Documentation

Overview

Package healthcare provides access to the Cloud Healthcare API.

For product documentation, see: https://cloud.google.com/healthcare

Creating a client

Usage example: 

import "google.golang.org/api/healthcare/v1"
...
ctx := context.Background()
healthcareService, err := healthcare.NewService(ctx)

In this example, Google Application Default Credentials are used for authentication.

For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials.

Other authentication options

To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey: 

healthcareService, err := healthcare.NewService(ctx, option.WithAPIKey("AIza..."))

To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource: 

config := &oauth2.Config{...}
// ...
token, err := config.Exchange(ctx, ...)
healthcareService, err := healthcare.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))

See https://godoc.org/google.golang.org/api/option/ for details on options.

Index

Constants

View Source 
const (
	// View and manage your data across Google Cloud Platform services
	CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
)

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type AuditConfig 

    type AuditConfig struct {
	// AuditLogConfigs: The configuration for logging of each type of
	// permission.
	AuditLogConfigs []*AuditLogConfig `json:"auditLogConfigs,omitempty"`

	// Service: 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 `json:"service,omitempty"`

	// ForceSendFields is a list of field names (e.g. "AuditLogConfigs") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "AuditLogConfigs") to
	// include in API requests with the JSON null value. By default, fields
	// with empty values are omitted from API requests. However, any field
	// with an empty value appearing in NullFields will be sent to the
	// server as null. It is an error if a field in this list has a
	// non-empty value. This may be used to include null fields in Patch
	// requests.
	NullFields []string `json:"-"`
}

      AuditConfig: 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.

      func (*AuditConfig) MarshalJSON 

      func (s *AuditConfig) MarshalJSON() ([]byte, error)

      type AuditLogConfig 

      type AuditLogConfig struct {
	// ExemptedMembers: Specifies the identities that do not cause logging
	// for this type of permission. Follows the same format of
	// Binding.members.
	ExemptedMembers []string `json:"exemptedMembers,omitempty"`

	// LogType: The log type that this config enables.
	//
	// Possible values:
	//   "LOG_TYPE_UNSPECIFIED" - Default case. Should never be this.
	//   "ADMIN_READ" - Admin reads. Example: CloudIAM getIamPolicy
	//   "DATA_WRITE" - Data writes. Example: CloudSQL Users create
	//   "DATA_READ" - Data reads. Example: CloudSQL Users list
	LogType string `json:"logType,omitempty"`

	// ForceSendFields is a list of field names (e.g. "ExemptedMembers") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "ExemptedMembers") to
	// include in API requests with the JSON null value. By default, fields
	// with empty values are omitted from API requests. However, any field
	// with an empty value appearing in NullFields will be sent to the
	// server as null. It is an error if a field in this list has a
	// non-empty value. This may be used to include null fields in Patch
	// requests.
	NullFields []string `json:"-"`
}

        AuditLogConfig: 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.

        func (*AuditLogConfig) MarshalJSON 

        func (s *AuditLogConfig) MarshalJSON() ([]byte, error)

        type Binding 

        type Binding struct {
	// Condition: The condition that is associated with this binding. If the
	// condition evaluates to `true`, then this binding applies to the
	// current request. If the condition evaluates to `false`, then this
	// binding does not apply to the current request. However, a different
	// role binding might grant the same role to one or more of the members
	// in this binding. To learn which resources support conditions in their
	// IAM policies, see the IAM documentation
	// (https://cloud.google.com/iam/help/conditions/resource-policies).
	Condition *Expr `json:"condition,omitempty"`

	// Members: 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`. * `deleted:user:{emailid}?uid={uniqueid}`: An
	// email address (plus unique identifier) representing a user that has
	// been recently deleted. For example,
	// `alice@example.com?uid=123456789012345678901`. If the user is
	// recovered, this value reverts to `user:{emailid}` and the recovered
	// user retains the role in the binding. *
	// `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address
	// (plus unique identifier) representing a service account that has been
	// recently deleted. For example,
	// `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`.
	// If the service account is undeleted, this value reverts to
	// `serviceAccount:{emailid}` and the undeleted service account retains
	// the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`:
	// An email address (plus unique identifier) representing a Google group
	// that has been recently deleted. For example,
	// `admins@example.com?uid=123456789012345678901`. If the group is
	// recovered, this value reverts to `group:{emailid}` and the recovered
	// group retains the role in the binding. * `domain:{domain}`: The G
	// Suite domain (primary) that represents all the users of that domain.
	// For example, `google.com` or `example.com`.
	Members []string `json:"members,omitempty"`

	// Role: Role that is assigned to `members`. For example,
	// `roles/viewer`, `roles/editor`, or `roles/owner`.
	Role string `json:"role,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Condition") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Condition") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

          Binding: Associates `members` with a `role`.

          func (*Binding) MarshalJSON 

          func (s *Binding) MarshalJSON() ([]byte, error)

          type CancelOperationRequest 

          type CancelOperationRequest struct {
}

            CancelOperationRequest: The request message for Operations.CancelOperation.

            type CharacterMaskConfig 

            type CharacterMaskConfig struct {
	// MaskingCharacter: Character to mask the sensitive values. If not
	// supplied, defaults to "*".
	MaskingCharacter string `json:"maskingCharacter,omitempty"`

	// ForceSendFields is a list of field names (e.g. "MaskingCharacter") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "MaskingCharacter") to
	// include in API requests with the JSON null value. By default, fields
	// with empty values are omitted from API requests. However, any field
	// with an empty value appearing in NullFields will be sent to the
	// server as null. It is an error if a field in this list has a
	// non-empty value. This may be used to include null fields in Patch
	// requests.
	NullFields []string `json:"-"`
}

              CharacterMaskConfig: Mask a string by replacing its characters with a fixed character.

              func (*CharacterMaskConfig) MarshalJSON 

              func (s *CharacterMaskConfig) MarshalJSON() ([]byte, error)

              type CreateMessageRequest 

              type CreateMessageRequest struct {
	// Message: HL7v2 message.
	Message *Message `json:"message,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Message") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Message") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                CreateMessageRequest: Creates a new message.

                func (*CreateMessageRequest) MarshalJSON 

                func (s *CreateMessageRequest) MarshalJSON() ([]byte, error)

                type CryptoHashConfig 

                type CryptoHashConfig struct {
	// CryptoKey: An AES 128/192/256 bit key. Causes the hash to be computed
	// based on this key. A default key is generated for each Deidentify
	// operation and is used wherever crypto_key is not specified.
	CryptoKey string `json:"cryptoKey,omitempty"`

	// ForceSendFields is a list of field names (e.g. "CryptoKey") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "CryptoKey") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                  CryptoHashConfig: Pseudonymization method that generates surrogates via cryptographic hashing. Uses SHA-256. Outputs a base64-encoded representation of the hashed output (for example, `L7k0BHmF1ha5U3NfGykjro4xWi1MPVQPjhMAZbSV9mM=`).

                  func (*CryptoHashConfig) MarshalJSON 

                  func (s *CryptoHashConfig) MarshalJSON() ([]byte, error)

                  type Dataset 

                  type Dataset struct {
	// Name: Resource name of the dataset, of the form
	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`.
	Name string `json:"name,omitempty"`

	// TimeZone: 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,
	// such as HL7 messages, where no explicit timezone is specified.
	TimeZone string `json:"timeZone,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "Name") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Name") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                    Dataset: 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.

                    func (*Dataset) MarshalJSON 

                    func (s *Dataset) MarshalJSON() ([]byte, error)

                    type DateShiftConfig 

                    type DateShiftConfig struct {
	// CryptoKey: 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 Deidentify operation and is used wherever
	// crypto_key is not specified.
	CryptoKey string `json:"cryptoKey,omitempty"`

	// ForceSendFields is a list of field names (e.g. "CryptoKey") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "CryptoKey") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                      DateShiftConfig: Shift a date forward or backward in time by a random amount which is consistent for a given patient and crypto key combination.

                      func (*DateShiftConfig) MarshalJSON 

                      func (s *DateShiftConfig) MarshalJSON() ([]byte, error)

                      type DeidentifyConfig 

                      type DeidentifyConfig struct {
	// Dicom: Configures de-id of application/DICOM content.
	Dicom *DicomConfig `json:"dicom,omitempty"`

	// Fhir: Configures de-id of application/FHIR content.
	Fhir *FhirConfig `json:"fhir,omitempty"`

	// Image: Configures de-identification of image pixels wherever they are
	// found in the source_dataset.
	Image *ImageConfig `json:"image,omitempty"`

	// Text: Configures de-identification of text wherever it is found in
	// the source_dataset.
	Text *TextConfig `json:"text,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Dicom") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Dicom") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                        DeidentifyConfig: 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.

                        func (*DeidentifyConfig) MarshalJSON 

                        func (s *DeidentifyConfig) MarshalJSON() ([]byte, error)

                        type DeidentifyDatasetRequest 

                        type DeidentifyDatasetRequest struct {
	// Config: Deidentify configuration.
	Config *DeidentifyConfig `json:"config,omitempty"`

	// DestinationDataset: The name of the dataset resource to create and
	// write the redacted data to. * The destination dataset must not exist.
	// * The destination dataset must be in the same project and location as
	// the source dataset. De-identifying data across multiple projects or
	// locations is not supported.
	DestinationDataset string `json:"destinationDataset,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Config") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Config") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                          DeidentifyDatasetRequest: Redacts identifying information from the specified dataset.

                          func (*DeidentifyDatasetRequest) MarshalJSON 

                          func (s *DeidentifyDatasetRequest) MarshalJSON() ([]byte, error)

                          type DeidentifyDicomStoreRequest 

                          type DeidentifyDicomStoreRequest struct {
	// Config: De-identify configuration.
	Config *DeidentifyConfig `json:"config,omitempty"`

	// DestinationStore: The name of the DICOM store to create and write the
	// redacted data to. For example,
	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/d
	// icomStores/{dicom_store_id}`. * The destination dataset must exist. *
	// The source dataset and destination dataset must both reside in the
	// same project. De-identifying data across multiple projects is not
	// supported. * The destination DICOM store must not exist. * The caller
	// must have the necessary permissions to create the destination DICOM
	// store.
	DestinationStore string `json:"destinationStore,omitempty"`

	// FilterConfig: Filter configuration.
	FilterConfig *DicomFilterConfig `json:"filterConfig,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Config") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Config") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                            DeidentifyDicomStoreRequest: Creates a new DICOM store with sensitive information de-identified.

                            func (*DeidentifyDicomStoreRequest) MarshalJSON 

                            func (s *DeidentifyDicomStoreRequest) MarshalJSON() ([]byte, error)

                            type DeidentifyFhirStoreRequest 

                            type DeidentifyFhirStoreRequest struct {
	// Config: Deidentify configuration.
	Config *DeidentifyConfig `json:"config,omitempty"`

	// DestinationStore: The name of the FHIR store to create and write the
	// redacted data to. For example,
	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/f
	// hirStores/{fhir_store_id}`. * The destination dataset must exist. *
	// The source dataset and destination dataset must both reside in the
	// same project. De-identifying data across multiple projects is not
	// supported. * The destination FHIR store must exist. * The caller must
	// have the healthcare.fhirResources.update permission to write to the
	// destination FHIR store.
	DestinationStore string `json:"destinationStore,omitempty"`

	// ResourceFilter: A filter specifying the resources to include in the
	// output. If not specified, all resources are included in the output.
	ResourceFilter *FhirFilter `json:"resourceFilter,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Config") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Config") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                              DeidentifyFhirStoreRequest: Creates a new FHIR store with sensitive information de-identified.

                              func (*DeidentifyFhirStoreRequest) MarshalJSON 

                              func (s *DeidentifyFhirStoreRequest) MarshalJSON() ([]byte, error)

                              type DeidentifySummary 

                              type DeidentifySummary struct {
}

                                DeidentifySummary: Contains a summary of the Deidentify operation.

                                type DicomConfig 

                                type DicomConfig struct {
	// FilterProfile: Tag filtering profile that determines which tags to
	// keep/remove.
	//
	// Possible values:
	//   "TAG_FILTER_PROFILE_UNSPECIFIED" - No tag filtration profile
	// provided. Same as KEEP_ALL_PROFILE.
	//   "MINIMAL_KEEP_LIST_PROFILE" - Keep only tags required to produce
	// valid DICOM.
	//   "ATTRIBUTE_CONFIDENTIALITY_BASIC_PROFILE" - Remove tags based on
	// DICOM Standard's Attribute Confidentiality Basic Profile (DICOM
	// Standard Edition 2018e)
	// http://dicom.nema.org/medical/dicom/2018e/output/chtml/part15/chapter_E.html.
	//   "KEEP_ALL_PROFILE" - Keep all tags.
	//   "DEIDENTIFY_TAG_CONTENTS" - Inspects within tag contents and
	// replaces sensitive text. The process can be configured using the
	// TextConfig. Applies to all tags with the following Value
	// Representation names: AE, LO, LT, PN, SH, ST, UC, UT, DA, DT, AS
	FilterProfile string `json:"filterProfile,omitempty"`

	// KeepList: List of tags to keep. Remove all other tags.
	KeepList *TagFilterList `json:"keepList,omitempty"`

	// RemoveList: List of tags to remove. Keep all other tags.
	RemoveList *TagFilterList `json:"removeList,omitempty"`

	// SkipIdRedaction: If true, skip replacing StudyInstanceUID,
	// SeriesInstanceUID, SOPInstanceUID, and MediaStorageSOPInstanceUID and
	// leave them untouched. The Cloud Healthcare API regenerates these UIDs
	// by default based on the DICOM Standard's reasoning: "Whilst these
	// UIDs cannot be mapped directly to an individual out of context, given
	// access to the original images, or to a database of the original
	// images containing the UIDs, it would be possible to recover the
	// individual's identity."
	// http://dicom.nema.org/medical/dicom/current/output/chtml/part15/sect_E.3.9.html
	SkipIdRedaction bool `json:"skipIdRedaction,omitempty"`

	// ForceSendFields is a list of field names (e.g. "FilterProfile") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "FilterProfile") to include
	// in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. However, any field with
	// an empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                  DicomConfig: Specifies the parameters needed for de-identification of DICOM stores.

                                  func (*DicomConfig) MarshalJSON 

                                  func (s *DicomConfig) MarshalJSON() ([]byte, error)

                                  type DicomFilterConfig 

                                  type DicomFilterConfig struct {
	// ResourcePathsGcsUri: The Cloud Storage location of the filter
	// configuration file. The `gcs_uri` must be in the format
	// `gs://bucket/path/to/object`. The filter configuration file must
	// contain a list of resource paths separated by newline characters (\n
	// or \r\n). Each resource path must be in the format
	// "/studies/{studyUID}[/series/{seriesUID}[/instances/{instanceUID}]]"
	// The Cloud Healthcare API service account must have the
	// `roles/storage.objectViewer` Cloud IAM role for this Cloud Storage
	// location.
	ResourcePathsGcsUri string `json:"resourcePathsGcsUri,omitempty"`

	// ForceSendFields is a list of field names (e.g. "ResourcePathsGcsUri")
	// to unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "ResourcePathsGcsUri") to
	// include in API requests with the JSON null value. By default, fields
	// with empty values are omitted from API requests. However, any field
	// with an empty value appearing in NullFields will be sent to the
	// server as null. It is an error if a field in this list has a
	// non-empty value. This may be used to include null fields in Patch
	// requests.
	NullFields []string `json:"-"`
}

                                    DicomFilterConfig: Specifies the filter configuration for DICOM resources.

                                    func (*DicomFilterConfig) MarshalJSON 

                                    func (s *DicomFilterConfig) MarshalJSON() ([]byte, error)

                                    type DicomStore 

                                    type DicomStore struct {
	// Labels: 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 map[string]string `json:"labels,omitempty"`

	// Name: Resource name of the DICOM store, of the form
	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/d
	// icomStores/{dicom_store_id}`.
	Name string `json:"name,omitempty"`

	// NotificationConfig: Notification destination for new DICOM instances.
	// Supplied by the client.
	NotificationConfig *NotificationConfig `json:"notificationConfig,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "Labels") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Labels") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                      DicomStore: Represents a DICOM store.

                                      func (*DicomStore) MarshalJSON 

                                      func (s *DicomStore) MarshalJSON() ([]byte, error)

                                      type Empty 

                                      type Empty struct {
	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`
}

                                        Empty: 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 `{}`.

                                        type ExportDicomDataRequest 

                                        type ExportDicomDataRequest struct {
	// BigqueryDestination: 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 Cloud Healthcare Service Agent
	// requires two IAM roles on the BigQuery location:
	// `roles/bigquery.dataEditor` and `roles/bigquery.jobUser`.
	BigqueryDestination *GoogleCloudHealthcareV1DicomBigQueryDestination `json:"bigqueryDestination,omitempty"`

	// GcsDestination: The Cloud Storage output destination. The Cloud
	// Healthcare Service Agent requires the `roles/storage.objectAdmin`
	// Cloud IAM roles on the Cloud Storage location.
	GcsDestination *GoogleCloudHealthcareV1DicomGcsDestination `json:"gcsDestination,omitempty"`

	// ForceSendFields is a list of field names (e.g. "BigqueryDestination")
	// to unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "BigqueryDestination") to
	// include in API requests with the JSON null value. By default, fields
	// with empty values are omitted from API requests. However, any field
	// with an empty value appearing in NullFields will be sent to the
	// server as null. It is an error if a field in this list has a
	// non-empty value. This may be used to include null fields in Patch
	// requests.
	NullFields []string `json:"-"`
}

                                          ExportDicomDataRequest: Exports data from the specified DICOM store. If a given resource, such as 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 persists when the DICOM store from which it was exported is deleted.

                                          func (*ExportDicomDataRequest) MarshalJSON 

                                          func (s *ExportDicomDataRequest) MarshalJSON() ([]byte, error)

                                          type ExportDicomDataResponse 

                                          type ExportDicomDataResponse struct {
}

                                            ExportDicomDataResponse: Returns additional information in regards to a completed DICOM store export.

                                            type ExportResourcesRequest 

                                            type ExportResourcesRequest struct {
	// BigqueryDestination: The BigQuery output destination. The Cloud
	// Healthcare Service Agent requires two IAM roles on the BigQuery
	// location: `roles/bigquery.dataEditor` and `roles/bigquery.jobUser`.
	// The output is one BigQuery table per resource type.
	BigqueryDestination *GoogleCloudHealthcareV1FhirBigQueryDestination `json:"bigqueryDestination,omitempty"`

	// GcsDestination: The Cloud Storage output destination. The Healthcare
	// Service Agent account requires the `roles/storage.objectAdmin` role
	// on the Cloud Storage location. The exported outputs are organized by
	// FHIR resource types. The server creates one object per resource type.
	// Each object contains newline delimited JSON, and each line is a FHIR
	// resource.
	GcsDestination *GoogleCloudHealthcareV1FhirGcsDestination `json:"gcsDestination,omitempty"`

	// ForceSendFields is a list of field names (e.g. "BigqueryDestination")
	// to unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "BigqueryDestination") to
	// include in API requests with the JSON null value. By default, fields
	// with empty values are omitted from API requests. However, any field
	// with an empty value appearing in NullFields will be sent to the
	// server as null. It is an error if a field in this list has a
	// non-empty value. This may be used to include null fields in Patch
	// requests.
	NullFields []string `json:"-"`
}

                                              ExportResourcesRequest: Request to export resources.

                                              func (*ExportResourcesRequest) MarshalJSON 

                                              func (s *ExportResourcesRequest) MarshalJSON() ([]byte, error)

                                              type ExportResourcesResponse 

                                              type ExportResourcesResponse struct {
}

                                                ExportResourcesResponse: Response when all resources export successfully. This structure is included in the response to describe the detailed outcome after the operation finishes successfully.

                                                type Expr 

                                                type Expr struct {
	// Description: 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 `json:"description,omitempty"`

	// Expression: Textual representation of an expression in Common
	// Expression Language syntax.
	Expression string `json:"expression,omitempty"`

	// Location: Optional. String indicating the location of the expression
	// for error reporting, e.g. a file name and a position in the file.
	Location string `json:"location,omitempty"`

	// Title: 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 `json:"title,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Description") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Description") to include
	// in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. However, any field with
	// an empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                  Expr: Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.

                                                  func (*Expr) MarshalJSON 

                                                  func (s *Expr) MarshalJSON() ([]byte, error)

                                                  type FhirConfig 

                                                  type FhirConfig struct {
	// FieldMetadataList: Specifies FHIR paths to match and how to transform
	// them. Any field that is not matched by a FieldMetadata is passed
	// through to the output dataset unmodified. All extensions are removed
	// in the output.
	FieldMetadataList []*FieldMetadata `json:"fieldMetadataList,omitempty"`

	// ForceSendFields is a list of field names (e.g. "FieldMetadataList")
	// to unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "FieldMetadataList") to
	// include in API requests with the JSON null value. By default, fields
	// with empty values are omitted from API requests. However, any field
	// with an empty value appearing in NullFields will be sent to the
	// server as null. It is an error if a field in this list has a
	// non-empty value. This may be used to include null fields in Patch
	// requests.
	NullFields []string `json:"-"`
}

                                                    FhirConfig: Specifies how to handle de-identification of a FHIR store.

                                                    func (*FhirConfig) MarshalJSON 

                                                    func (s *FhirConfig) MarshalJSON() ([]byte, error)

                                                    type FhirFilter 

                                                    type FhirFilter struct {
	// Resources: List of resources to include in the output. If this list
	// is empty or not specified, all resources are included in the output.
	Resources *Resources `json:"resources,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Resources") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Resources") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                      FhirFilter: Filter configuration.

                                                      func (*FhirFilter) MarshalJSON 

                                                      func (s *FhirFilter) MarshalJSON() ([]byte, error)

                                                      type FhirStore 

                                                      type FhirStore struct {
	// DisableReferentialIntegrity: Immutable. 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 enforces referential integrity and fails the requests that
	// result in inconsistent state in the FHIR store. When this field is
	// set to true, the API skips referential integrity checks.
	// Consequently, operations that rely on references, such as
	// GetPatientEverything, do not return all the results if broken
	// references exist.
	DisableReferentialIntegrity bool `json:"disableReferentialIntegrity,omitempty"`

	// DisableResourceVersioning: Immutable. 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 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 are kept. The server sends errors for attempts to
	// read the historical versions.
	DisableResourceVersioning bool `json:"disableResourceVersioning,omitempty"`

	// EnableUpdateCreate: 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 return errors. It is strongly advised not to
	// include or encode any sensitive data such as patient identifiers in
	// client-specified resource IDs. Those IDs are part of the FHIR
	// resource path recorded in Cloud audit logs and Cloud Pub/Sub
	// notifications. Those IDs can also be contained in reference fields
	// within other resources.
	EnableUpdateCreate bool `json:"enableUpdateCreate,omitempty"`

	// Labels: 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 map[string]string `json:"labels,omitempty"`

	// Name: Output only. Resource name of the FHIR store, of the form
	// `projects/{project_id}/datasets/{dataset_id}/fhirStores/{fhir_store_id
	// }`.
	Name string `json:"name,omitempty"`

	// NotificationConfig: If non-empty, publish all resource modifications
	// of this FHIR store to this destination. The Cloud Pub/Sub message
	// attributes contain a map with a string describing the action that has
	// triggered the notification. For example, "action":"CreateResource".
	NotificationConfig *NotificationConfig `json:"notificationConfig,omitempty"`

	// StreamConfigs: 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 is streamed
	// to the new location in addition to the existing ones. When a location
	// is removed from the list, the server stops 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 []*StreamConfig `json:"streamConfigs,omitempty"`

	// Version: Immutable. The FHIR specification version that this FHIR
	// store supports natively. This field is immutable after store
	// creation. Requests are rejected if they contain FHIR resources of a
	// different version. Version is required for every FHIR store.
	//
	// Possible values:
	//   "VERSION_UNSPECIFIED" - Users must specify a version on store
	// creation or an error is returned.
	//   "DSTU2" - Draft Standard for Trial Use, [Release
	// 2](https://www.hl7.org/fhir/DSTU2)
	//   "STU3" - Standard for Trial Use, [Release
	// 3](https://www.hl7.org/fhir/STU3)
	//   "R4" - [Release 4](https://www.hl7.org/fhir/R4)
	Version string `json:"version,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g.
	// "DisableReferentialIntegrity") to unconditionally include in API
	// requests. By default, fields with empty values are omitted from API
	// requests. However, any non-pointer, non-interface field appearing in
	// ForceSendFields will be sent to the server regardless of whether the
	// field is empty or not. This may be used to include empty fields in
	// Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g.
	// "DisableReferentialIntegrity") to include in API requests with the
	// JSON null value. By default, fields with empty values are omitted
	// from API requests. However, any field with an empty value appearing
	// in NullFields will be sent to the server as null. It is an error if a
	// field in this list has a non-empty value. This may be used to include
	// null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                        FhirStore: Represents a FHIR store.

                                                        func (*FhirStore) MarshalJSON 

                                                        func (s *FhirStore) MarshalJSON() ([]byte, error)

                                                        type FieldMetadata 

                                                        type FieldMetadata struct {
	// Action: Deidentify action for one field.
	//
	// Possible values:
	//   "ACTION_UNSPECIFIED" - No action specified.
	//   "TRANSFORM" - Transform the entire field.
	//   "INSPECT_AND_TRANSFORM" - Inspect and transform any found PHI.
	//   "DO_NOT_TRANSFORM" - Do not transform.
	Action string `json:"action,omitempty"`

	// Paths: 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. For example, "deceasedAge.unit" is matched by
	// "Deceased.Age.unit". Supported types are: AdministrativeGenderCode,
	// Code, Date, DateTime, Decimal, HumanName, Id, LanguageCode, Markdown,
	// Oid, String, Uri, Uuid, Xhtml. Base64Binary is also supported, but
	// may only be kept as-is or have all the content removed.
	Paths []string `json:"paths,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Action") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Action") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                          FieldMetadata: Specifies FHIR paths to match, and how to handle de-identification of matching fields.

                                                          func (*FieldMetadata) MarshalJSON 

                                                          func (s *FieldMetadata) MarshalJSON() ([]byte, error)

                                                          type GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary 

                                                          type GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary struct {
}

                                                            GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary: Contains a summary of the DeidentifyDicomStore operation.

                                                            type GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary 

                                                            type GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary struct {
}

                                                              GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary: Contains a summary of the DeidentifyFhirStore operation.

                                                              type GoogleCloudHealthcareV1DicomBigQueryDestination 

                                                              type GoogleCloudHealthcareV1DicomBigQueryDestination struct {
	// Force: If the destination table already exists and this flag is
	// `TRUE`, the table is 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 bool `json:"force,omitempty"`

	// TableUri: BigQuery URI to a table, up to 2000 characters long, in the
	// format `bq://projectId.bqDatasetId.tableId`
	TableUri string `json:"tableUri,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Force") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Force") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                GoogleCloudHealthcareV1DicomBigQueryDestination: The BigQuery table where the server writes the output.

                                                                func (*GoogleCloudHealthcareV1DicomBigQueryDestination) MarshalJSON 

                                                                func (s *GoogleCloudHealthcareV1DicomBigQueryDestination) MarshalJSON() ([]byte, error)

                                                                type GoogleCloudHealthcareV1DicomGcsDestination 

                                                                type GoogleCloudHealthcareV1DicomGcsDestination struct {
	// MimeType: MIME types supported by DICOM spec. Each file is written in
	// the following format:
	// `.../{study_id}/{series_id}/{instance_id}[/{frame_number}].{extension}
	// ` The frame_number component exists only for multi-frame instances.
	// Supported MIME types are consistent with supported formats in
	// DICOMweb:
	// https://cloud.google.com/healthcare/docs/dicom#retrieve_transaction.
	// Specifically, the following are supported: - application/dicom;
	// transfer-syntax=1.2.840.10008.1.2.1 (uncompressed DICOM) -
	// application/dicom; transfer-syntax=1.2.840.10008.1.2.4.50 (DICOM with
	// embedded JPEG Baseline) - application/dicom;
	// transfer-syntax=1.2.840.10008.1.2.4.90 (DICOM with embedded JPEG 2000
	// Lossless Only) - application/dicom;
	// transfer-syntax=1.2.840.10008.1.2.4.91 (DICOM with embedded JPEG
	// 2000) - application/dicom; transfer-syntax=* (DICOM with no
	// transcoding) - application/octet-stream;
	// transfer-syntax=1.2.840.10008.1.2.1 (raw uncompressed PixelData) -
	// application/octet-stream; transfer-syntax=* (raw PixelData in
	// whatever format it was uploaded in) - image/jpeg;
	// transfer-syntax=1.2.840.10008.1.2.4.50 (Consumer JPEG) - image/png
	// The following extensions are used for output files: -
	// application/dicom -> .dcm - image/jpeg -> .jpg - image/png -> .png -
	// application/octet-stream -> no extension If unspecified, the
	// instances are exported in the original DICOM format they were
	// uploaded in.
	MimeType string `json:"mimeType,omitempty"`

	// UriPrefix: The Cloud Storage destination to export to. URI for a
	// Cloud Storage directory where the server writes the result files, in
	// the format `gs://{bucket-id}/{path/to/destination/dir}`). If there is
	// no trailing slash, the service appends one when composing the object
	// path. The user is responsible for creating the Cloud Storage bucket
	// referenced in `uri_prefix`.
	UriPrefix string `json:"uriPrefix,omitempty"`

	// ForceSendFields is a list of field names (e.g. "MimeType") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "MimeType") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                  GoogleCloudHealthcareV1DicomGcsDestination: The Cloud Storage location where the server writes the output and the export configuration.

                                                                  func (*GoogleCloudHealthcareV1DicomGcsDestination) MarshalJSON 

                                                                  func (s *GoogleCloudHealthcareV1DicomGcsDestination) MarshalJSON() ([]byte, error)

                                                                  type GoogleCloudHealthcareV1DicomGcsSource 

                                                                  type GoogleCloudHealthcareV1DicomGcsSource struct {
	// Uri: 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 `json:"uri,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Uri") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Uri") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                    GoogleCloudHealthcareV1DicomGcsSource: Specifies the configuration for importing data from Cloud Storage.

                                                                    func (*GoogleCloudHealthcareV1DicomGcsSource) MarshalJSON 

                                                                    func (s *GoogleCloudHealthcareV1DicomGcsSource) MarshalJSON() ([]byte, error)

                                                                    type GoogleCloudHealthcareV1FhirBigQueryDestination 

                                                                    type GoogleCloudHealthcareV1FhirBigQueryDestination struct {
	// DatasetUri: BigQuery URI to an existing dataset, up to 2000
	// characters long, in the format `bq://projectId.bqDatasetId`.
	DatasetUri string `json:"datasetUri,omitempty"`

	// Force: If this flag is `TRUE`, all tables are deleted from the
	// dataset before the new exported tables are written. If the flag is
	// not set and the destination dataset contains tables, the export call
	// returns an error. If `write_disposition` is specified, this parameter
	// is ignored. force=false is equivalent to
	// write_disposition=WRITE_EMPTY and force=true is equivalent to
	// write_disposition=WRITE_TRUNCATE.
	Force bool `json:"force,omitempty"`

	// SchemaConfig: The configuration for the exported BigQuery schema.
	SchemaConfig *SchemaConfig `json:"schemaConfig,omitempty"`

	// WriteDisposition: Determines whether existing tables in the
	// destination dataset are overwritten or appended to. If a
	// write_disposition is specified, the `force` parameter is ignored.
	//
	// Possible values:
	//   "WRITE_DISPOSITION_UNSPECIFIED" - Default behavior is the same as
	// WRITE_EMPTY.
	//   "WRITE_EMPTY" - Only export data if the destination tables are
	// empty.
	//   "WRITE_TRUNCATE" - Erase all existing data in a tables before
	// writing the instances.
	//   "WRITE_APPEND" - Append data to the existing tables.
	WriteDisposition string `json:"writeDisposition,omitempty"`

	// ForceSendFields is a list of field names (e.g. "DatasetUri") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "DatasetUri") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                      GoogleCloudHealthcareV1FhirBigQueryDestination: The configuration for exporting to BigQuery.

                                                                      func (*GoogleCloudHealthcareV1FhirBigQueryDestination) MarshalJSON 

                                                                      func (s *GoogleCloudHealthcareV1FhirBigQueryDestination) MarshalJSON() ([]byte, error)

                                                                      type GoogleCloudHealthcareV1FhirGcsDestination 

                                                                      type GoogleCloudHealthcareV1FhirGcsDestination struct {
	// UriPrefix: URI for a Cloud Storage directory where result files
	// should be written, in the format of
	// `gs://{bucket-id}/{path/to/destination/dir}`. If there is no trailing
	// slash, the service appends one when composing the object path. The
	// user is responsible for creating the Cloud Storage bucket referenced
	// in `uri_prefix`.
	UriPrefix string `json:"uriPrefix,omitempty"`

	// ForceSendFields is a list of field names (e.g. "UriPrefix") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "UriPrefix") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                        GoogleCloudHealthcareV1FhirGcsDestination: The configuration for exporting to Cloud Storage.

                                                                        func (*GoogleCloudHealthcareV1FhirGcsDestination) MarshalJSON 

                                                                        func (s *GoogleCloudHealthcareV1FhirGcsDestination) MarshalJSON() ([]byte, error)

                                                                        type GoogleCloudHealthcareV1FhirGcsSource 

                                                                        type GoogleCloudHealthcareV1FhirGcsSource struct {
	// Uri: 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 `json:"uri,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Uri") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Uri") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                          GoogleCloudHealthcareV1FhirGcsSource: Specifies the configuration for importing data from Cloud Storage.

                                                                          func (*GoogleCloudHealthcareV1FhirGcsSource) MarshalJSON 

                                                                          func (s *GoogleCloudHealthcareV1FhirGcsSource) MarshalJSON() ([]byte, error)

                                                                          type Hl7V2NotificationConfig 

                                                                          type Hl7V2NotificationConfig struct {
	// Filter: Restricts notifications sent for messages matching a filter.
	// If this is empty, all messages are matched. Syntax:
	// https://cloud.google.com/appengine/docs/standard/python/search/query_strings
	// The following fields and functions are available for filtering: *
	// `message_type`, from the MSH-9.1 field. For example, `NOT
	// message_type = "ADT". * `send_date` or `sendDate`, the YYYY-MM-DD
	// date the message was sent in the dataset's time_zone, from the MSH-7
	// segment. For example, `send_date < "2017-01-02". * `send_time`, the
	// timestamp when the message was sent, using the RFC3339 time format
	// for comparisons, from the MSH-7 segment. For example, `send_time <
	// "2017-01-02T00:00:00-05:00". * `send_facility`, the care center that
	// the message came from, from the MSH-4 segment. For example,
	// `send_facility = "ABC". * `PatientId(value, type)`, which matches if
	// the message lists a patient having an ID of the given value and type
	// in the PID-2, PID-3, or PID-4 segments. For example,
	// `PatientId("123456", "MRN")`. * `labels.x`, a string value of the
	// label with key `x` as set using the Message.labels map. For example,
	// `labels."priority"="high". The operator `:*` can be used to assert
	// the existence of a label. For example, `labels."priority":*`.
	Filter string `json:"filter,omitempty"`

	// PubsubTopic: The Cloud Pub/Sub
	// (https://cloud.google.com/pubsub/docs/) topic that notifications of
	// changes are published on. Supplied by the client. The notification is
	// a `PubsubMessage` with the following fields: * `PubsubMessage.Data`
	// contains the resource name. * `PubsubMessage.MessageId` is the ID of
	// this notification. It's guaranteed to be unique within the topic. *
	// `PubsubMessage.PublishTime` is the time when the message was
	// published. Note that notifications are only sent if the topic is
	// non-empty. Topic names
	// (https://cloud.google.com/pubsub/docs/overview#names) must be scoped
	// to a project. The Cloud Healthcare API service account,
	// service-PROJECT_NUMBER@gcp-sa-healthcare.iam.gserviceaccount.com,
	// must have publisher permissions on the given Pub/Sub topic. Not
	// having adequate permissions causes the calls that send notifications
	// to fail. If a notification cannot be published to Cloud Pub/Sub,
	// errors are logged to Cloud Logging. For more information, see Viewing
	// error logs in Cloud Logging (/healthcare/docs/how-tos/logging)).
	PubsubTopic string `json:"pubsubTopic,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Filter") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Filter") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                            Hl7V2NotificationConfig: Specifies where and whether to send notifications upon changes to a data store.

                                                                            func (*Hl7V2NotificationConfig) MarshalJSON 

                                                                            func (s *Hl7V2NotificationConfig) MarshalJSON() ([]byte, error)

                                                                            type Hl7V2Store 

                                                                            type Hl7V2Store struct {
	// Labels: 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 map[string]string `json:"labels,omitempty"`

	// Name: Resource name of the HL7v2 store, of the form
	// `projects/{project_id}/datasets/{dataset_id}/hl7V2Stores/{hl7v2_store_
	// id}`.
	Name string `json:"name,omitempty"`

	// NotificationConfigs: A list of notification configs. Each
	// configuration uses a filter to determine whether to publish a message
	// (both Ingest & Create) on the corresponding notification destination.
	// Only the message name is sent as part of the notification. Supplied
	// by the client.
	NotificationConfigs []*Hl7V2NotificationConfig `json:"notificationConfigs,omitempty"`

	// ParserConfig: The configuration for the parser. It determines how the
	// server parses the messages.
	ParserConfig *ParserConfig `json:"parserConfig,omitempty"`

	// RejectDuplicateMessage: Determines whether to reject duplicate
	// messages. A duplicate message is a message with the same raw bytes as
	// a message that has already been ingested/created in this HL7v2 store.
	// The default value is false, meaning that the store accepts the
	// duplicate messages and it also returns the same ACK message in the
	// IngestMessageResponse as has been returned previously. Note that only
	// one resource is created in the store. When this field is set to true,
	// CreateMessage/IngestMessage requests with a duplicate message will be
	// rejected by the store, and IngestMessageErrorDetail returns a NACK
	// message upon rejection.
	RejectDuplicateMessage bool `json:"rejectDuplicateMessage,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "Labels") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Labels") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                              Hl7V2Store: Represents an HL7v2 store.

                                                                              func (*Hl7V2Store) MarshalJSON 

                                                                              func (s *Hl7V2Store) MarshalJSON() ([]byte, error)

                                                                              type HttpBody 

                                                                              type HttpBody struct {
	// ContentType: The HTTP Content-Type header value specifying the
	// content type of the body.
	ContentType string `json:"contentType,omitempty"`

	// Data: The HTTP request/response body as raw binary.
	Data string `json:"data,omitempty"`

	// Extensions: Application specific response metadata. Must be set in
	// the first response for streaming APIs.
	Extensions []googleapi.RawMessage `json:"extensions,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "ContentType") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "ContentType") to include
	// in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. However, any field with
	// an empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                HttpBody: 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.

                                                                                func (*HttpBody) MarshalJSON 

                                                                                func (s *HttpBody) MarshalJSON() ([]byte, error)

                                                                                type ImageConfig 

                                                                                type ImageConfig struct {
	// TextRedactionMode: Determines how to redact text from image.
	//
	// Possible values:
	//   "TEXT_REDACTION_MODE_UNSPECIFIED" - No text redaction specified.
	// Same as REDACT_NO_TEXT.
	//   "REDACT_ALL_TEXT" - Redact all text.
	//   "REDACT_SENSITIVE_TEXT" - Redact sensitive text.
	//   "REDACT_NO_TEXT" - Do not redact text.
	TextRedactionMode string `json:"textRedactionMode,omitempty"`

	// ForceSendFields is a list of field names (e.g. "TextRedactionMode")
	// to unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "TextRedactionMode") to
	// include in API requests with the JSON null value. By default, fields
	// with empty values are omitted from API requests. However, any field
	// with an empty value appearing in NullFields will be sent to the
	// server as null. It is an error if a field in this list has a
	// non-empty value. This may be used to include null fields in Patch
	// requests.
	NullFields []string `json:"-"`
}

                                                                                  ImageConfig: Specifies how to handle de-identification of image pixels.

                                                                                  func (*ImageConfig) MarshalJSON 

                                                                                  func (s *ImageConfig) MarshalJSON() ([]byte, error)

                                                                                  type ImportDicomDataRequest 

                                                                                  type ImportDicomDataRequest struct {
	// GcsSource: Cloud Storage source data location and import
	// configuration. The Cloud Healthcare Service Agent requires the
	// `roles/storage.objectViewer` Cloud IAM roles on the Cloud Storage
	// location.
	GcsSource *GoogleCloudHealthcareV1DicomGcsSource `json:"gcsSource,omitempty"`

	// ForceSendFields is a list of field names (e.g. "GcsSource") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "GcsSource") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                    ImportDicomDataRequest: Imports data into the specified DICOM store. Returns an error if any of the files to import are not DICOM files. This API accepts duplicate DICOM instances by ignoring the newly-pushed instance. It does not overwrite.

                                                                                    func (*ImportDicomDataRequest) MarshalJSON 

                                                                                    func (s *ImportDicomDataRequest) MarshalJSON() ([]byte, error)

                                                                                    type ImportDicomDataResponse 

                                                                                    type ImportDicomDataResponse struct {
}

                                                                                      ImportDicomDataResponse: Returns additional information in regards to a completed DICOM store import.

                                                                                      type ImportResourcesRequest 

                                                                                      type ImportResourcesRequest struct {
	// ContentStructure: The content structure in the source location. If
	// not specified, the server treats the input source files as BUNDLE.
	//
	// Possible values:
	//   "CONTENT_STRUCTURE_UNSPECIFIED" - If the content structure is not
	// specified, the default value `BUNDLE` is used.
	//   "BUNDLE" - The source file contains one or more lines of
	// newline-delimited JSON (ndjson). Each line is a bundle that contains
	// one or more resources.
	//   "RESOURCE" - The source file contains one or more lines of
	// newline-delimited JSON (ndjson). Each line is a single resource.
	//   "BUNDLE_PRETTY" - The entire file is one JSON bundle. The JSON can
	// span multiple lines.
	//   "RESOURCE_PRETTY" - The entire file is one JSON resource. The JSON
	// can span multiple lines.
	ContentStructure string `json:"contentStructure,omitempty"`

	// GcsSource: Cloud Storage source data location and import
	// configuration. The Healthcare Service Agent account requires the
	// `roles/storage.objectAdmin` role on the Cloud Storage location. Each
	// Cloud Storage object should be a text file that contains the format
	// specified in ContentStructure.
	GcsSource *GoogleCloudHealthcareV1FhirGcsSource `json:"gcsSource,omitempty"`

	// ForceSendFields is a list of field names (e.g. "ContentStructure") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "ContentStructure") to
	// include in API requests with the JSON null value. By default, fields
	// with empty values are omitted from API requests. However, any field
	// with an empty value appearing in NullFields will be sent to the
	// server as null. It is an error if a field in this list has a
	// non-empty value. This may be used to include null fields in Patch
	// requests.
	NullFields []string `json:"-"`
}

                                                                                        ImportResourcesRequest: Request to import resources.

                                                                                        func (*ImportResourcesRequest) MarshalJSON 

                                                                                        func (s *ImportResourcesRequest) MarshalJSON() ([]byte, error)

                                                                                        type ImportResourcesResponse 

                                                                                        type ImportResourcesResponse struct {
}

                                                                                          ImportResourcesResponse: Final response of importing resources. This structure is included in the response to describe the detailed outcome after the operation finishes successfully.

                                                                                          type InfoTypeTransformation 

                                                                                          type InfoTypeTransformation struct {
	// CharacterMaskConfig: Config for character mask.
	CharacterMaskConfig *CharacterMaskConfig `json:"characterMaskConfig,omitempty"`

	// CryptoHashConfig: Config for crypto hash.
	CryptoHashConfig *CryptoHashConfig `json:"cryptoHashConfig,omitempty"`

	// DateShiftConfig: Config for date shift.
	DateShiftConfig *DateShiftConfig `json:"dateShiftConfig,omitempty"`

	// InfoTypes: InfoTypes to apply this transformation to. If this is not
	// specified, the transformation applies to any info_type.
	InfoTypes []string `json:"infoTypes,omitempty"`

	// RedactConfig: Config for text redaction.
	RedactConfig *RedactConfig `json:"redactConfig,omitempty"`

	// ReplaceWithInfoTypeConfig: Config for replace with InfoType.
	ReplaceWithInfoTypeConfig *ReplaceWithInfoTypeConfig `json:"replaceWithInfoTypeConfig,omitempty"`

	// ForceSendFields is a list of field names (e.g. "CharacterMaskConfig")
	// to unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "CharacterMaskConfig") to
	// include in API requests with the JSON null value. By default, fields
	// with empty values are omitted from API requests. However, any field
	// with an empty value appearing in NullFields will be sent to the
	// server as null. It is an error if a field in this list has a
	// non-empty value. This may be used to include null fields in Patch
	// requests.
	NullFields []string `json:"-"`
}

                                                                                            InfoTypeTransformation: A transformation to apply to text that is identified as a specific info_type.

                                                                                            func (*InfoTypeTransformation) MarshalJSON 

                                                                                            func (s *InfoTypeTransformation) MarshalJSON() ([]byte, error)

                                                                                            type IngestMessageRequest 

                                                                                            type IngestMessageRequest struct {
	// Message: HL7v2 message to ingest.
	Message *Message `json:"message,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Message") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Message") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                              IngestMessageRequest: Ingests a message into the specified HL7v2 store.

                                                                                              func (*IngestMessageRequest) MarshalJSON 

                                                                                              func (s *IngestMessageRequest) MarshalJSON() ([]byte, error)

                                                                                              type IngestMessageResponse 

                                                                                              type IngestMessageResponse struct {
	// Hl7Ack: HL7v2 ACK message.
	Hl7Ack string `json:"hl7Ack,omitempty"`

	// Message: Created message resource.
	Message *Message `json:"message,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "Hl7Ack") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Hl7Ack") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                IngestMessageResponse: Acknowledges that a message has been ingested into the specified HL7v2 store.

                                                                                                func (*IngestMessageResponse) MarshalJSON 

                                                                                                func (s *IngestMessageResponse) MarshalJSON() ([]byte, error)

                                                                                                type ListDatasetsResponse 

                                                                                                type ListDatasetsResponse struct {
	// Datasets: The first page of datasets.
	Datasets []*Dataset `json:"datasets,omitempty"`

	// NextPageToken: Token to retrieve the next page of results, or empty
	// if there are no more results in the list.
	NextPageToken string `json:"nextPageToken,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "Datasets") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Datasets") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                  ListDatasetsResponse: Lists the available datasets.

                                                                                                  func (*ListDatasetsResponse) MarshalJSON 

                                                                                                  func (s *ListDatasetsResponse) MarshalJSON() ([]byte, error)

                                                                                                  type ListDicomStoresResponse 

                                                                                                  type ListDicomStoresResponse struct {
	// DicomStores: The returned DICOM stores. Won't be more DICOM stores
	// than the value of page_size in the request.
	DicomStores []*DicomStore `json:"dicomStores,omitempty"`

	// NextPageToken: Token to retrieve the next page of results or empty if
	// there are no more results in the list.
	NextPageToken string `json:"nextPageToken,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "DicomStores") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "DicomStores") to include
	// in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. However, any field with
	// an empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                    ListDicomStoresResponse: Lists the DICOM stores in the given dataset.

                                                                                                    func (*ListDicomStoresResponse) MarshalJSON 

                                                                                                    func (s *ListDicomStoresResponse) MarshalJSON() ([]byte, error)

                                                                                                    type ListFhirStoresResponse 

                                                                                                    type ListFhirStoresResponse struct {
	// FhirStores: The returned FHIR stores. Won't be more FHIR stores than
	// the value of page_size in the request.
	FhirStores []*FhirStore `json:"fhirStores,omitempty"`

	// NextPageToken: Token to retrieve the next page of results or empty if
	// there are no more results in the list.
	NextPageToken string `json:"nextPageToken,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "FhirStores") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "FhirStores") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                      ListFhirStoresResponse: Lists the FHIR stores in the given dataset.

                                                                                                      func (*ListFhirStoresResponse) MarshalJSON 

                                                                                                      func (s *ListFhirStoresResponse) MarshalJSON() ([]byte, error)

                                                                                                      type ListHl7V2StoresResponse 

                                                                                                      type ListHl7V2StoresResponse struct {
	// Hl7V2Stores: The returned HL7v2 stores. Won't be more HL7v2 stores
	// than the value of page_size in the request.
	Hl7V2Stores []*Hl7V2Store `json:"hl7V2Stores,omitempty"`

	// NextPageToken: Token to retrieve the next page of results or empty if
	// there are no more results in the list.
	NextPageToken string `json:"nextPageToken,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "Hl7V2Stores") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Hl7V2Stores") to include
	// in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. However, any field with
	// an empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                        ListHl7V2StoresResponse: Lists the HL7v2 stores in the given dataset.

                                                                                                        func (*ListHl7V2StoresResponse) MarshalJSON 

                                                                                                        func (s *ListHl7V2StoresResponse) MarshalJSON() ([]byte, error)

                                                                                                        type ListLocationsResponse 

                                                                                                        type ListLocationsResponse struct {
	// Locations: A list of locations that matches the specified filter in
	// the request.
	Locations []*Location `json:"locations,omitempty"`

	// NextPageToken: The standard List next-page token.
	NextPageToken string `json:"nextPageToken,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "Locations") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Locations") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                          ListLocationsResponse: The response message for Locations.ListLocations.

                                                                                                          func (*ListLocationsResponse) MarshalJSON 

                                                                                                          func (s *ListLocationsResponse) MarshalJSON() ([]byte, error)

                                                                                                          type ListMessagesResponse 

                                                                                                          type ListMessagesResponse struct {
	// Hl7V2Messages: The returned Messages. Won't be more Messages than the
	// value of page_size in the request. See view for populated fields.
	Hl7V2Messages []*Message `json:"hl7V2Messages,omitempty"`

	// NextPageToken: Token to retrieve the next page of results or empty if
	// there are no more results in the list.
	NextPageToken string `json:"nextPageToken,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "Hl7V2Messages") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Hl7V2Messages") to include
	// in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. However, any field with
	// an empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                            ListMessagesResponse: Lists the messages in the specified HL7v2 store.

                                                                                                            func (*ListMessagesResponse) MarshalJSON 

                                                                                                            func (s *ListMessagesResponse) MarshalJSON() ([]byte, error)

                                                                                                            type ListOperationsResponse 

                                                                                                            type ListOperationsResponse struct {
	// NextPageToken: The standard List next-page token.
	NextPageToken string `json:"nextPageToken,omitempty"`

	// Operations: A list of operations that matches the specified filter in
	// the request.
	Operations []*Operation `json:"operations,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "NextPageToken") to include
	// in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. However, any field with
	// an empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                              ListOperationsResponse: The response message for Operations.ListOperations.

                                                                                                              func (*ListOperationsResponse) MarshalJSON 

                                                                                                              func (s *ListOperationsResponse) MarshalJSON() ([]byte, error)

                                                                                                              type Location 

                                                                                                              type Location struct {
	// DisplayName: The friendly name for this location, typically a nearby
	// city name. For example, "Tokyo".
	DisplayName string `json:"displayName,omitempty"`

	// Labels: Cross-service attributes for the location. For example
	// {"cloud.googleapis.com/region": "us-east1"}
	Labels map[string]string `json:"labels,omitempty"`

	// LocationId: The canonical id for this location. For example:
	// "us-east1".
	LocationId string `json:"locationId,omitempty"`

	// Metadata: Service-specific metadata. For example the available
	// capacity at the given location.
	Metadata googleapi.RawMessage `json:"metadata,omitempty"`

	// Name: Resource name for the location, which may vary between
	// implementations. For example:
	// "projects/example-project/locations/us-east1"
	Name string `json:"name,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "DisplayName") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "DisplayName") to include
	// in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. However, any field with
	// an empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                                Location: A resource that represents Google Cloud Platform location.

                                                                                                                func (*Location) MarshalJSON 

                                                                                                                func (s *Location) MarshalJSON() ([]byte, error)

                                                                                                                type Message 

                                                                                                                type Message struct {
	// CreateTime: Output only. The datetime when the message was created.
	// Set by the server.
	CreateTime string `json:"createTime,omitempty"`

	// Data: Raw message bytes.
	Data string `json:"data,omitempty"`

	// Labels: 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 map[string]string `json:"labels,omitempty"`

	// MessageType: The message type for this message. MSH-9.1.
	MessageType string `json:"messageType,omitempty"`

	// Name: 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 `json:"name,omitempty"`

	// ParsedData: Output only. The parsed version of the raw message data.
	ParsedData *ParsedData `json:"parsedData,omitempty"`

	// PatientIds: All patient IDs listed in the PID-2, PID-3, and PID-4
	// segments of this message.
	PatientIds []*PatientId `json:"patientIds,omitempty"`

	// SendFacility: The hospital that this message came from. MSH-4.
	SendFacility string `json:"sendFacility,omitempty"`

	// SendTime: The datetime the sending application sent this message.
	// MSH-7.
	SendTime string `json:"sendTime,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "CreateTime") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "CreateTime") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                                  Message: A complete HL7v2 message. See [Introduction to HL7 Standards] (https://www.hl7.org/implement/standards/index.cfm?ref=common) for details on the standard.

                                                                                                                  func (*Message) MarshalJSON 

                                                                                                                  func (s *Message) MarshalJSON() ([]byte, error)

                                                                                                                  type NotificationConfig 

                                                                                                                  type NotificationConfig struct {
	// PubsubTopic: The Cloud Pub/Sub
	// (https://cloud.google.com/pubsub/docs/) topic that notifications of
	// changes are published on. Supplied by the client. PubsubMessage.Data
	// contains 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 (https://cloud.google.com/pubsub/docs/overview#names)
	// must be scoped to a project. Cloud Healthcare API service account
	// must have publisher permissions on the given Cloud Pub/Sub topic. Not
	// having adequate permissions causes the calls that send notifications
	// to fail. If a notification can't be published to Cloud Pub/Sub,
	// errors are logged to Cloud Logging (see Viewing logs
	// (/healthcare/docs/how-tos/logging)). If the number of errors exceeds
	// a certain rate, some aren't submitted. Note that not all operations
	// trigger notifications, see Configuring Pub/Sub notifications
	// (https://cloud.google.com/healthcare/docs/how-tos/pubsub) for
	// specific details.
	PubsubTopic string `json:"pubsubTopic,omitempty"`

	// ForceSendFields is a list of field names (e.g. "PubsubTopic") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "PubsubTopic") to include
	// in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. However, any field with
	// an empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                                    NotificationConfig: Specifies where to send notifications upon changes to a data store.

                                                                                                                    func (*NotificationConfig) MarshalJSON 

                                                                                                                    func (s *NotificationConfig) MarshalJSON() ([]byte, error)

                                                                                                                    type Operation 

                                                                                                                    type Operation struct {
	// Done: 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 bool `json:"done,omitempty"`

	// Error: The error result of the operation in case of failure or
	// cancellation.
	Error *Status `json:"error,omitempty"`

	// Metadata: Service-specific metadata associated with the operation. It
	// typically contains progress information and common metadata such as
	// create time. Some services might not provide such metadata. Any
	// method that returns a long-running operation should document the
	// metadata type, if any.
	Metadata googleapi.RawMessage `json:"metadata,omitempty"`

	// Name: The server-assigned name, which is only unique within the same
	// service that originally returns it. If you use the default HTTP
	// mapping, the `name` should be a resource name ending with
	// `operations/{unique_id}`.
	Name string `json:"name,omitempty"`

	// Response: The normal response of the operation in case of success. If
	// the original method returns no data on success, such as `Delete`, the
	// response is `google.protobuf.Empty`. If the original method is
	// standard `Get`/`Create`/`Update`, the response should be the
	// resource. For other methods, the response should have the type
	// `XxxResponse`, where `Xxx` is the original method name. For example,
	// if the original method name is `TakeSnapshot()`, the inferred
	// response type is `TakeSnapshotResponse`.
	Response googleapi.RawMessage `json:"response,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "Done") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Done") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                                      Operation: This resource represents a long-running operation that is the result of a network API call.

                                                                                                                      func (*Operation) MarshalJSON 

                                                                                                                      func (s *Operation) MarshalJSON() ([]byte, error)

                                                                                                                      type OperationMetadata 

                                                                                                                      type OperationMetadata struct {
	// ApiMethodName: The name of the API method that initiated the
	// operation.
	ApiMethodName string `json:"apiMethodName,omitempty"`

	// CancelRequested: Specifies if cancellation was requested for the
	// operation.
	CancelRequested bool `json:"cancelRequested,omitempty"`

	Counter *ProgressCounter `json:"counter,omitempty"`

	// CreateTime: The time at which the operation was created by the API.
	CreateTime string `json:"createTime,omitempty"`

	// EndTime: The time at which execution was completed.
	EndTime string `json:"endTime,omitempty"`

	// LogsUrl: A link to audit and error logs in the log viewer. Error logs
	// are generated only by some operations, listed at Viewing logs
	// (/healthcare/docs/how-tos/logging).
	LogsUrl string `json:"logsUrl,omitempty"`

	// ForceSendFields is a list of field names (e.g. "ApiMethodName") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "ApiMethodName") to include
	// in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. However, any field with
	// an empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                                        OperationMetadata: OperationMetadata provides information about the operation execution. Returned in the long-running operation's metadata field.

                                                                                                                        func (*OperationMetadata) MarshalJSON 

                                                                                                                        func (s *OperationMetadata) MarshalJSON() ([]byte, error)

                                                                                                                        type ParsedData 

                                                                                                                        type ParsedData struct {
	Segments []*Segment `json:"segments,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Segments") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Segments") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                                          ParsedData: The content of a HL7v2 message in a structured format.

                                                                                                                          func (*ParsedData) MarshalJSON 

                                                                                                                          func (s *ParsedData) MarshalJSON() ([]byte, error)

                                                                                                                          type ParserConfig 

                                                                                                                          type ParserConfig struct {
	// AllowNullHeader: Determines whether messages with no header are
	// allowed.
	AllowNullHeader bool `json:"allowNullHeader,omitempty"`

	// SegmentTerminator: Byte(s) to use as the segment terminator. If this
	// is unset, '\r' is used as segment terminator, matching the HL7
	// version 2 specification.
	SegmentTerminator string `json:"segmentTerminator,omitempty"`

	// ForceSendFields is a list of field names (e.g. "AllowNullHeader") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "AllowNullHeader") to
	// include in API requests with the JSON null value. By default, fields
	// with empty values are omitted from API requests. However, any field
	// with an empty value appearing in NullFields will be sent to the
	// server as null. It is an error if a field in this list has a
	// non-empty value. This may be used to include null fields in Patch
	// requests.
	NullFields []string `json:"-"`
}

                                                                                                                            ParserConfig: The configuration for the parser. It determines how the server parses the messages.

                                                                                                                            func (*ParserConfig) MarshalJSON 

                                                                                                                            func (s *ParserConfig) MarshalJSON() ([]byte, error)

                                                                                                                            type PatientId 

                                                                                                                            type PatientId struct {
	// Type: ID type. For example, MRN or NHS.
	Type string `json:"type,omitempty"`

	// Value: The patient's unique identifier.
	Value string `json:"value,omitempty"`

	// ForceSendFields is a list of field names (e.g. "Type") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Type") to include in API
	// requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                                              PatientId: A patient identifier and associated type.

                                                                                                                              func (*PatientId) MarshalJSON 

                                                                                                                              func (s *PatientId) MarshalJSON() ([]byte, error)

                                                                                                                              type Policy 

                                                                                                                              type Policy struct {
	// AuditConfigs: Specifies cloud audit logging configuration for this
	// policy.
	AuditConfigs []*AuditConfig `json:"auditConfigs,omitempty"`

	// Bindings: Associates a list of `members` to a `role`. Optionally, may
	// specify a `condition` that determines how and when the `bindings` are
	// applied. Each of the `bindings` must contain at least one member.
	Bindings []*Binding `json:"bindings,omitempty"`

	// Etag: `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. **Important:** If you use IAM
	// Conditions, you must include the `etag` field whenever you call
	// `setIamPolicy`. If you omit this field, then IAM allows you to
	// overwrite a version `3` policy with a version `1` policy, and all of
	// the conditions in the version `3` policy are lost.
	Etag string `json:"etag,omitempty"`

	// Version: Specifies the format of the policy. Valid values are `0`,
	// `1`, and `3`. Requests that specify an invalid value are rejected.
	// Any operation that affects conditional role bindings must specify
	// version `3`. This requirement applies to the following operations: *
	// Getting a policy that includes a conditional role binding * Adding a
	// conditional role binding to a policy * Changing a conditional role
	// binding in a policy * Removing any role binding, with or without a
	// condition, from a policy that includes conditions **Important:** If
	// you use IAM Conditions, you must include the `etag` field whenever
	// you call `setIamPolicy`. If you omit this field, then IAM allows you
	// to overwrite a version `3` policy with a version `1` policy, and all
	// of the conditions in the version `3` policy are lost. If a policy
	// does not include any conditions, operations on that policy may
	// specify any valid version or leave the field unset. To learn which
	// resources support conditions in their IAM policies, see the IAM
	// documentation
	// (https://cloud.google.com/iam/help/conditions/resource-policies).
	Version int64 `json:"version,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the
	// server.
	googleapi.ServerResponse `json:"-"`

	// ForceSendFields is a list of field names (e.g. "AuditConfigs") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "AuditConfigs") to include
	// in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. However, any field with
	// an empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                                                Policy: An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members` to a single `role`. Members can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the IAM documentation (https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** { "bindings": [ { "role": "roles/resourcemanager.organizationAdmin", "members": [ "user:mike@example.com", "group:admins@example.com", "domain:google.com", "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] }, { "role": "roles/resourcemanager.organizationViewer", "members": [ "user:eve@example.com" ], "condition": { "title": "expirable access", "description": "Does not grant access after Sep 2020", "expression": "request.time < timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag": "BwWWja0YfJA=", "version": 3 } **YAML example:** bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') - etag: BwWWja0YfJA= - version: 3 For a description of IAM and its features, see the IAM documentation (https://cloud.google.com/iam/docs/).

                                                                                                                                func (*Policy) MarshalJSON 

                                                                                                                                func (s *Policy) MarshalJSON() ([]byte, error)

                                                                                                                                type ProgressCounter 

                                                                                                                                type ProgressCounter struct {
	// Failure: The number of units that failed in the operation.
	Failure int64 `json:"failure,omitempty,string"`

	// Pending: The number of units that are pending in the operation.
	Pending int64 `json:"pending,omitempty,string"`

	// Success: The number of units that succeeded in the operation.
	Success int64 `json:"success,omitempty,string"`

	// ForceSendFields is a list of field names (e.g. "Failure") to
	// unconditionally include in API requests. By default, fields with
	// empty values are omitted from API requests. However, any non-pointer,
	// non-interface field appearing in ForceSendFields will be sent to the
	// server regardless of whether the field is empty or not. This may be
	// used to include empty fields in Patch requests.
	ForceSendFields []string `json:"-"`

	// NullFields is a list of field names (e.g. "Failure") to include in
	// API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. However, any field with an
	// empty value appearing in NullFields will be sent to the server as
	// null. It is an error if a field in this list has a non-empty value.
	// This may be used to include null fields in Patch requests.
	NullFields []string `json:"-"`
}

                                                                                                                                  ProgressCounter: ProgressCounter provides counters to describe an operation's progress.

                                                                                                                                  func (*ProgressCounter) MarshalJSON 

                                                                                                                                  func (s *ProgressCounter) MarshalJSON() ([]byte, error)

                                                                                                                                  type ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall 

                                                                                                                                  type ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                  func (*ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Context 

                                                                                                                                  func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall

                                                                                                                                    Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                    func (*ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Do 

                                                                                                                                    func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error)

                                                                                                                                      Do executes the "healthcare.projects.locations.datasets.consentStores.getIamPolicy" call. Exactly one of *Policy or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Policy.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                      func (*ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Fields 

                                                                                                                                      func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall

                                                                                                                                        Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                        func (*ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Header 

                                                                                                                                        func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Header() http.Header

                                                                                                                                          Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                          func (*ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) IfNoneMatch 

                                                                                                                                          func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall

                                                                                                                                            IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                            func (*ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) OptionsRequestedPolicyVersion 

                                                                                                                                            func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall

                                                                                                                                              OptionsRequestedPolicyVersion sets the optional parameter "options.requestedPolicyVersion": The policy format version to be returned. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional bindings must specify version 3. Policies without any conditional bindings may specify any valid value or leave the field unset. To learn which resources support conditions in their IAM policies, see the IAM documentation (https://cloud.google.com/iam/help/conditions/resource-policies).

                                                                                                                                              type ProjectsLocationsDatasetsConsentStoresService 

                                                                                                                                              type ProjectsLocationsDatasetsConsentStoresService struct {
	// contains filtered or unexported fields
}

                                                                                                                                              func NewProjectsLocationsDatasetsConsentStoresService 

                                                                                                                                              func NewProjectsLocationsDatasetsConsentStoresService(s *Service) *ProjectsLocationsDatasetsConsentStoresService

                                                                                                                                              func (*ProjectsLocationsDatasetsConsentStoresService) GetIamPolicy 

                                                                                                                                              func (r *ProjectsLocationsDatasetsConsentStoresService) GetIamPolicy(resource string) *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall

                                                                                                                                                GetIamPolicy: Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.

                                                                                                                                                func (*ProjectsLocationsDatasetsConsentStoresService) SetIamPolicy 

                                                                                                                                                func (r *ProjectsLocationsDatasetsConsentStoresService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall

                                                                                                                                                  SetIamPolicy: Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.

                                                                                                                                                  func (*ProjectsLocationsDatasetsConsentStoresService) TestIamPermissions 

                                                                                                                                                  func (r *ProjectsLocationsDatasetsConsentStoresService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall

                                                                                                                                                    TestIamPermissions: Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may "fail open" without warning.

                                                                                                                                                    type ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall 

                                                                                                                                                    type ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                    func (*ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Context 

                                                                                                                                                    func (c *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall

                                                                                                                                                      Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                      func (*ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Do 

                                                                                                                                                      func (c *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error)

                                                                                                                                                        Do executes the "healthcare.projects.locations.datasets.consentStores.setIamPolicy" call. Exactly one of *Policy or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Policy.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                        func (*ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Fields 

                                                                                                                                                        func (c *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall

                                                                                                                                                          Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                          func (*ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Header 

                                                                                                                                                          func (c *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Header() http.Header

                                                                                                                                                            Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                            type ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall 

                                                                                                                                                            type ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                            func (*ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Context 

                                                                                                                                                            func (c *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall

                                                                                                                                                              Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                              func (*ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Do 

                                                                                                                                                              func (c *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error)

                                                                                                                                                                Do executes the "healthcare.projects.locations.datasets.consentStores.testIamPermissions" call. Exactly one of *TestIamPermissionsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *TestIamPermissionsResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                func (*ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Fields 

                                                                                                                                                                func (c *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall

                                                                                                                                                                  Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                  func (*ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Header 

                                                                                                                                                                  func (c *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Header() http.Header

                                                                                                                                                                    Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                    type ProjectsLocationsDatasetsCreateCall 

                                                                                                                                                                    type ProjectsLocationsDatasetsCreateCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                    func (*ProjectsLocationsDatasetsCreateCall) Context 

                                                                                                                                                                    func (c *ProjectsLocationsDatasetsCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsCreateCall

                                                                                                                                                                      Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                      func (*ProjectsLocationsDatasetsCreateCall) DatasetId 

                                                                                                                                                                      func (c *ProjectsLocationsDatasetsCreateCall) DatasetId(datasetId string) *ProjectsLocationsDatasetsCreateCall

                                                                                                                                                                        DatasetId sets the optional parameter "datasetId": The ID of the dataset that is being created. The string must match the following regex: `[\p{L}\p{N}_\-\.]{1,256}`.

                                                                                                                                                                        func (*ProjectsLocationsDatasetsCreateCall) Do 

                                                                                                                                                                        func (c *ProjectsLocationsDatasetsCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error)

                                                                                                                                                                          Do executes the "healthcare.projects.locations.datasets.create" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                          func (*ProjectsLocationsDatasetsCreateCall) Fields 

                                                                                                                                                                          func (c *ProjectsLocationsDatasetsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsCreateCall

                                                                                                                                                                            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                            func (*ProjectsLocationsDatasetsCreateCall) Header 

                                                                                                                                                                            func (c *ProjectsLocationsDatasetsCreateCall) Header() http.Header

                                                                                                                                                                              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                              type ProjectsLocationsDatasetsDeidentifyCall 

                                                                                                                                                                              type ProjectsLocationsDatasetsDeidentifyCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                              func (*ProjectsLocationsDatasetsDeidentifyCall) Context 

                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDeidentifyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDeidentifyCall

                                                                                                                                                                                Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                func (*ProjectsLocationsDatasetsDeidentifyCall) Do 

                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDeidentifyCall) Do(opts ...googleapi.CallOption) (*Operation, error)

                                                                                                                                                                                  Do executes the "healthcare.projects.locations.datasets.deidentify" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDeidentifyCall) Fields 

                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDeidentifyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDeidentifyCall

                                                                                                                                                                                    Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDeidentifyCall) Header 

                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDeidentifyCall) Header() http.Header

                                                                                                                                                                                      Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                      type ProjectsLocationsDatasetsDeleteCall 

                                                                                                                                                                                      type ProjectsLocationsDatasetsDeleteCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDeleteCall) Context 

                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDeleteCall

                                                                                                                                                                                        Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDeleteCall) Do 

                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error)

                                                                                                                                                                                          Do executes the "healthcare.projects.locations.datasets.delete" call. Exactly one of *Empty or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Empty.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDeleteCall) Fields 

                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDeleteCall

                                                                                                                                                                                            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDeleteCall) Header 

                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDeleteCall) Header() http.Header

                                                                                                                                                                                              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresCreateCall 

                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresCreateCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresCreateCall) Context 

                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresCreateCall

                                                                                                                                                                                                Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresCreateCall) DicomStoreId 

                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresCreateCall) DicomStoreId(dicomStoreId string) *ProjectsLocationsDatasetsDicomStoresCreateCall

                                                                                                                                                                                                  DicomStoreId sets the optional parameter "dicomStoreId": The ID of the DICOM store that is being created. Any string value up to 256 characters in length.

                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresCreateCall) Do 

                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresCreateCall) Do(opts ...googleapi.CallOption) (*DicomStore, error)

                                                                                                                                                                                                    Do executes the "healthcare.projects.locations.datasets.dicomStores.create" call. Exactly one of *DicomStore or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *DicomStore.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresCreateCall) Fields 

                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresCreateCall

                                                                                                                                                                                                      Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresCreateCall) Header 

                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresCreateCall) Header() http.Header

                                                                                                                                                                                                        Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                        type ProjectsLocationsDatasetsDicomStoresDeidentifyCall 

                                                                                                                                                                                                        type ProjectsLocationsDatasetsDicomStoresDeidentifyCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Context 

                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresDeidentifyCall

                                                                                                                                                                                                          Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Do 

                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Do(opts ...googleapi.CallOption) (*Operation, error)

                                                                                                                                                                                                            Do executes the "healthcare.projects.locations.datasets.dicomStores.deidentify" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Fields 

                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresDeidentifyCall

                                                                                                                                                                                                              Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Header 

                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Header() http.Header

                                                                                                                                                                                                                Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                type ProjectsLocationsDatasetsDicomStoresDeleteCall 

                                                                                                                                                                                                                type ProjectsLocationsDatasetsDicomStoresDeleteCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresDeleteCall) Context 

                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresDeleteCall

                                                                                                                                                                                                                  Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresDeleteCall) Do 

                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error)

                                                                                                                                                                                                                    Do executes the "healthcare.projects.locations.datasets.dicomStores.delete" call. Exactly one of *Empty or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Empty.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresDeleteCall) Fields 

                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresDeleteCall

                                                                                                                                                                                                                      Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresDeleteCall) Header 

                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresDeleteCall) Header() http.Header

                                                                                                                                                                                                                        Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                        type ProjectsLocationsDatasetsDicomStoresExportCall 

                                                                                                                                                                                                                        type ProjectsLocationsDatasetsDicomStoresExportCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresExportCall) Context 

                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresExportCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresExportCall

                                                                                                                                                                                                                          Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresExportCall) Do 

                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresExportCall) Do(opts ...googleapi.CallOption) (*Operation, error)

                                                                                                                                                                                                                            Do executes the "healthcare.projects.locations.datasets.dicomStores.export" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresExportCall) Fields 

                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresExportCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresExportCall

                                                                                                                                                                                                                              Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresExportCall) Header 

                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresExportCall) Header() http.Header

                                                                                                                                                                                                                                Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                type ProjectsLocationsDatasetsDicomStoresGetCall 

                                                                                                                                                                                                                                type ProjectsLocationsDatasetsDicomStoresGetCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresGetCall) Context 

                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresGetCall

                                                                                                                                                                                                                                  Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresGetCall) Do 

                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresGetCall) Do(opts ...googleapi.CallOption) (*DicomStore, error)

                                                                                                                                                                                                                                    Do executes the "healthcare.projects.locations.datasets.dicomStores.get" call. Exactly one of *DicomStore or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *DicomStore.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresGetCall) Fields 

                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresGetCall

                                                                                                                                                                                                                                      Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresGetCall) Header 

                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresGetCall) Header() http.Header

                                                                                                                                                                                                                                        Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresGetCall) IfNoneMatch 

                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresGetCall

                                                                                                                                                                                                                                          IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                          type ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall 

                                                                                                                                                                                                                                          type ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Context 

                                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall

                                                                                                                                                                                                                                            Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Do 

                                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error)

                                                                                                                                                                                                                                              Do executes the "healthcare.projects.locations.datasets.dicomStores.getIamPolicy" call. Exactly one of *Policy or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Policy.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Fields 

                                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall

                                                                                                                                                                                                                                                Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Header 

                                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Header() http.Header

                                                                                                                                                                                                                                                  Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) IfNoneMatch 

                                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall

                                                                                                                                                                                                                                                    IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) OptionsRequestedPolicyVersion 

                                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall

                                                                                                                                                                                                                                                      OptionsRequestedPolicyVersion sets the optional parameter "options.requestedPolicyVersion": The policy format version to be returned. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional bindings must specify version 3. Policies without any conditional bindings may specify any valid value or leave the field unset. To learn which resources support conditions in their IAM policies, see the IAM documentation (https://cloud.google.com/iam/help/conditions/resource-policies).

                                                                                                                                                                                                                                                      type ProjectsLocationsDatasetsDicomStoresImportCall 

                                                                                                                                                                                                                                                      type ProjectsLocationsDatasetsDicomStoresImportCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresImportCall) Context 

                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresImportCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresImportCall

                                                                                                                                                                                                                                                        Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresImportCall) Do 

                                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresImportCall) Do(opts ...googleapi.CallOption) (*Operation, error)

                                                                                                                                                                                                                                                          Do executes the "healthcare.projects.locations.datasets.dicomStores.import" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresImportCall) Fields 

                                                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresImportCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresImportCall

                                                                                                                                                                                                                                                            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresImportCall) Header 

                                                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresImportCall) Header() http.Header

                                                                                                                                                                                                                                                              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresListCall 

                                                                                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresListCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresListCall) Context 

                                                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresListCall

                                                                                                                                                                                                                                                                Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresListCall) Do 

                                                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresListCall) Do(opts ...googleapi.CallOption) (*ListDicomStoresResponse, error)

                                                                                                                                                                                                                                                                  Do executes the "healthcare.projects.locations.datasets.dicomStores.list" call. Exactly one of *ListDicomStoresResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListDicomStoresResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresListCall) Fields 

                                                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresListCall

                                                                                                                                                                                                                                                                    Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresListCall) Filter 

                                                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresListCall) Filter(filter string) *ProjectsLocationsDatasetsDicomStoresListCall

                                                                                                                                                                                                                                                                      Filter sets the optional parameter "filter": Restricts stores returned to those matching a filter. Syntax: https://cloud.google.com/appengine/docs/standard/python/search/query_strings Only filtering on labels is supported. For example, `labels.key=value`.

                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresListCall) Header 

                                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresListCall) Header() http.Header

                                                                                                                                                                                                                                                                        Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresListCall) IfNoneMatch 

                                                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresListCall

                                                                                                                                                                                                                                                                          IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresListCall) PageSize 

                                                                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsDicomStoresListCall

                                                                                                                                                                                                                                                                            PageSize sets the optional parameter "pageSize": Limit on the number of DICOM stores to return in a single response. If not specified, 100 is used. May not be larger than 1000.

                                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresListCall) PageToken 

                                                                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsDicomStoresListCall

                                                                                                                                                                                                                                                                              PageToken sets the optional parameter "pageToken": The next_page_token value returned from the previous List request, if any.

                                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresListCall) Pages 

                                                                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresListCall) Pages(ctx context.Context, f func(*ListDicomStoresResponse) error) error

                                                                                                                                                                                                                                                                                Pages invokes f for each page of results. A non-nil error returned from f will halt the iteration. The provided context supersedes any context provided to the Context method.

                                                                                                                                                                                                                                                                                type ProjectsLocationsDatasetsDicomStoresPatchCall 

                                                                                                                                                                                                                                                                                type ProjectsLocationsDatasetsDicomStoresPatchCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresPatchCall) Context 

                                                                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresPatchCall

                                                                                                                                                                                                                                                                                  Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresPatchCall) Do 

                                                                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresPatchCall) Do(opts ...googleapi.CallOption) (*DicomStore, error)

                                                                                                                                                                                                                                                                                    Do executes the "healthcare.projects.locations.datasets.dicomStores.patch" call. Exactly one of *DicomStore or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *DicomStore.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresPatchCall) Fields 

                                                                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresPatchCall

                                                                                                                                                                                                                                                                                      Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresPatchCall) Header 

                                                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresPatchCall) Header() http.Header

                                                                                                                                                                                                                                                                                        Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresPatchCall) UpdateMask 

                                                                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDatasetsDicomStoresPatchCall

                                                                                                                                                                                                                                                                                          UpdateMask sets the optional parameter "updateMask": The update mask applies to the resource. For the `FieldMask` definition, see https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask

                                                                                                                                                                                                                                                                                          type ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall 

                                                                                                                                                                                                                                                                                          type ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Context 

                                                                                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall

                                                                                                                                                                                                                                                                                            Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Do 

                                                                                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Do(opts ...googleapi.CallOption) (*http.Response, error)

                                                                                                                                                                                                                                                                                              Do executes the "healthcare.projects.locations.datasets.dicomStores.searchForInstances" call.

                                                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Fields 

                                                                                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall

                                                                                                                                                                                                                                                                                                Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Header 

                                                                                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Header() http.Header

                                                                                                                                                                                                                                                                                                  Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) IfNoneMatch 

                                                                                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall

                                                                                                                                                                                                                                                                                                    IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                                                                                    type ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall 

                                                                                                                                                                                                                                                                                                    type ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Context 

                                                                                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall

                                                                                                                                                                                                                                                                                                      Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Do 

                                                                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Do(opts ...googleapi.CallOption) (*http.Response, error)

                                                                                                                                                                                                                                                                                                        Do executes the "healthcare.projects.locations.datasets.dicomStores.searchForSeries" call.

                                                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Fields 

                                                                                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall

                                                                                                                                                                                                                                                                                                          Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Header 

                                                                                                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Header() http.Header

                                                                                                                                                                                                                                                                                                            Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) IfNoneMatch 

                                                                                                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall

                                                                                                                                                                                                                                                                                                              IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall 

                                                                                                                                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Context 

                                                                                                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall

                                                                                                                                                                                                                                                                                                                Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Do 

                                                                                                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Do(opts ...googleapi.CallOption) (*http.Response, error)

                                                                                                                                                                                                                                                                                                                  Do executes the "healthcare.projects.locations.datasets.dicomStores.searchForStudies" call.

                                                                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Fields 

                                                                                                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall

                                                                                                                                                                                                                                                                                                                    Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Header 

                                                                                                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                      Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) IfNoneMatch 

                                                                                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall

                                                                                                                                                                                                                                                                                                                        IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                                                                                                        type ProjectsLocationsDatasetsDicomStoresService 

                                                                                                                                                                                                                                                                                                                        type ProjectsLocationsDatasetsDicomStoresService struct {
	Studies *ProjectsLocationsDatasetsDicomStoresStudiesService
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                        func NewProjectsLocationsDatasetsDicomStoresService 

                                                                                                                                                                                                                                                                                                                        func NewProjectsLocationsDatasetsDicomStoresService(s *Service) *ProjectsLocationsDatasetsDicomStoresService

                                                                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresService) Create 

                                                                                                                                                                                                                                                                                                                        func (r *ProjectsLocationsDatasetsDicomStoresService) Create(parent string, dicomstore *DicomStore) *ProjectsLocationsDatasetsDicomStoresCreateCall

                                                                                                                                                                                                                                                                                                                          Create: Creates a new DICOM store within the parent dataset.

                                                                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresService) Deidentify 

                                                                                                                                                                                                                                                                                                                          func (r *ProjectsLocationsDatasetsDicomStoresService) Deidentify(sourceStore string, deidentifydicomstorerequest *DeidentifyDicomStoreRequest) *ProjectsLocationsDatasetsDicomStoresDeidentifyCall

                                                                                                                                                                                                                                                                                                                            Deidentify: De-identifies data from the source store and writes it to the destination store. The metadata field type is OperationMetadata. If the request is successful, the response field type is DeidentifyDicomStoreSummary. If errors occur, error is set. The LRO result may still be successful if de-identification fails for some DICOM instances. The output DICOM store will not contain these failed resources. Failed resource totals are tracked in Operation.metadata. Error details are also logged to Cloud Logging (see Viewing logs (/healthcare/docs/how-tos/logging)).

                                                                                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresService) Delete 

                                                                                                                                                                                                                                                                                                                            func (r *ProjectsLocationsDatasetsDicomStoresService) Delete(name string) *ProjectsLocationsDatasetsDicomStoresDeleteCall

                                                                                                                                                                                                                                                                                                                              Delete: Deletes the specified DICOM store and removes all images that are contained within it.

                                                                                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresService) Export 

                                                                                                                                                                                                                                                                                                                              func (r *ProjectsLocationsDatasetsDicomStoresService) Export(name string, exportdicomdatarequest *ExportDicomDataRequest) *ProjectsLocationsDatasetsDicomStoresExportCall

                                                                                                                                                                                                                                                                                                                                Export: Exports data to the specified destination by copying it from the DICOM store. Errors are also logged to Cloud Logging. For more information, see Viewing logs (/healthcare/docs/how-tos/logging). The metadata field type is OperationMetadata.

                                                                                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresService) Get 

                                                                                                                                                                                                                                                                                                                                func (r *ProjectsLocationsDatasetsDicomStoresService) Get(name string) *ProjectsLocationsDatasetsDicomStoresGetCall

                                                                                                                                                                                                                                                                                                                                  Get: Gets the specified DICOM store.

                                                                                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresService) GetIamPolicy 

                                                                                                                                                                                                                                                                                                                                  func (r *ProjectsLocationsDatasetsDicomStoresService) GetIamPolicy(resource string) *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall

                                                                                                                                                                                                                                                                                                                                    GetIamPolicy: Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.

                                                                                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresService) Import 

                                                                                                                                                                                                                                                                                                                                    func (r *ProjectsLocationsDatasetsDicomStoresService) Import(name string, importdicomdatarequest *ImportDicomDataRequest) *ProjectsLocationsDatasetsDicomStoresImportCall

                                                                                                                                                                                                                                                                                                                                      Import: Imports data into the DICOM store by copying it from the specified source. Errors are logged to Cloud Logging. For more information, see Viewing logs (/healthcare/docs/how-tos/logging). The metadata field type is OperationMetadata.

                                                                                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresService) List 

                                                                                                                                                                                                                                                                                                                                      func (r *ProjectsLocationsDatasetsDicomStoresService) List(parent string) *ProjectsLocationsDatasetsDicomStoresListCall

                                                                                                                                                                                                                                                                                                                                        List: Lists the DICOM stores in the given dataset.

                                                                                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresService) Patch 

                                                                                                                                                                                                                                                                                                                                        func (r *ProjectsLocationsDatasetsDicomStoresService) Patch(name string, dicomstore *DicomStore) *ProjectsLocationsDatasetsDicomStoresPatchCall

                                                                                                                                                                                                                                                                                                                                          Patch: Updates the specified DICOM store.

                                                                                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresService) SearchForInstances 

                                                                                                                                                                                                                                                                                                                                          func (r *ProjectsLocationsDatasetsDicomStoresService) SearchForInstances(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall

                                                                                                                                                                                                                                                                                                                                            SearchForInstances: SearchForInstances returns a list of matching instances. See [Search Transaction] (http://dicom.nema.org/medical/dicom/current/output/html/part18.html#sect_10.6). For details on the implementation of SearchForInstances, see Search transaction (https://cloud.google.com/healthcare/docs/dicom#search_transaction) in the Cloud Healthcare API conformance statement. For samples that show how to call SearchForInstances, see Searching for studies, series, instances, and frames (https://cloud.google.com/healthcare/docs/how-tos/dicomweb#searching_for_studies_series_instances_and_frames).

                                                                                                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresService) SearchForSeries 

                                                                                                                                                                                                                                                                                                                                            func (r *ProjectsLocationsDatasetsDicomStoresService) SearchForSeries(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall

                                                                                                                                                                                                                                                                                                                                              SearchForSeries: SearchForSeries returns a list of matching series. See [Search Transaction] (http://dicom.nema.org/medical/dicom/current/output/html/part18.html#sect_10.6). For details on the implementation of SearchForSeries, see Search transaction (https://cloud.google.com/healthcare/docs/dicom#search_transaction) in the Cloud Healthcare API conformance statement. For samples that show how to call SearchForSeries, see Searching for studies, series, instances, and frames (https://cloud.google.com/healthcare/docs/how-tos/dicomweb#searching_for_studies_series_instances_and_frames).

                                                                                                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresService) SearchForStudies 

                                                                                                                                                                                                                                                                                                                                              func (r *ProjectsLocationsDatasetsDicomStoresService) SearchForStudies(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall

                                                                                                                                                                                                                                                                                                                                                SearchForStudies: SearchForStudies returns a list of matching studies. See [Search Transaction] (http://dicom.nema.org/medical/dicom/current/output/html/part18.html#sect_10.6). For details on the implementation of SearchForStudies, see Search transaction (https://cloud.google.com/healthcare/docs/dicom#search_transaction) in the Cloud Healthcare API conformance statement. For samples that show how to call SearchForStudies, see Searching for studies, series, instances, and frames (https://cloud.google.com/healthcare/docs/how-tos/dicomweb#searching_for_studies_series_instances_and_frames).

                                                                                                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresService) SetIamPolicy 

                                                                                                                                                                                                                                                                                                                                                func (r *ProjectsLocationsDatasetsDicomStoresService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall

                                                                                                                                                                                                                                                                                                                                                  SetIamPolicy: Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.

                                                                                                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresService) StoreInstances 

                                                                                                                                                                                                                                                                                                                                                  func (r *ProjectsLocationsDatasetsDicomStoresService) StoreInstances(parent string, dicomWebPath string, body_ io.Reader) *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall

                                                                                                                                                                                                                                                                                                                                                    StoreInstances: StoreInstances stores DICOM instances associated with study instance unique identifiers (SUID). See [Store Transaction] (http://dicom.nema.org/medical/dicom/current/output/html/part18.html#sect_10.5). For details on the implementation of StoreInstances, see Store transaction (https://cloud.google.com/healthcare/docs/dicom#store_transaction) in the Cloud Healthcare API conformance statement. For samples that show how to call StoreInstances, see Storing DICOM data (https://cloud.google.com/healthcare/docs/how-tos/dicomweb#storing_dicom_data).

                                                                                                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresService) TestIamPermissions 

                                                                                                                                                                                                                                                                                                                                                    func (r *ProjectsLocationsDatasetsDicomStoresService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsDatasetsDicomStoresTestIamPermissionsCall

                                                                                                                                                                                                                                                                                                                                                      TestIamPermissions: Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may "fail open" without warning.

                                                                                                                                                                                                                                                                                                                                                      type ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall 

                                                                                                                                                                                                                                                                                                                                                      type ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Context 

                                                                                                                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall

                                                                                                                                                                                                                                                                                                                                                        Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Do 

                                                                                                                                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error)

                                                                                                                                                                                                                                                                                                                                                          Do executes the "healthcare.projects.locations.datasets.dicomStores.setIamPolicy" call. Exactly one of *Policy or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Policy.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Fields 

                                                                                                                                                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall

                                                                                                                                                                                                                                                                                                                                                            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Header 

                                                                                                                                                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresStoreInstancesCall 

                                                                                                                                                                                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresStoreInstancesCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Context 

                                                                                                                                                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall

                                                                                                                                                                                                                                                                                                                                                                Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Do 

                                                                                                                                                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Do(opts ...googleapi.CallOption) (*http.Response, error)

                                                                                                                                                                                                                                                                                                                                                                  Do executes the "healthcare.projects.locations.datasets.dicomStores.storeInstances" call.

                                                                                                                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Fields 

                                                                                                                                                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall

                                                                                                                                                                                                                                                                                                                                                                    Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Header 

                                                                                                                                                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                                      Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                                                                      type ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall 

                                                                                                                                                                                                                                                                                                                                                                      type ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Context 

                                                                                                                                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall

                                                                                                                                                                                                                                                                                                                                                                        Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Do 

                                                                                                                                                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error)

                                                                                                                                                                                                                                                                                                                                                                          Do executes the "healthcare.projects.locations.datasets.dicomStores.studies.delete" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Fields 

                                                                                                                                                                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall

                                                                                                                                                                                                                                                                                                                                                                            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Header 

                                                                                                                                                                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                                              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall 

                                                                                                                                                                                                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Context 

                                                                                                                                                                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall

                                                                                                                                                                                                                                                                                                                                                                                Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Do 

                                                                                                                                                                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Do(opts ...googleapi.CallOption) (*http.Response, error)

                                                                                                                                                                                                                                                                                                                                                                                  Do executes the "healthcare.projects.locations.datasets.dicomStores.studies.retrieveMetadata" call.

                                                                                                                                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Fields 

                                                                                                                                                                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall

                                                                                                                                                                                                                                                                                                                                                                                    Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Header 

                                                                                                                                                                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                                                      Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) IfNoneMatch 

                                                                                                                                                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall

                                                                                                                                                                                                                                                                                                                                                                                        IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                                                                                                                                                                        type ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall 

                                                                                                                                                                                                                                                                                                                                                                                        type ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Context 

                                                                                                                                                                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall

                                                                                                                                                                                                                                                                                                                                                                                          Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Do 

                                                                                                                                                                                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Do(opts ...googleapi.CallOption) (*http.Response, error)

                                                                                                                                                                                                                                                                                                                                                                                            Do executes the "healthcare.projects.locations.datasets.dicomStores.studies.retrieveStudy" call.

                                                                                                                                                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Fields 

                                                                                                                                                                                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall

                                                                                                                                                                                                                                                                                                                                                                                              Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Header 

                                                                                                                                                                                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                                                                Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) IfNoneMatch 

                                                                                                                                                                                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall

                                                                                                                                                                                                                                                                                                                                                                                                  IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                                                                                                                                                                                  type ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall 

                                                                                                                                                                                                                                                                                                                                                                                                  type ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Context 

                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall

                                                                                                                                                                                                                                                                                                                                                                                                    Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Do 

                                                                                                                                                                                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Do(opts ...googleapi.CallOption) (*http.Response, error)

                                                                                                                                                                                                                                                                                                                                                                                                      Do executes the "healthcare.projects.locations.datasets.dicomStores.studies.searchForInstances" call.

                                                                                                                                                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Fields 

                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall

                                                                                                                                                                                                                                                                                                                                                                                                        Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Header 

                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                                                                          Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) IfNoneMatch 

                                                                                                                                                                                                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall

                                                                                                                                                                                                                                                                                                                                                                                                            IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                                                                                                                                                                                            type ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall 

                                                                                                                                                                                                                                                                                                                                                                                                            type ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Context 

                                                                                                                                                                                                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall

                                                                                                                                                                                                                                                                                                                                                                                                              Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Do 

                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Do(opts ...googleapi.CallOption) (*http.Response, error)

                                                                                                                                                                                                                                                                                                                                                                                                                Do executes the "healthcare.projects.locations.datasets.dicomStores.studies.searchForSeries" call.

                                                                                                                                                                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Fields 

                                                                                                                                                                                                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall

                                                                                                                                                                                                                                                                                                                                                                                                                  Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Header 

                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                                                                                    Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) IfNoneMatch 

                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall

                                                                                                                                                                                                                                                                                                                                                                                                                      IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                                                                                                                                                                                                      type ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall 

                                                                                                                                                                                                                                                                                                                                                                                                                      type ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Context 

                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall

                                                                                                                                                                                                                                                                                                                                                                                                                        Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Do 

                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error)

                                                                                                                                                                                                                                                                                                                                                                                                                          Do executes the "healthcare.projects.locations.datasets.dicomStores.studies.series.delete" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Fields 

                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall

                                                                                                                                                                                                                                                                                                                                                                                                                            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Header 

                                                                                                                                                                                                                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                                                                                              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall 

                                                                                                                                                                                                                                                                                                                                                                                                                              type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Context 

                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall

                                                                                                                                                                                                                                                                                                                                                                                                                                Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Do 

                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                  Do executes the "healthcare.projects.locations.datasets.dicomStores.studies.series.instances.delete" call. Exactly one of *Empty or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Empty.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Fields 

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall

                                                                                                                                                                                                                                                                                                                                                                                                                                    Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Header 

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                                                                                                      Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                                                                                                                                      type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall 

                                                                                                                                                                                                                                                                                                                                                                                                                                      type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Context 

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall

                                                                                                                                                                                                                                                                                                                                                                                                                                        Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Do 

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Do(opts ...googleapi.CallOption) (*http.Response, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                          Do executes the "healthcare.projects.locations.datasets.dicomStores.studies.series.instances.frames.retrieveFrames" call.

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Fields 

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall

                                                                                                                                                                                                                                                                                                                                                                                                                                            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Header 

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                                                                                                              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) IfNoneMatch 

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall

                                                                                                                                                                                                                                                                                                                                                                                                                                                IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                                                                                                                                                                                                                                type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall 

                                                                                                                                                                                                                                                                                                                                                                                                                                                type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Context 

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Do 

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Do(opts ...googleapi.CallOption) (*http.Response, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Do executes the "healthcare.projects.locations.datasets.dicomStores.studies.series.instances.frames.retrieveRendered" call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Fields 

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Header 

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) IfNoneMatch 

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall

                                                                                                                                                                                                                                                                                                                                                                                                                                                          IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService 

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService struct {
	// contains filtered or unexported fields
}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService 

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService(s *Service) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService)