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/v1alpha2"
...
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 Annotation

    type Annotation struct {
    	// AnnotationSource: Details of the source.
    	AnnotationSource *AnnotationSource `json:"annotationSource,omitempty"`
    
    	// ImageAnnotation: Annotations for images, e.g., bounding polygons.
    	ImageAnnotation *ImageAnnotation `json:"imageAnnotation,omitempty"`
    
    	// Name: Output only. Resource name of the Annotation, of the
    	// form
    	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_
    	// id}/annotationStores/{annotation_store_id}/annotations/{annotation_id}
    	// `.
    	Name string `json:"name,omitempty"`
    
    	// ResourceAnnotation: Annotations for resource, e.g., classification
    	// tags.
    	ResourceAnnotation *ResourceAnnotation `json:"resourceAnnotation,omitempty"`
    
    	// TextAnnotation: Annotations for sensitive texts, e.g., range of such
    	// texts.
    	TextAnnotation *SensitiveTextAnnotation `json:"textAnnotation,omitempty"`
    
    	// ServerResponse contains the HTTP response code and headers from the
    	// server.
    	googleapi.ServerResponse `json:"-"`
    
    	// ForceSendFields is a list of field names (e.g. "AnnotationSource") 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. "AnnotationSource") 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:"-"`
    }

      Annotation: An annotation record.

      func (*Annotation) MarshalJSON

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

      type AnnotationSource

      type AnnotationSource struct {
      	// CloudHealthcareSource: Cloud Healthcare API resource.
      	CloudHealthcareSource *CloudHealthcareSource `json:"cloudHealthcareSource,omitempty"`
      
      	// ForceSendFields is a list of field names (e.g.
      	// "CloudHealthcareSource") 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. "CloudHealthcareSource") 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:"-"`
      }

        AnnotationSource: AnnotationSource holds the source information of the annotation.

        func (*AnnotationSource) MarshalJSON

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

        type AnnotationStore

        type AnnotationStore struct {
        	// Labels: User-supplied key-value pairs used to organize Annotation
        	// stores.
        	//
        	// Label keys must be between 1 and 63 characters long, have a UTF-8
        	// encoding
        	// of maximum 128 bytes, and must conform to the
        	// following PCRE regular expression:
        	// \p{Ll}\p{Lo}{0,62}
        	//
        	// Label values are optional, must be between 1 and 63 characters long,
        	// have
        	// a UTF-8 encoding of maximum 128 bytes, and must conform to
        	// the
        	// following PCRE regular expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63}
        	//
        	// No more than 64 labels can be associated with a given store.
        	Labels map[string]string `json:"labels,omitempty"`
        
        	// Name: Output only. Resource name of the Annotation store, of the
        	// form
        	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_
        	// id}/annotationStores/{annotation_store_id}`.
        	Name string `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. "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:"-"`
        }

          AnnotationStore: An Annotation store that can store annotation resources such as labels and tags for text, image and audio.

          func (*AnnotationStore) MarshalJSON

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

          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.
              	// NOTE: An unsatisfied condition will not allow user access via
              	// current
              	// binding. Different bindings, including their conditions, are
              	// examined
              	// independently.
              	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`.
              	//
              	//
              	// * `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 BoundingPoly

                type BoundingPoly struct {
                	Label string `json:"label,omitempty"`
                
                	Vertices []*Vertex `json:"vertices,omitempty"`
                
                	// ForceSendFields is a list of field names (e.g. "Label") 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. "Label") 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:"-"`
                }

                  BoundingPoly: A bounding polygon for the detected image annotation.

                  func (*BoundingPoly) MarshalJSON

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

                  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: Masks a string by replacing its characters with a fixed character.

                    func (*CharacterMaskConfig) MarshalJSON

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

                    type CloudHealthcareSource

                    type CloudHealthcareSource struct {
                    	// Name: Full path of a Cloud Healthcare API resource.
                    	Name string `json:"name,omitempty"`
                    
                    	// 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:"-"`
                    }

                      CloudHealthcareSource: Cloud Healthcare API resource.

                      func (*CloudHealthcareSource) MarshalJSON

                      func (s *CloudHealthcareSource) 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 when 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 using 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: Output only. 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 (e.g., 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
                            	// de-identification operation and is used when 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: Shifts a date forward or backward in time by a random amount that 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 the de-identification of image pixels in the
                              	// source_dataset.
                              	Image *ImageConfig `json:"image,omitempty"`
                              
                              	// Text: Configures the de-identification of text in `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
                                	// (e.g.,
                                	// `projects/{project_id}/locations/{location_id}/datasets/{dat
                                	// aset_id}`).
                                	//
                                	//  * The destination dataset must not exist.
                                	//  * The destination dataset must be in the same project as the source
                                	//    dataset. De-identifying data across multiple projects is not
                                	// supported.
                                	DestinationDataset string `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 DeidentifyErrorDetails

                                  type DeidentifyErrorDetails struct {
                                  	// FailureResourceCount: Number of resources failed to process.
                                  	FailureResourceCount int64 `json:"failureResourceCount,omitempty,string"`
                                  
                                  	// FailureStoreCount: Number of stores failed to process.
                                  	FailureStoreCount int64 `json:"failureStoreCount,omitempty,string"`
                                  
                                  	// SuccessResourceCount: Number of resources successfully processed.
                                  	SuccessResourceCount int64 `json:"successResourceCount,omitempty,string"`
                                  
                                  	// SuccessStoreCount: Number of stores successfully processed.
                                  	SuccessStoreCount int64 `json:"successStoreCount,omitempty,string"`
                                  
                                  	// ForceSendFields is a list of field names (e.g.
                                  	// "FailureResourceCount") 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. "FailureResourceCount") 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:"-"`
                                  }

                                    DeidentifyErrorDetails: Contains the status of the Deidentify operation.

                                    func (*DeidentifyErrorDetails) MarshalJSON

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

                                    type DeidentifySummary

                                    type DeidentifySummary struct {
                                    	// SuccessResourceCount: Number of resources successfully processed.
                                    	SuccessResourceCount int64 `json:"successResourceCount,omitempty,string"`
                                    
                                    	// SuccessStoreCount: Number of stores successfully processed.
                                    	SuccessStoreCount int64 `json:"successStoreCount,omitempty,string"`
                                    
                                    	// ForceSendFields is a list of field names (e.g.
                                    	// "SuccessResourceCount") 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. "SuccessResourceCount") 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:"-"`
                                    }

                                      DeidentifySummary: Contains a detailed summary of the Deidentify operation.

                                      func (*DeidentifySummary) MarshalJSON

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

                                      type Detail

                                      type Detail struct {
                                      	Findings []*Finding `json:"findings,omitempty"`
                                      
                                      	// ForceSendFields is a list of field names (e.g. "Findings") 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. "Findings") 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:"-"`
                                      }

                                        Detail: Contains multiple sensitive information findings for each resource slice.

                                        func (*Detail) MarshalJSON

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

                                        type DicomConfig

                                        type DicomConfig struct {
                                        	// FilterProfile: Tag filtering profile that determines the tags to keep
                                        	// or 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/c
                                        	// hapter_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"`
                                        
                                        	// 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 the de-identification of DICOM stores.

                                          func (*DicomConfig) MarshalJSON

                                          func (s *DicomConfig) 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: Output only. Resource name of the DICOM store, of the
                                          	// form
                                          	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_
                                          	// id}/dicomStores/{dicom_store_id}`.
                                          	Name string `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 ErrorDetail

                                              type ErrorDetail struct {
                                              	// Error: The status of the error.
                                              	Error *Status `json:"error,omitempty"`
                                              
                                              	// Resource: The identifier of the resource.
                                              	Resource string `json:"resource,omitempty"`
                                              
                                              	// ForceSendFields is a list of field names (e.g. "Error") 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. "Error") 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:"-"`
                                              }

                                                ErrorDetail: Structure to describe the error encountered during batch operation on one resource. This is used both for sample errors in operation response, and for format of errors in error reports.

                                                func (*ErrorDetail) MarshalJSON

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

                                                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 BigQuery location requires two IAM
                                                	// roles:
                                                	// `roles/bigquery.dataEditor` and `roles/bigquery.jobUser`.
                                                	BigqueryDestination *GoogleCloudHealthcareV1alpha2DicomBigQueryDestination `json:"bigqueryDestination,omitempty"`
                                                
                                                	// GcsDestination: The Cloud Storage output destination.
                                                	//
                                                	// The Cloud Storage location requires the `roles/storage.objectAdmin`
                                                	// Cloud
                                                	// IAM role.
                                                	GcsDestination *GoogleCloudHealthcareV1alpha2DicomGcsDestination `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 (e.g., a DICOM object with the same SOPInstance UID) already exists in the output, it is overwritten with the version in the source dataset. Exported DICOM data will persist when the DICOM store from which it was exported is deleted.

                                                  func (*ExportDicomDataRequest) MarshalJSON

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

                                                  type ExportResourcesRequest

                                                  type ExportResourcesRequest struct {
                                                  	// BigqueryDestination: The BigQuery output destination.
                                                  	//
                                                  	// The BigQuery location requires two IAM
                                                  	// roles:
                                                  	// `roles/bigquery.dataEditor` and `roles/bigquery.jobUser`.
                                                  	//
                                                  	// The output will be one BigQuery table per resource type.
                                                  	BigqueryDestination *GoogleCloudHealthcareV1alpha2FhirBigQueryDestination `json:"bigqueryDestination,omitempty"`
                                                  
                                                  	// GcsDestination: The Cloud Storage output destination.
                                                  	//
                                                  	// The Cloud Storage location requires the `roles/storage.objectAdmin`
                                                  	// Cloud
                                                  	// IAM role.
                                                  	//
                                                  	// The exported outputs are
                                                  	// organized by FHIR resource types. The server will create one object
                                                  	// per
                                                  	// resource type. Each object contains newline delimited JSON, and each
                                                  	// line
                                                  	// is a FHIR resource.
                                                  	GcsDestination *GoogleCloudHealthcareV1alpha2FhirRestGcsDestination `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 Expr

                                                    type Expr struct {
                                                    	// Description: An optional description of the expression. This is a
                                                    	// longer text which
                                                    	// describes the expression, e.g. when hovered over it in a UI.
                                                    	Description string `json:"description,omitempty"`
                                                    
                                                    	// Expression: Textual representation of an expression in
                                                    	// Common Expression Language syntax.
                                                    	//
                                                    	// The application context of the containing message determines
                                                    	// which
                                                    	// well-known feature set of CEL is supported.
                                                    	Expression string `json:"expression,omitempty"`
                                                    
                                                    	// Location: An optional string indicating the location of the
                                                    	// expression for error
                                                    	// reporting, e.g. a file name and a position in the file.
                                                    	Location string `json:"location,omitempty"`
                                                    
                                                    	// Title: An optional title for the expression, i.e. a short string
                                                    	// describing
                                                    	// its purpose. This can be used e.g. in UIs which allow to enter
                                                    	// the
                                                    	// expression.
                                                    	Title string `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 an expression text. Example:

                                                      title: "User account presence"
                                                      description: "Determines whether the request has a user account"
                                                      expression: "size(request.user) > 0"
                                                      

                                                      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 the de-identification of a FHIR store.

                                                        func (*FhirConfig) MarshalJSON

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

                                                        type FhirStore

                                                        type FhirStore struct {
                                                        	// DisableReferentialIntegrity: Whether to disable referential integrity
                                                        	// in this FHIR store. This field is
                                                        	// immutable after FHIR store creation.
                                                        	// The default value is false, meaning that the API will enforce
                                                        	// referential
                                                        	// integrity and fail the requests that will result in inconsistent
                                                        	// state in
                                                        	// the FHIR store.
                                                        	// When this field is set to true, the API will skip referential
                                                        	// integrity
                                                        	// check. Consequently, operations that rely on references, such
                                                        	// as
                                                        	// GetPatientEverything, will not return all the results if broken
                                                        	// references
                                                        	// exist.
                                                        	DisableReferentialIntegrity bool `json:"disableReferentialIntegrity,omitempty"`
                                                        
                                                        	// DisableResourceVersioning: Whether to disable resource versioning for
                                                        	// this FHIR store. This field can
                                                        	// not be changed after the creation of FHIR store.
                                                        	// If set to false, which is the default behavior, all write operations
                                                        	// will
                                                        	// cause historical versions to be recorded automatically. The
                                                        	// historical
                                                        	// versions can be fetched through the history APIs, but cannot be
                                                        	// updated.
                                                        	// If set to true, no historical versions will be kept. The server will
                                                        	// send
                                                        	// back errors for attempts to read the historical versions.
                                                        	DisableResourceVersioning bool `json:"disableResourceVersioning,omitempty"`
                                                        
                                                        	// EnableHistoryImport: Whether to allow the bulk import API to accept
                                                        	// history bundles and directly
                                                        	// insert historical resource versions into the FHIR store. Importing
                                                        	// resource
                                                        	// histories creates resource interactions that appear to have occurred
                                                        	// in the
                                                        	// past, which clients may not want to allow. If set to false, history
                                                        	// bundles
                                                        	// within an import will fail with an error.
                                                        	EnableHistoryImport bool `json:"enableHistoryImport,omitempty"`
                                                        
                                                        	// EnableUpdateCreate: Whether this FHIR store has the
                                                        	// [updateCreate
                                                        	// capability](https://www.hl7.org/fhir/capabilitystatement
                                                        	// -definitions.html#CapabilityStatement.rest.resource.updateCreate).
                                                        	// Thi
                                                        	// s determines if the client can use an Update operation to create a
                                                        	// new
                                                        	// resource with a client-specified ID. If false, all IDs are
                                                        	// server-assigned
                                                        	// through the Create operation and attempts to Update a non-existent
                                                        	// resource
                                                        	// will return errors. Please treat the audit logs with appropriate
                                                        	// levels of
                                                        	// care if client-specified resource IDs contain sensitive data such
                                                        	// as
                                                        	// patient identifiers, those IDs will be part of the FHIR resource
                                                        	// path
                                                        	// recorded in Cloud audit logs and Cloud Pub/Sub notifications.
                                                        	EnableUpdateCreate 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_sto
                                                        	// re_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 will contain a
                                                        	// map
                                                        	// with a string describing the action that has triggered the
                                                        	// notification,
                                                        	// e.g. "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 will be
                                                        	// streamed to
                                                        	// the new location in addition to the existing ones.
                                                        	// When a location is removed from the list, the server will simply
                                                        	// stop
                                                        	// streaming to that location. Before adding a new config, you must add
                                                        	// the
                                                        	// required
                                                        	// [`bigquery.dataEditor`](https://cloud.google.com/bigquery
                                                        	// /docs/access-control#bigquery.dataEditor)
                                                        	// role to your project's **Cloud Healthcare Service Agent**
                                                        	// [service
                                                        	// account](https://cloud.google.com/iam/docs/service-accounts).
                                                        	// Some lag (typically on the order of dozens of seconds) is expected
                                                        	// before
                                                        	// the results show up in the streaming destination.
                                                        	StreamConfigs []*StreamConfig `json:"streamConfigs,omitempty"`
                                                        
                                                        	// SubscriptionConfig: Configuration of FHIR
                                                        	// Subscription:
                                                        	// https://www.hl7.org/fhir/subscription.html.
                                                        	SubscriptionConfig *SubscriptionConfig `json:"subscriptionConfig,omitempty"`
                                                        
                                                        	// ValidationConfig: Configuration for how incoming FHIR resources will
                                                        	// be validated against
                                                        	// configured profiles.
                                                        	ValidationConfig *ValidationConfig `json:"validationConfig,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. When
                                                          	// `AnnotationConfig` is
                                                          	// provided, annotations of PHI are generated, except for Date and
                                                          	// Datetime.
                                                          	//   "DO_NOT_TRANSFORM" - Do not transform.
                                                          	Action string `json:"action,omitempty"`
                                                          
                                                          	// Paths: List of paths to FHIR fields to redact. 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]), 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, MimeTypeCode,
                                                          	// Oid,
                                                          	// String, Uri, Uuid, Xhtml.
                                                          	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 the de-identification of matching fields.

                                                            func (*FieldMetadata) MarshalJSON

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

                                                            type Finding

                                                            type Finding struct {
                                                            	// End: Zero-based ending index of the found text, exclusively.
                                                            	End int64 `json:"end,omitempty,string"`
                                                            
                                                            	// InfoType: The type of information stored in this text range (e.g.
                                                            	// HumanName,
                                                            	// BirthDate, Address, etc.)
                                                            	InfoType string `json:"infoType,omitempty"`
                                                            
                                                            	// Start: Zero-based starting index of the found text, inclusively.
                                                            	Start int64 `json:"start,omitempty,string"`
                                                            
                                                            	// ForceSendFields is a list of field names (e.g. "End") 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. "End") 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:"-"`
                                                            }

                                                            func (*Finding) MarshalJSON

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

                                                            type GetIamPolicyRequest

                                                            type GetIamPolicyRequest struct {
                                                            	// Options: OPTIONAL: A `GetPolicyOptions` object for specifying options
                                                            	// to
                                                            	// `GetIamPolicy`. This field is only used by Cloud IAM.
                                                            	Options *GetPolicyOptions `json:"options,omitempty"`
                                                            
                                                            	// ForceSendFields is a list of field names (e.g. "Options") 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. "Options") 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:"-"`
                                                            }

                                                              GetIamPolicyRequest: Request message for `GetIamPolicy` method.

                                                              func (*GetIamPolicyRequest) MarshalJSON

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

                                                              type GetPolicyOptions

                                                              type GetPolicyOptions struct {
                                                              	// RequestedPolicyVersion: Optional. The policy format version to be
                                                              	// returned.
                                                              	// Acceptable values are 0, 1, and 3.
                                                              	// If the value is 0, or the field is omitted, policy format version 1
                                                              	// will be
                                                              	// returned.
                                                              	RequestedPolicyVersion int64 `json:"requestedPolicyVersion,omitempty"`
                                                              
                                                              	// ForceSendFields is a list of field names (e.g.
                                                              	// "RequestedPolicyVersion") 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. "RequestedPolicyVersion")
                                                              	// 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:"-"`
                                                              }

                                                                GetPolicyOptions: Encapsulates settings provided to GetIamPolicy.

                                                                func (*GetPolicyOptions) MarshalJSON

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

                                                                type GoogleCloudHealthcareV1alpha2DicomBigQueryDestination

                                                                type GoogleCloudHealthcareV1alpha2DicomBigQueryDestination struct {
                                                                	// Force: If the destination table already exists and this flag is
                                                                	// `TRUE`, the table
                                                                	// will be overwritten by the contents of the DICOM store. If the flag
                                                                	// is not
                                                                	// set and the destination table already exists, the export call returns
                                                                	// an
                                                                	// error.
                                                                	Force 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:"-"`
                                                                }

                                                                  GoogleCloudHealthcareV1alpha2DicomBigQueryDestination: The BigQuery table where the output should be written.

                                                                  func (*GoogleCloudHealthcareV1alpha2DicomBigQueryDestination) MarshalJSON

                                                                  type GoogleCloudHealthcareV1alpha2DicomGcsDestination

                                                                  type GoogleCloudHealthcareV1alpha2DicomGcsDestination struct {
                                                                  	// MimeType: MIME types supported by DICOM spec.
                                                                  	// Each file will be written in the following
                                                                  	// format:
                                                                  	// `.../{study_id}/{series_id}/{instance_id}[/{frame_number}].{ex
                                                                  	// tension}`
                                                                  	// The frame_number component will exist only for multi-frame
                                                                  	// instances.
                                                                  	//
                                                                  	// Refer to the DICOM conformance statement for permissible MIME
                                                                  	// types:
                                                                  	// https://cloud.google.com/healthcare/docs/dicom#wado-rs
                                                                  	//
                                                                  	// The following extensions will be used for output files:
                                                                  	//   application/dicom -> .dcm
                                                                  	//   image/jpeg -> .jpg
                                                                  	//   image/png -> .png
                                                                  	//
                                                                  	// If unspecified, the instances will be exported in their
                                                                  	// original
                                                                  	// DICOM format.
                                                                  	MimeType string `json:"mimeType,omitempty"`
                                                                  
                                                                  	// UriPrefix: The Cloud Storage destination to export to.
                                                                  	//
                                                                  	// URI for a Cloud Storage directory where result files should be
                                                                  	// written (in
                                                                  	// the format `gs://{bucket-id}/{path/to/destination/dir}`). If there is
                                                                  	// no
                                                                  	// trailing slash, the service will append one when composing the object
                                                                  	// path.
                                                                  	// The user is responsible for creating the Cloud Storage bucket
                                                                  	// referenced in
                                                                  	// `uri_prefix`.
                                                                  	UriPrefix string `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:"-"`
                                                                  }

                                                                    GoogleCloudHealthcareV1alpha2DicomGcsDestination: The Cloud Storage location where the output should be written, and the export configuration.

                                                                    func (*GoogleCloudHealthcareV1alpha2DicomGcsDestination) MarshalJSON

                                                                    type GoogleCloudHealthcareV1alpha2DicomGcsSource

                                                                    type GoogleCloudHealthcareV1alpha2DicomGcsSource 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:"-"`
                                                                    }

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

                                                                      func (*GoogleCloudHealthcareV1alpha2DicomGcsSource) MarshalJSON

                                                                      type GoogleCloudHealthcareV1alpha2FhirBigQueryDestination

                                                                      type GoogleCloudHealthcareV1alpha2FhirBigQueryDestination struct {
                                                                      	// DatasetUri: BigQuery URI to a dataset, up to 2000 characters long, in
                                                                      	// the format
                                                                      	// `bq://projectId.bqDatasetId`
                                                                      	DatasetUri string `json:"datasetUri,omitempty"`
                                                                      
                                                                      	// SchemaConfig: The configuration for the exported BigQuery schema.
                                                                      	SchemaConfig *SchemaConfig `json:"schemaConfig,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:"-"`
                                                                      }

                                                                        GoogleCloudHealthcareV1alpha2FhirBigQueryDestination: The configuration for exporting to BigQuery.

                                                                        func (*GoogleCloudHealthcareV1alpha2FhirBigQueryDestination) MarshalJSON

                                                                        type GoogleCloudHealthcareV1alpha2FhirRestExportResourcesErrorDetails

                                                                        type GoogleCloudHealthcareV1alpha2FhirRestExportResourcesErrorDetails struct {
                                                                        	// ErrorCount: The number of resources that had errors.
                                                                        	ErrorCount int64 `json:"errorCount,omitempty,string"`
                                                                        
                                                                        	// FhirStore: The name of the FHIR store where resources have been
                                                                        	// exported, in
                                                                        	// the
                                                                        	// format
                                                                        	// `projects/{project_id}/locations/{location_id}/datasets/{da
                                                                        	// taset_id}/fhirStores/{fhir_store_id}`.
                                                                        	FhirStore string `json:"fhirStore,omitempty"`
                                                                        
                                                                        	// ResourceCount: The total number of resources included in the export
                                                                        	// operation. This is
                                                                        	// the sum of the success and error counts.
                                                                        	ResourceCount int64 `json:"resourceCount,omitempty,string"`
                                                                        
                                                                        	// SuccessCount: The number of resources that were exported.
                                                                        	SuccessCount int64 `json:"successCount,omitempty,string"`
                                                                        
                                                                        	// ForceSendFields is a list of field names (e.g. "ErrorCount") 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. "ErrorCount") 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:"-"`
                                                                        }

                                                                          GoogleCloudHealthcareV1alpha2FhirRestExportResourcesErrorDetails: Response when errors occur while exporting resources. This structure is included in the error details to describe the detailed outcome. It is only included when the operation finishes with errors.

                                                                          func (*GoogleCloudHealthcareV1alpha2FhirRestExportResourcesErrorDetails) MarshalJSON

                                                                          type GoogleCloudHealthcareV1alpha2FhirRestExportResourcesResponse

                                                                          type GoogleCloudHealthcareV1alpha2FhirRestExportResourcesResponse struct {
                                                                          	// FhirStore: The name of the FHIR store where resources have been
                                                                          	// exported, in
                                                                          	// the
                                                                          	// format
                                                                          	// `projects/{project_id}/locations/{location_id}/datasets/{da
                                                                          	// taset_id}/fhirStores/{fhir_store_id}`.
                                                                          	FhirStore string `json:"fhirStore,omitempty"`
                                                                          
                                                                          	// ResourceCount: The total number of resources exported from the
                                                                          	// requested FHIR store.
                                                                          	ResourceCount int64 `json:"resourceCount,omitempty,string"`
                                                                          
                                                                          	// ForceSendFields is a list of field names (e.g. "FhirStore") 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. "FhirStore") 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:"-"`
                                                                          }

                                                                            GoogleCloudHealthcareV1alpha2FhirRestExportResourcesResponse: Response when all resources export successfully. This structure will be included in the response to describe the detailed outcome. It will only be included when the operation finishes successfully.

                                                                            func (*GoogleCloudHealthcareV1alpha2FhirRestExportResourcesResponse) MarshalJSON

                                                                            type GoogleCloudHealthcareV1alpha2FhirRestGcsDestination

                                                                            type GoogleCloudHealthcareV1alpha2FhirRestGcsDestination struct {
                                                                            	// UriPrefix: URI for a Cloud Storage directory where result files
                                                                            	// should be written (in
                                                                            	// the format `gs://{bucket-id}/{path/to/destination/dir}`). If there is
                                                                            	// no
                                                                            	// trailing slash, the service will append one when composing the object
                                                                            	// path.
                                                                            	// The user is responsible for creating the Cloud Storage bucket
                                                                            	// referenced in
                                                                            	// `uri_prefix`.
                                                                            	UriPrefix string `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:"-"`
                                                                            }

                                                                              GoogleCloudHealthcareV1alpha2FhirRestGcsDestination: The configuration for exporting to Cloud Storage.

                                                                              func (*GoogleCloudHealthcareV1alpha2FhirRestGcsDestination) MarshalJSON

                                                                              type GoogleCloudHealthcareV1alpha2FhirRestGcsErrorDestination

                                                                              type GoogleCloudHealthcareV1alpha2FhirRestGcsErrorDestination struct {
                                                                              	// UriPrefix: URI for a Cloud Storage directory to which error report
                                                                              	// files should be
                                                                              	// written (in the format `gs://{bucket-id}/{path/to/destination/dir}`).
                                                                              	// If
                                                                              	// there is no trailing slash, the service will append one when
                                                                              	// composing the
                                                                              	// object path. The user is responsible for creating the Cloud Storage
                                                                              	// bucket
                                                                              	// referenced in `uri_prefix`.
                                                                              	UriPrefix string `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:"-"`
                                                                              }

                                                                                GoogleCloudHealthcareV1alpha2FhirRestGcsErrorDestination: Specifies the Cloud Storage destination where errors will be recorded.

                                                                                func (*GoogleCloudHealthcareV1alpha2FhirRestGcsErrorDestination) MarshalJSON

                                                                                type GoogleCloudHealthcareV1alpha2FhirRestGcsSource

                                                                                type GoogleCloudHealthcareV1alpha2FhirRestGcsSource 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:"-"`
                                                                                }

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

                                                                                  func (*GoogleCloudHealthcareV1alpha2FhirRestGcsSource) MarshalJSON

                                                                                  type GoogleCloudHealthcareV1alpha2FhirRestImportResourcesErrorDetails

                                                                                  type GoogleCloudHealthcareV1alpha2FhirRestImportResourcesErrorDetails struct {
                                                                                  	// ErrorCount: The number of resources that had errors.
                                                                                  	ErrorCount int64 `json:"errorCount,omitempty,string"`
                                                                                  
                                                                                  	// FhirStore: The name of the FHIR store where resources have been
                                                                                  	// imported, in
                                                                                  	// the
                                                                                  	// format
                                                                                  	// `projects/{project_id}/locations/{location_id}/datasets/{da
                                                                                  	// taset_id}/fhirStores/{fhir_store_id}`.
                                                                                  	FhirStore string `json:"fhirStore,omitempty"`
                                                                                  
                                                                                  	// InputSize: The total number of resources included in the source data.
                                                                                  	// This is the sum
                                                                                  	// of the success and error counts.
                                                                                  	InputSize int64 `json:"inputSize,omitempty,string"`
                                                                                  
                                                                                  	// SuccessCount: The number of resources that have been imported.
                                                                                  	SuccessCount int64 `json:"successCount,omitempty,string"`
                                                                                  
                                                                                  	// ForceSendFields is a list of field names (e.g. "ErrorCount") 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. "ErrorCount") 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:"-"`
                                                                                  }

                                                                                    GoogleCloudHealthcareV1alpha2FhirRestImportResourcesErrorDetails: Error response of importing resources. This structure will be included in the error details to describe the detailed error. It will only be included when the operation finishes with some failure.

                                                                                    func (*GoogleCloudHealthcareV1alpha2FhirRestImportResourcesErrorDetails) MarshalJSON

                                                                                    type GoogleCloudHealthcareV1alpha2FhirRestImportResourcesResponse

                                                                                    type GoogleCloudHealthcareV1alpha2FhirRestImportResourcesResponse struct {
                                                                                    	// FhirStore: The name of the FHIR store where the resources have been
                                                                                    	// imported, in
                                                                                    	// the
                                                                                    	// format
                                                                                    	// `projects/{project_id}/locations/{location_id}/datasets/{da
                                                                                    	// taset_id}/fhirStores/{fhir_store_id}`.
                                                                                    	FhirStore string `json:"fhirStore,omitempty"`
                                                                                    
                                                                                    	// InputSize: The total number of resources included in the source data.
                                                                                    	InputSize int64 `json:"inputSize,omitempty,string"`
                                                                                    
                                                                                    	// ForceSendFields is a list of field names (e.g. "FhirStore") 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. "FhirStore") 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:"-"`
                                                                                    }

                                                                                      GoogleCloudHealthcareV1alpha2FhirRestImportResourcesResponse: Final response of importing resources. This structure will be included in the response to describe the detailed outcome. It will only be included when the operation finishes successfully.

                                                                                      func (*GoogleCloudHealthcareV1alpha2FhirRestImportResourcesResponse) MarshalJSON

                                                                                      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: Output only. Resource name of the HL7v2 store, of the
                                                                                      	// form
                                                                                      	// `projects/{project_id}/datasets/{dataset_id}/hl7V2Stores/{hl7v2_s
                                                                                      	// tore_id}`.
                                                                                      	Name string `json:"name,omitempty"`
                                                                                      
                                                                                      	// NotificationConfig: The notification destination all messages (both
                                                                                      	// Ingest & Create) are
                                                                                      	// published on. Only the message name is sent as part of the
                                                                                      	// notification. If
                                                                                      	// this is unset, no notifications will be sent. Supplied by the client.
                                                                                      	NotificationConfig *NotificationConfig `json:"notificationConfig,omitempty"`
                                                                                      
                                                                                      	// ParserConfig: The configuration for the parser. It determines how the
                                                                                      	// server parses the
                                                                                      	// messages.
                                                                                      	ParserConfig *ParserConfig `json:"parserConfig,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 ImageAnnotation

                                                                                          type ImageAnnotation struct {
                                                                                          	// BoundingPolys: The list of polygons outlining the sensitive regions
                                                                                          	// in the image.
                                                                                          	BoundingPolys []*BoundingPoly `json:"boundingPolys,omitempty"`
                                                                                          
                                                                                          	// ForceSendFields is a list of field names (e.g. "BoundingPolys") 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. "BoundingPolys") 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:"-"`
                                                                                          }

                                                                                            ImageAnnotation: Image annotation.

                                                                                            func (*ImageAnnotation) MarshalJSON

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

                                                                                            type ImageConfig

                                                                                            type ImageConfig struct {
                                                                                            	// TextRedactionMode: Determines how to redact text from images.
                                                                                            	//
                                                                                            	// 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 the de-identification of image pixels.

                                                                                              func (*ImageConfig) MarshalJSON

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

                                                                                              type ImportDicomDataErrorDetails

                                                                                              type ImportDicomDataErrorDetails struct {
                                                                                              	// SampleErrors: Deprecated. Use only for debugging purposes.
                                                                                              	//
                                                                                              	// Contains sample errors encountered in imports of individual
                                                                                              	// resources
                                                                                              	// (for example, a Cloud Storage object).
                                                                                              	SampleErrors []*ErrorDetail `json:"sampleErrors,omitempty"`
                                                                                              
                                                                                              	// ForceSendFields is a list of field names (e.g. "SampleErrors") 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. "SampleErrors") 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:"-"`
                                                                                              }

                                                                                                ImportDicomDataErrorDetails: Returns the errors encountered during DICOM store import.

                                                                                                func (*ImportDicomDataErrorDetails) MarshalJSON

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

                                                                                                type ImportDicomDataRequest

                                                                                                type ImportDicomDataRequest struct {
                                                                                                	// GcsSource: Cloud Storage source data location and import
                                                                                                	// configuration.
                                                                                                	//
                                                                                                	// The Cloud Storage location requires the
                                                                                                	// `roles/storage.objectViewer`
                                                                                                	// Cloud IAM role.
                                                                                                	GcsSource *GoogleCloudHealthcareV1alpha2DicomGcsSource `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 will accept duplicate DICOM instances, by simply ignoring the newly pushed instance (it will not overwrite).

                                                                                                  func (*ImportDicomDataRequest) MarshalJSON

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

                                                                                                  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`
                                                                                                  	// will be used.
                                                                                                  	//   "BUNDLE" - The source file contains one or more lines of
                                                                                                  	// newline-delimited JSON
                                                                                                  	// (ndjson). Each line is a bundle, which contains one or more
                                                                                                  	// resources.
                                                                                                  	// Set the bundle type to `history` to import resource versions.
                                                                                                  	//   "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"`
                                                                                                  
                                                                                                  	// GcsErrorDestination: The Cloud Storage destination to write the error
                                                                                                  	// report to.
                                                                                                  	//
                                                                                                  	// The Cloud Storage location requires the `roles/storage.objectAdmin`
                                                                                                  	// Cloud
                                                                                                  	// IAM role.
                                                                                                  	//
                                                                                                  	// Note that writing a file to the same destination multiple times
                                                                                                  	// will
                                                                                                  	// result in the previous version of the file being overwritten.
                                                                                                  	GcsErrorDestination *GoogleCloudHealthcareV1alpha2FhirRestGcsErrorDestination `json:"gcsErrorDestination,omitempty"`
                                                                                                  
                                                                                                  	// GcsSource: Cloud Storage source data location and import
                                                                                                  	// configuration.
                                                                                                  	//
                                                                                                  	// The Cloud Storage location requires the
                                                                                                  	// `roles/storage.objectViewer`
                                                                                                  	// Cloud IAM role.
                                                                                                  	//
                                                                                                  	// Each Cloud Storage object should be a text file that contains the
                                                                                                  	// format
                                                                                                  	// specified in ContentStructu.
                                                                                                  	GcsSource *GoogleCloudHealthcareV1alpha2FhirRestGcsSource `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 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 ListAnnotationStoresResponse

                                                                                                          type ListAnnotationStoresResponse struct {
                                                                                                          	// AnnotationStores: The returned Annotation stores. Won't be more
                                                                                                          	// Annotation stores than the
                                                                                                          	// value of page_size in the request.
                                                                                                          	AnnotationStores []*AnnotationStore `json:"annotationStores,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. "AnnotationStores") 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. "AnnotationStores") 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:"-"`
                                                                                                          }

                                                                                                            ListAnnotationStoresResponse: Lists the Annotation stores in the given dataset.

                                                                                                            func (*ListAnnotationStoresResponse) MarshalJSON

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

                                                                                                            type ListAnnotationsResponse

                                                                                                            type ListAnnotationsResponse struct {
                                                                                                            	// Annotations: The returned Annotations names. Won't be more values
                                                                                                            	// than the value of
                                                                                                            	// page_size in the request.
                                                                                                            	Annotations []string `json:"annotations,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. "Annotations") 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. "Annotations") 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:"-"`
                                                                                                            }

                                                                                                              ListAnnotationsResponse: Lists the Annotations in the specified Annotation store.

                                                                                                              func (*ListAnnotationsResponse) MarshalJSON

                                                                                                              func (s *ListAnnotationsResponse) 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 {
                                                                                                                        	// Messages: The returned message names. Won't be more values than the
                                                                                                                        	// value of
                                                                                                                        	// page_size in the request.
                                                                                                                        	Messages []string `json:"messages,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. "Messages") 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. "Messages") 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 and trigger event for this message.
                                                                                                                              	// MSH-9.
                                                                                                                              	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 http://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 will contain the resource
                                                                                                                                	// name.
                                                                                                                                	// PubsubMessage.MessageId is the ID of this message. It is guaranteed
                                                                                                                                	// to be
                                                                                                                                	// unique within the topic.
                                                                                                                                	// PubsubMessage.PublishTime is the time at which the message was
                                                                                                                                	// published.
                                                                                                                                	// Notifications are only sent if the topic is
                                                                                                                                	// non-empty.
                                                                                                                                	// [Topic
                                                                                                                                	// names](https://cloud.google.com/pubsub/docs/overview#names) must be
                                                                                                                                	// scoped
                                                                                                                                	// to a project. cloud-healthcare@system.gserviceaccount.com must
                                                                                                                                	// have
                                                                                                                                	// publisher permissions on the given Cloud Pub/Sub topic. Not having
                                                                                                                                	// adequate
                                                                                                                                	// permissions will cause the calls that send notifications to fail.
                                                                                                                                	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 notifications should be sent 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"`
                                                                                                                                    
                                                                                                                                    	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"`
                                                                                                                                    
                                                                                                                                    	// 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 be used as the segment terminator. If
                                                                                                                                        	// this is unset, '\r' will
                                                                                                                                        	// be used as the 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, e.g. 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`.
                                                                                                                                            	// `bindings` with no members will result in an error.
                                                                                                                                            	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.
                                                                                                                                            	//
                                                                                                                                            	// If no `etag` is provided in the call to `setIamPolicy`, then the
                                                                                                                                            	// existing
                                                                                                                                            	// policy is overwritten.
                                                                                                                                            	Etag string `json:"etag,omitempty"`
                                                                                                                                            
                                                                                                                                            	// Version: Deprecated.
                                                                                                                                            	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: Defines an Identity and Access Management (IAM) policy. It is used to specify access control policies for Cloud Platform resources.

                                                                                                                                              A `Policy` consists of a list of `bindings`. A `binding` binds a list of `members` to a `role`, where the members can be user accounts, Google groups, Google domains, and service accounts. A `role` is a named list of permissions defined by IAM.

                                                                                                                                              **JSON Example**

                                                                                                                                              {
                                                                                                                                                "bindings": [
                                                                                                                                                  {
                                                                                                                                                    "role": "roles/owner",
                                                                                                                                                    "members": [
                                                                                                                                                      "user:mike@example.com",
                                                                                                                                                      "group:admins@example.com",
                                                                                                                                                      "domain:google.com",
                                                                                                                                              

                                                                                                                                              "serviceAccount:my-other-app@appspot.gserviceaccount.com"

                                                                                                                                                    ]
                                                                                                                                                  },
                                                                                                                                                  {
                                                                                                                                                    "role": "roles/viewer",
                                                                                                                                                    "members": ["user:sean@example.com"]
                                                                                                                                                  }
                                                                                                                                                ]
                                                                                                                                              }
                                                                                                                                              

                                                                                                                                              **YAML Example**

                                                                                                                                              bindings:
                                                                                                                                              - members:
                                                                                                                                                - user:mike@example.com
                                                                                                                                                - group:admins@example.com
                                                                                                                                                - domain:google.com
                                                                                                                                                - serviceAccount:my-other-app@appspot.gserviceaccount.com
                                                                                                                                                role: roles/owner
                                                                                                                                              - members:
                                                                                                                                                - user:sean@example.com
                                                                                                                                                role: roles/viewer
                                                                                                                                              

                                                                                                                                              For a description of IAM and its features, see the [IAM developer's guide](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 ProjectsLocationsDatasetsAnnotationStoresAnnotationsCreateCall

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

                                                                                                                                                func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsCreateCall) Context

                                                                                                                                                  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 (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsCreateCall) Do

                                                                                                                                                    Do executes the "healthcare.projects.locations.datasets.annotationStores.annotations.create" call. Exactly one of *Annotation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Annotation.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 (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsCreateCall) Fields

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

                                                                                                                                                      func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsCreateCall) Header

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

                                                                                                                                                        type ProjectsLocationsDatasetsAnnotationStoresAnnotationsDeleteCall

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

                                                                                                                                                        func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsDeleteCall) Context

                                                                                                                                                          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 (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsDeleteCall) Do

                                                                                                                                                            Do executes the "healthcare.projects.locations.datasets.annotationStores.annotations.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 (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsDeleteCall) Fields

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

                                                                                                                                                              func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsDeleteCall) Header

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

                                                                                                                                                                type ProjectsLocationsDatasetsAnnotationStoresAnnotationsGetCall

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

                                                                                                                                                                func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsGetCall) Context

                                                                                                                                                                  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 (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsGetCall) Do

                                                                                                                                                                    Do executes the "healthcare.projects.locations.datasets.annotationStores.annotations.get" call. Exactly one of *Annotation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Annotation.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 (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsGetCall) Fields

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

                                                                                                                                                                      func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsGetCall) Header

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

                                                                                                                                                                        func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsGetCall) IfNoneMatch

                                                                                                                                                                          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 ProjectsLocationsDatasetsAnnotationStoresAnnotationsListCall

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

                                                                                                                                                                          func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsListCall) Context

                                                                                                                                                                            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 (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsListCall) Do

                                                                                                                                                                              Do executes the "healthcare.projects.locations.datasets.annotationStores.annotations.list" call. Exactly one of *ListAnnotationsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListAnnotationsResponse.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 (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsListCall) Fields

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

                                                                                                                                                                                func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsListCall) Filter

                                                                                                                                                                                  Filter sets the optional parameter "filter": Restricts Annotations returned to those matching a filter. Syntax: https://cloud.google.com/appengine/docs/standard/python/search /query_strings Fields/functions available for filtering are: - source_version

                                                                                                                                                                                  func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsListCall) Header

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

                                                                                                                                                                                    func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsListCall) IfNoneMatch

                                                                                                                                                                                      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 (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsListCall) PageSize

                                                                                                                                                                                        PageSize sets the optional parameter "pageSize": Limit on the number of Annotations to return in a single response. If zero the default page size of 100 is used.

                                                                                                                                                                                        func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsListCall) PageToken

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

                                                                                                                                                                                          func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsListCall) Pages

                                                                                                                                                                                            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 ProjectsLocationsDatasetsAnnotationStoresAnnotationsPatchCall

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

                                                                                                                                                                                            func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsPatchCall) Context

                                                                                                                                                                                              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 (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsPatchCall) Do

                                                                                                                                                                                                Do executes the "healthcare.projects.locations.datasets.annotationStores.annotations.patch" call. Exactly one of *Annotation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Annotation.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 (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsPatchCall) Fields

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

                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsPatchCall) Header

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

                                                                                                                                                                                                    func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsPatchCall) UpdateMask

                                                                                                                                                                                                      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/re ference/google.protobuf#fieldmask

                                                                                                                                                                                                      type ProjectsLocationsDatasetsAnnotationStoresAnnotationsService

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

                                                                                                                                                                                                      func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsService) Create

                                                                                                                                                                                                        Create: Creates a new Annotation record. It is valid to create Annotation objects for the same source more than once since a unique ID is assigned to each record by this service.

                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsService) Delete

                                                                                                                                                                                                          Delete: Deletes an Annotation or returns NOT_FOUND if it does not exist.

                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsService) Get

                                                                                                                                                                                                            Get: Gets an Annotation.

                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsService) List

                                                                                                                                                                                                              List: Lists the Annotations in the given Annotation store for a source resource.

                                                                                                                                                                                                              func (*ProjectsLocationsDatasetsAnnotationStoresAnnotationsService) Patch

                                                                                                                                                                                                                Patch: Updates the Annotation.

                                                                                                                                                                                                                type ProjectsLocationsDatasetsAnnotationStoresCreateCall

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

                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsAnnotationStoresCreateCall) AnnotationStoreId

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

                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsAnnotationStoresCreateCall) Context

                                                                                                                                                                                                                    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 (*ProjectsLocationsDatasetsAnnotationStoresCreateCall) Do

                                                                                                                                                                                                                      Do executes the "healthcare.projects.locations.datasets.annotationStores.create" call. Exactly one of *AnnotationStore or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AnnotationStore.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 (*ProjectsLocationsDatasetsAnnotationStoresCreateCall) Fields

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

                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsAnnotationStoresCreateCall) Header

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

                                                                                                                                                                                                                          type ProjectsLocationsDatasetsAnnotationStoresDeleteCall

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

                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsAnnotationStoresDeleteCall) Context

                                                                                                                                                                                                                            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 (*ProjectsLocationsDatasetsAnnotationStoresDeleteCall) Do

                                                                                                                                                                                                                              Do executes the "healthcare.projects.locations.datasets.annotationStores.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 (*ProjectsLocationsDatasetsAnnotationStoresDeleteCall) Fields

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

                                                                                                                                                                                                                                func (*ProjectsLocationsDatasetsAnnotationStoresDeleteCall) Header

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

                                                                                                                                                                                                                                  type ProjectsLocationsDatasetsAnnotationStoresGetCall

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

                                                                                                                                                                                                                                  func (*ProjectsLocationsDatasetsAnnotationStoresGetCall) Context

                                                                                                                                                                                                                                    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 (*ProjectsLocationsDatasetsAnnotationStoresGetCall) Do

                                                                                                                                                                                                                                      Do executes the "healthcare.projects.locations.datasets.annotationStores.get" call. Exactly one of *AnnotationStore or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AnnotationStore.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 (*ProjectsLocationsDatasetsAnnotationStoresGetCall) Fields

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

                                                                                                                                                                                                                                        func (*ProjectsLocationsDatasetsAnnotationStoresGetCall) Header

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

                                                                                                                                                                                                                                          func (*ProjectsLocationsDatasetsAnnotationStoresGetCall) IfNoneMatch

                                                                                                                                                                                                                                            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 ProjectsLocationsDatasetsAnnotationStoresGetIamPolicyCall

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

                                                                                                                                                                                                                                            func (*ProjectsLocationsDatasetsAnnotationStoresGetIamPolicyCall) Context

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