Documentation

Overview

Package healthcare provides access to the Cloud Healthcare API.

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

Creating a client

Usage example:

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

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

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

Other authentication options

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

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

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

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

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

Index

Constants

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

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type ActivateConsentRequest

    type ActivateConsentRequest struct {
    	// ConsentArtifact: Required. The resource name of the Consent artifact
    	// that contains documentation of the user's consent, of the form
    	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/c
    	// onsentStores/{consent_store_id}/consentArtifacts/{consent_artifact_id}
    	// `. If the draft Consent had a Consent artifact, this Consent artifact
    	// overwrites it.
    	ConsentArtifact string `json:"consentArtifact,omitempty"`
    
    	// ExpireTime: Timestamp in UTC of when this Consent is considered
    	// expired.
    	ExpireTime string `json:"expireTime,omitempty"`
    
    	// Ttl: The time to live for this Consent from when it is marked as
    	// active.
    	Ttl string `json:"ttl,omitempty"`
    
    	// ForceSendFields is a list of field names (e.g. "ConsentArtifact") 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. "ConsentArtifact") 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:"-"`
    }

      ActivateConsentRequest: Activates the latest revision of the specified Consent by committing a new revision with `state` updated to `ACTIVE`. If the latest revision of the given Consent is in the `ACTIVE` state, no new revision is committed. A FAILED_PRECONDITION error occurs if the latest revision of the given consent is in the `REJECTED` or `REVOKED` state.

      func (*ActivateConsentRequest) MarshalJSON

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

      type ArchiveUserDataMappingRequest

      type ArchiveUserDataMappingRequest struct {
      }

        ArchiveUserDataMappingRequest: Archives the specified User data mapping.

        type ArchiveUserDataMappingResponse

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

          ArchiveUserDataMappingResponse: Archives the specified User data mapping.

          type Attribute

          type Attribute struct {
          	// AttributeDefinitionId: Indicates the name of an attribute defined in
          	// the consent store.
          	AttributeDefinitionId string `json:"attributeDefinitionId,omitempty"`
          
          	// Values: Required. The value of the attribute. Must be an acceptable
          	// value as defined in the consent store. For example, if the consent
          	// store defines "data type" with acceptable values "questionnaire" and
          	// "step-count", when the attribute name is data type, this field must
          	// contain one of those values.
          	Values []string `json:"values,omitempty"`
          
          	// ForceSendFields is a list of field names (e.g.
          	// "AttributeDefinitionId") 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. "AttributeDefinitionId") 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:"-"`
          }

            Attribute: An attribute value for a Consent or User data mapping. Each Attribute must have a corresponding AttributeDefinition in the consent store that defines the default and allowed values.

            func (*Attribute) MarshalJSON

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

            type AttributeDefinition

            type AttributeDefinition struct {
            	// AllowedValues: Required. Possible values for the attribute. The
            	// number of allowed values must not exceed 100. An empty list is
            	// invalid. The list can only be expanded after creation.
            	AllowedValues []string `json:"allowedValues,omitempty"`
            
            	// Category: Required. The category of the attribute. The value of this
            	// field cannot be changed after creation.
            	//
            	// Possible values:
            	//   "CATEGORY_UNSPECIFIED" - No category specified. This option is
            	// invalid.
            	//   "RESOURCE" - Specify this category when this attribute describes
            	// the properties of resources. For example, data anonymity or data
            	// type.
            	//   "REQUEST" - Specify this category when this attribute describes the
            	// properties of requests. For example, requester's role or requester's
            	// organization.
            	Category string `json:"category,omitempty"`
            
            	// ConsentDefaultValues: Optional. Default values of the attribute in
            	// Consents. If no default values are specified, it defaults to an empty
            	// value.
            	ConsentDefaultValues []string `json:"consentDefaultValues,omitempty"`
            
            	// DataMappingDefaultValue: Optional. Default value of the attribute in
            	// User data mappings. If no default value is specified, it defaults to
            	// an empty value. This field is only applicable to attributes of the
            	// category `RESOURCE`.
            	DataMappingDefaultValue string `json:"dataMappingDefaultValue,omitempty"`
            
            	// Description: Optional. A description of the attribute.
            	Description string `json:"description,omitempty"`
            
            	// Name: Resource name of the Attribute definition, of the form
            	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/c
            	// onsentStores/{consent_store_id}/attributeDefinitions/{attribute_defini
            	// tion_id}`. Cannot be changed after creation.
            	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. "AllowedValues") 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. "AllowedValues") 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:"-"`
            }

              AttributeDefinition: A client-defined consent attribute.

              func (*AttributeDefinition) MarshalJSON

              func (s *AttributeDefinition) 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. If the
                  	// condition evaluates to `true`, then this binding applies to the
                  	// current request. If the condition evaluates to `false`, then this
                  	// binding does not apply to the current request. However, a different
                  	// role binding might grant the same role to one or more of the members
                  	// in this binding. To learn which resources support conditions in their
                  	// IAM policies, see the IAM documentation
                  	// (https://cloud.google.com/iam/help/conditions/resource-policies).
                  	Condition *Expr `json:"condition,omitempty"`
                  
                  	// Members: Specifies the identities requesting access for a Cloud
                  	// Platform resource. `members` can have the following values: *
                  	// `allUsers`: A special identifier that represents anyone who is on the
                  	// internet; with or without a Google account. *
                  	// `allAuthenticatedUsers`: A special identifier that represents anyone
                  	// who is authenticated with a Google account or a service account. *
                  	// `user:{emailid}`: An email address that represents a specific Google
                  	// account. For example, `alice@example.com` . *
                  	// `serviceAccount:{emailid}`: An email address that represents a
                  	// service account. For example,
                  	// `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An
                  	// email address that represents a Google group. For example,
                  	// `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An
                  	// email address (plus unique identifier) representing a user that has
                  	// been recently deleted. For example,
                  	// `alice@example.com?uid=123456789012345678901`. If the user is
                  	// recovered, this value reverts to `user:{emailid}` and the recovered
                  	// user retains the role in the binding. *
                  	// `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address
                  	// (plus unique identifier) representing a service account that has been
                  	// recently deleted. For example,
                  	// `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`.
                  	// If the service account is undeleted, this value reverts to
                  	// `serviceAccount:{emailid}` and the undeleted service account retains
                  	// the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`:
                  	// An email address (plus unique identifier) representing a Google group
                  	// that has been recently deleted. For example,
                  	// `admins@example.com?uid=123456789012345678901`. If the group is
                  	// recovered, this value reverts to `group:{emailid}` and the recovered
                  	// group retains the role in the binding. * `domain:{domain}`: The G
                  	// Suite domain (primary) that represents all the users of that domain.
                  	// For example, `google.com` or `example.com`.
                  	Members []string `json:"members,omitempty"`
                  
                  	// Role: Role that is assigned to `members`. For example,
                  	// `roles/viewer`, `roles/editor`, or `roles/owner`.
                  	Role string `json:"role,omitempty"`
                  
                  	// ForceSendFields is a list of field names (e.g. "Condition") to
                  	// unconditionally include in API requests. By default, fields with
                  	// empty values are omitted from API requests. However, any non-pointer,
                  	// non-interface field appearing in ForceSendFields will be sent to the
                  	// server regardless of whether the field is empty or not. This may be
                  	// used to include empty fields in Patch requests.
                  	ForceSendFields []string `json:"-"`
                  
                  	// NullFields is a list of field names (e.g. "Condition") to include in
                  	// API requests with the JSON null value. By default, fields with empty
                  	// values are omitted from API requests. However, any field with an
                  	// empty value appearing in NullFields will be sent to the server as
                  	// null. It is an error if a field in this list has a non-empty value.
                  	// This may be used to include null fields in Patch requests.
                  	NullFields []string `json:"-"`
                  }

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

                    func (*Binding) MarshalJSON

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

                    type CancelOperationRequest

                    type CancelOperationRequest struct {
                    }

                      CancelOperationRequest: The request message for Operations.CancelOperation.

                      type CharacterMaskConfig

                      type CharacterMaskConfig struct {
                      	// MaskingCharacter: Character to mask the sensitive values. If not
                      	// supplied, defaults to "*".
                      	MaskingCharacter string `json:"maskingCharacter,omitempty"`
                      
                      	// ForceSendFields is a list of field names (e.g. "MaskingCharacter") to
                      	// unconditionally include in API requests. By default, fields with
                      	// empty values are omitted from API requests. However, any non-pointer,
                      	// non-interface field appearing in ForceSendFields will be sent to the
                      	// server regardless of whether the field is empty or not. This may be
                      	// used to include empty fields in Patch requests.
                      	ForceSendFields []string `json:"-"`
                      
                      	// NullFields is a list of field names (e.g. "MaskingCharacter") to
                      	// include in API requests with the JSON null value. By default, fields
                      	// with empty values are omitted from API requests. However, any field
                      	// with an empty value appearing in NullFields will be sent to the
                      	// server as null. It is an error if a field in this list has a
                      	// non-empty value. This may be used to include null fields in Patch
                      	// requests.
                      	NullFields []string `json:"-"`
                      }

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

                        func (*CharacterMaskConfig) MarshalJSON

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

                        type CheckDataAccessRequest

                        type CheckDataAccessRequest struct {
                        	// ConsentList: Optional. Specific Consents to evaluate the access
                        	// request against. These Consents must have the same `user_id` as the
                        	// evaluated User data mapping, must exist in the current
                        	// `consent_store`, and have a `state` of either `ACTIVE` or `DRAFT`. A
                        	// maximum of 100 Consents can be provided here. If no selection is
                        	// specified, the access request is evaluated against all `ACTIVE`
                        	// unexpired Consents with the same `user_id` as the evaluated User data
                        	// mapping.
                        	ConsentList *ConsentList `json:"consentList,omitempty"`
                        
                        	// DataId: Required. The unique identifier of the resource to check
                        	// access for. This identifier must correspond to a User data mapping in
                        	// the given consent store.
                        	DataId string `json:"dataId,omitempty"`
                        
                        	// RequestAttributes: The values of request attributes associated with
                        	// this access request.
                        	RequestAttributes map[string]string `json:"requestAttributes,omitempty"`
                        
                        	// ResponseView: Optional. The view for CheckDataAccessResponse. If
                        	// unspecified, defaults to `BASIC` and returns `consented` as `TRUE` or
                        	// `FALSE`.
                        	//
                        	// Possible values:
                        	//   "RESPONSE_VIEW_UNSPECIFIED" - No response view specified. The API
                        	// will default to the BASIC view.
                        	//   "BASIC" - Only the `consented` field is populated in
                        	// CheckDataAccessResponse.
                        	//   "FULL" - All fields within CheckDataAccessResponse are populated.
                        	// When set to `FULL`, all `ACTIVE` Consents are evaluated even if a
                        	// matching policy is found during evaluation.
                        	ResponseView string `json:"responseView,omitempty"`
                        
                        	// ForceSendFields is a list of field names (e.g. "ConsentList") 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. "ConsentList") 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:"-"`
                        }

                          CheckDataAccessRequest: Checks if a particular data_id of a User data mapping in the given consent store is consented for a given use.

                          func (*CheckDataAccessRequest) MarshalJSON

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

                          type CheckDataAccessResponse

                          type CheckDataAccessResponse struct {
                          	// ConsentDetails: The resource names of all evaluated Consents mapped
                          	// to their evaluation.
                          	ConsentDetails map[string]ConsentEvaluation `json:"consentDetails,omitempty"`
                          
                          	// Consented: Whether the requested resource is consented for the given
                          	// use.
                          	Consented bool `json:"consented,omitempty"`
                          
                          	// ServerResponse contains the HTTP response code and headers from the
                          	// server.
                          	googleapi.ServerResponse `json:"-"`
                          
                          	// ForceSendFields is a list of field names (e.g. "ConsentDetails") 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. "ConsentDetails") 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:"-"`
                          }

                            CheckDataAccessResponse: Checks if a particular data_id of a User data mapping in the given consent store is consented for a given use.

                            func (*CheckDataAccessResponse) MarshalJSON

                            func (s *CheckDataAccessResponse) MarshalJSON() ([]byte, error)
                            type Consent struct {
                            	// ConsentArtifact: Required. The resource name of the Consent artifact
                            	// that contains proof of the end user's consent, of the form
                            	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/c
                            	// onsentStores/{consent_store_id}/consentArtifacts/{consent_artifact_id}
                            	// `.
                            	ConsentArtifact string `json:"consentArtifact,omitempty"`
                            
                            	// ExpireTime: Timestamp in UTC of when this Consent is considered
                            	// expired.
                            	ExpireTime string `json:"expireTime,omitempty"`
                            
                            	// Metadata: Optional. User-supplied key-value pairs used to organize
                            	// Consent resources. Metadata keys must: - be between 1 and 63
                            	// characters long - have a UTF-8 encoding of maximum 128 bytes - begin
                            	// with a letter - consist of up to 63 characters including lowercase
                            	// letters, numeric characters, underscores, and dashes Metadata values
                            	// must be: - be between 1 and 63 characters long - have a UTF-8
                            	// encoding of maximum 128 bytes - consist of up to 63 characters
                            	// including lowercase letters, numeric characters, underscores, and
                            	// dashes No more than 64 metadata entries can be associated with a
                            	// given consent.
                            	Metadata map[string]string `json:"metadata,omitempty"`
                            
                            	// Name: Resource name of the Consent, of the form
                            	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/c
                            	// onsentStores/{consent_store_id}/consents/{consent_id}`. Cannot be
                            	// changed after creation.
                            	Name string `json:"name,omitempty"`
                            
                            	// Policies: Optional. Represents a user's consent in terms of the
                            	// resources that can be accessed and under what conditions.
                            	Policies []*GoogleCloudHealthcareV1ConsentPolicy `json:"policies,omitempty"`
                            
                            	// RevisionCreateTime: Output only. The timestamp that the revision was
                            	// created.
                            	RevisionCreateTime string `json:"revisionCreateTime,omitempty"`
                            
                            	// RevisionId: Output only. The revision ID of the Consent. The format
                            	// is an 8-character hexadecimal string. Refer to a specific revision of
                            	// a Consent by appending `@{revision_id}` to the Consent's resource
                            	// name.
                            	RevisionId string `json:"revisionId,omitempty"`
                            
                            	// State: Required. Indicates the current state of this Consent.
                            	//
                            	// Possible values:
                            	//   "STATE_UNSPECIFIED" - No state specified.
                            	//   "ACTIVE" - The Consent is active and is considered when evaluating
                            	// a user's consent on resources.
                            	//   "ARCHIVED" - When a Consent is updated, the current version is
                            	// archived and a new one is created with its state set to the updated
                            	// Consent's previous state.
                            	//   "REVOKED" - A revoked Consent is not considered when evaluating a
                            	// user's consent on resources.
                            	//   "DRAFT" - A draft Consent is not considered when evaluating a
                            	// user's consent on resources unless explicitly specified.
                            	//   "REJECTED" - When a draft Consent is rejected by a user, it is set
                            	// to a rejected state. A rejected Consent is not considered when
                            	// evaluating a user's consent on resources.
                            	State string `json:"state,omitempty"`
                            
                            	// Ttl: Input only. The time to live for this Consent from when it is
                            	// created.
                            	Ttl string `json:"ttl,omitempty"`
                            
                            	// UserId: Required. User's UUID provided by the client.
                            	UserId string `json:"userId,omitempty"`
                            
                            	// ServerResponse contains the HTTP response code and headers from the
                            	// server.
                            	googleapi.ServerResponse `json:"-"`
                            
                            	// ForceSendFields is a list of field names (e.g. "ConsentArtifact") 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. "ConsentArtifact") 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:"-"`
                            }

                              Consent: Represents a user's consent.

                              func (*Consent) MarshalJSON

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

                              type ConsentArtifact

                              type ConsentArtifact struct {
                              	// ConsentContentScreenshots: Optional. Screenshots, PDFs, or other
                              	// binary information documenting the user's consent.
                              	ConsentContentScreenshots []*Image `json:"consentContentScreenshots,omitempty"`
                              
                              	// ConsentContentVersion: Optional. An string indicating the version of
                              	// the consent information shown to the user.
                              	ConsentContentVersion string `json:"consentContentVersion,omitempty"`
                              
                              	// GuardianSignature: Optional. A signature from a guardian.
                              	GuardianSignature *Signature `json:"guardianSignature,omitempty"`
                              
                              	// Metadata: Optional. Metadata associated with the Consent artifact.
                              	// For example, the consent locale or user agent version.
                              	Metadata map[string]string `json:"metadata,omitempty"`
                              
                              	// Name: Resource name of the Consent artifact, of the form
                              	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/c
                              	// onsentStores/{consent_store_id}/consentArtifacts/{consent_artifact_id}
                              	// `. Cannot be changed after creation.
                              	Name string `json:"name,omitempty"`
                              
                              	// UserId: Required. User's UUID provided by the client.
                              	UserId string `json:"userId,omitempty"`
                              
                              	// UserSignature: Optional. User's signature.
                              	UserSignature *Signature `json:"userSignature,omitempty"`
                              
                              	// WitnessSignature: Optional. A signature from a witness.
                              	WitnessSignature *Signature `json:"witnessSignature,omitempty"`
                              
                              	// ServerResponse contains the HTTP response code and headers from the
                              	// server.
                              	googleapi.ServerResponse `json:"-"`
                              
                              	// ForceSendFields is a list of field names (e.g.
                              	// "ConsentContentScreenshots") 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.
                              	// "ConsentContentScreenshots") 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:"-"`
                              }

                                ConsentArtifact: Documentation of a user's consent.

                                func (*ConsentArtifact) MarshalJSON

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

                                type ConsentEvaluation

                                type ConsentEvaluation struct {
                                	// EvaluationResult: The evaluation result.
                                	//
                                	// Possible values:
                                	//   "EVALUATION_RESULT_UNSPECIFIED" - No evaluation result specified.
                                	// This option is invalid.
                                	//   "NOT_APPLICABLE" - The Consent is not applicable to the requested
                                	// access determination. For example, the Consent does not apply to the
                                	// user for which the access determination is requested, or it has a
                                	// `state` of `REVOKED`.
                                	//   "NO_MATCHING_POLICY" - The Consent does not have a policy that
                                	// matches the `resource_attributes` of the evaluated resource.
                                	//   "NO_SATISFIED_POLICY" - The Consent has at least one policy that
                                	// matches the `resource_attributes` of the evaluated resource, but no
                                	// `authorization_rule` was satisfied.
                                	//   "HAS_SATISFIED_POLICY" - The Consent has at least one policy that
                                	// matches the `resource_attributes` of the evaluated resource, and at
                                	// least one `authorization_rule` was satisfied.
                                	EvaluationResult string `json:"evaluationResult,omitempty"`
                                
                                	// ForceSendFields is a list of field names (e.g. "EvaluationResult") 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. "EvaluationResult") 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:"-"`
                                }

                                  ConsentEvaluation: The detailed evaluation of a particular Consent.

                                  func (*ConsentEvaluation) MarshalJSON

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

                                  type ConsentList

                                  type ConsentList struct {
                                  	// Consents: The resource names of the Consents to evaluate against, of
                                  	// the form
                                  	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/c
                                  	// onsentStores/{consent_store_id}/consents/{consent_id}`.
                                  	Consents []string `json:"consents,omitempty"`
                                  
                                  	// ForceSendFields is a list of field names (e.g. "Consents") 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. "Consents") 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:"-"`
                                  }

                                    ConsentList: List of resource names of Consent resources.

                                    func (*ConsentList) MarshalJSON

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

                                    type ConsentStore

                                    type ConsentStore struct {
                                    	// DefaultConsentTtl: Optional. Default time to live for Consents
                                    	// created in this store. Must be at least 24 hours. Updating this field
                                    	// will not affect the expiration time of existing consents.
                                    	DefaultConsentTtl string `json:"defaultConsentTtl,omitempty"`
                                    
                                    	// EnableConsentCreateOnUpdate: Optional. If `true`, UpdateConsent
                                    	// creates the Consent if it does not already exist. If unspecified,
                                    	// defaults to `false`.
                                    	EnableConsentCreateOnUpdate bool `json:"enableConsentCreateOnUpdate,omitempty"`
                                    
                                    	// Labels: Optional. User-supplied key-value pairs used to organize
                                    	// consent 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
                                    	// 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. For more information:
                                    	// https://cloud.google.com/healthcare/docs/how-tos/labeling-resources
                                    	Labels map[string]string `json:"labels,omitempty"`
                                    
                                    	// Name: Resource name of the consent store, of the form
                                    	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/c
                                    	// onsentStores/{consent_store_id}`. Cannot be changed after creation.
                                    	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. "DefaultConsentTtl")
                                    	// 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. "DefaultConsentTtl") 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:"-"`
                                    }

                                      ConsentStore: Represents a consent store.

                                      func (*ConsentStore) MarshalJSON

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

                                      type CreateMessageRequest

                                      type CreateMessageRequest struct {
                                      	// Message: HL7v2 message.
                                      	Message *Message `json:"message,omitempty"`
                                      
                                      	// ForceSendFields is a list of field names (e.g. "Message") to
                                      	// unconditionally include in API requests. By default, fields with
                                      	// empty values are omitted from API requests. However, any non-pointer,
                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                      	// server regardless of whether the field is empty or not. This may be
                                      	// used to include empty fields in Patch requests.
                                      	ForceSendFields []string `json:"-"`
                                      
                                      	// NullFields is a list of field names (e.g. "Message") to include in
                                      	// API requests with the JSON null value. By default, fields with empty
                                      	// values are omitted from API requests. However, any field with an
                                      	// empty value appearing in NullFields will be sent to the server as
                                      	// null. It is an error if a field in this list has a non-empty value.
                                      	// This may be used to include null fields in Patch requests.
                                      	NullFields []string `json:"-"`
                                      }

                                        CreateMessageRequest: Creates a new message.

                                        func (*CreateMessageRequest) MarshalJSON

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

                                        type CryptoHashConfig

                                        type CryptoHashConfig struct {
                                        	// CryptoKey: An AES 128/192/256 bit key. Causes the hash to be computed
                                        	// based on this key. A default key is generated for each Deidentify
                                        	// operation and is used wherever crypto_key is not specified.
                                        	CryptoKey string `json:"cryptoKey,omitempty"`
                                        
                                        	// ForceSendFields is a list of field names (e.g. "CryptoKey") to
                                        	// unconditionally include in API requests. By default, fields with
                                        	// empty values are omitted from API requests. However, any non-pointer,
                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                        	// server regardless of whether the field is empty or not. This may be
                                        	// used to include empty fields in Patch requests.
                                        	ForceSendFields []string `json:"-"`
                                        
                                        	// NullFields is a list of field names (e.g. "CryptoKey") to include in
                                        	// API requests with the JSON null value. By default, fields with empty
                                        	// values are omitted from API requests. However, any field with an
                                        	// empty value appearing in NullFields will be sent to the server as
                                        	// null. It is an error if a field in this list has a non-empty value.
                                        	// This may be used to include null fields in Patch requests.
                                        	NullFields []string `json:"-"`
                                        }

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

                                          func (*CryptoHashConfig) MarshalJSON

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

                                          type Dataset

                                          type Dataset struct {
                                          	// Name: Resource name of the dataset, of the form
                                          	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`.
                                          	Name string `json:"name,omitempty"`
                                          
                                          	// TimeZone: The default timezone used by this dataset. Must be a either
                                          	// a valid IANA time zone name such as "America/New_York" or empty,
                                          	// which defaults to UTC. This is used for parsing times in resources,
                                          	// such as HL7 messages, where no explicit timezone is specified.
                                          	TimeZone string `json:"timeZone,omitempty"`
                                          
                                          	// ServerResponse contains the HTTP response code and headers from the
                                          	// server.
                                          	googleapi.ServerResponse `json:"-"`
                                          
                                          	// ForceSendFields is a list of field names (e.g. "Name") to
                                          	// unconditionally include in API requests. By default, fields with
                                          	// empty values are omitted from API requests. However, any non-pointer,
                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                          	// server regardless of whether the field is empty or not. This may be
                                          	// used to include empty fields in Patch requests.
                                          	ForceSendFields []string `json:"-"`
                                          
                                          	// NullFields is a list of field names (e.g. "Name") to include in API
                                          	// requests with the JSON null value. By default, fields with empty
                                          	// values are omitted from API requests. However, any field with an
                                          	// empty value appearing in NullFields will be sent to the server as
                                          	// null. It is an error if a field in this list has a non-empty value.
                                          	// This may be used to include null fields in Patch requests.
                                          	NullFields []string `json:"-"`
                                          }

                                            Dataset: A message representing a health dataset. A health dataset represents a collection of healthcare data pertaining to one or more patients. This may include multiple modalities of healthcare data, such as electronic medical records or medical imaging data.

                                            func (*Dataset) MarshalJSON

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

                                            type DateShiftConfig

                                            type DateShiftConfig struct {
                                            	// CryptoKey: An AES 128/192/256 bit key. Causes the shift to be
                                            	// computed based on this key and the patient ID. A default key is
                                            	// generated for each Deidentify operation and is used wherever
                                            	// crypto_key is not specified.
                                            	CryptoKey string `json:"cryptoKey,omitempty"`
                                            
                                            	// ForceSendFields is a list of field names (e.g. "CryptoKey") to
                                            	// unconditionally include in API requests. By default, fields with
                                            	// empty values are omitted from API requests. However, any non-pointer,
                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                            	// server regardless of whether the field is empty or not. This may be
                                            	// used to include empty fields in Patch requests.
                                            	ForceSendFields []string `json:"-"`
                                            
                                            	// NullFields is a list of field names (e.g. "CryptoKey") to include in
                                            	// API requests with the JSON null value. By default, fields with empty
                                            	// values are omitted from API requests. However, any field with an
                                            	// empty value appearing in NullFields will be sent to the server as
                                            	// null. It is an error if a field in this list has a non-empty value.
                                            	// This may be used to include null fields in Patch requests.
                                            	NullFields []string `json:"-"`
                                            }

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

                                              func (*DateShiftConfig) MarshalJSON

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

                                              type DeidentifyConfig

                                              type DeidentifyConfig struct {
                                              	// Dicom: Configures de-id of application/DICOM content.
                                              	Dicom *DicomConfig `json:"dicom,omitempty"`
                                              
                                              	// Fhir: Configures de-id of application/FHIR content.
                                              	Fhir *FhirConfig `json:"fhir,omitempty"`
                                              
                                              	// Image: Configures de-identification of image pixels wherever they are
                                              	// found in the source_dataset.
                                              	Image *ImageConfig `json:"image,omitempty"`
                                              
                                              	// Text: Configures de-identification of text wherever it is found in
                                              	// the source_dataset.
                                              	Text *TextConfig `json:"text,omitempty"`
                                              
                                              	// ForceSendFields is a list of field names (e.g. "Dicom") to
                                              	// unconditionally include in API requests. By default, fields with
                                              	// empty values are omitted from API requests. However, any non-pointer,
                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                              	// server regardless of whether the field is empty or not. This may be
                                              	// used to include empty fields in Patch requests.
                                              	ForceSendFields []string `json:"-"`
                                              
                                              	// NullFields is a list of field names (e.g. "Dicom") to include in API
                                              	// requests with the JSON null value. By default, fields with empty
                                              	// values are omitted from API requests. However, any field with an
                                              	// empty value appearing in NullFields will be sent to the server as
                                              	// null. It is an error if a field in this list has a non-empty value.
                                              	// This may be used to include null fields in Patch requests.
                                              	NullFields []string `json:"-"`
                                              }

                                                DeidentifyConfig: Configures de-id options specific to different types of content. Each submessage customizes the handling of an https://tools.ietf.org/html/rfc6838 media type or subtype. Configs are applied in a nested manner at runtime.

                                                func (*DeidentifyConfig) MarshalJSON

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

                                                type DeidentifyDatasetRequest

                                                type DeidentifyDatasetRequest struct {
                                                	// Config: Deidentify configuration.
                                                	Config *DeidentifyConfig `json:"config,omitempty"`
                                                
                                                	// DestinationDataset: The name of the dataset resource to create and
                                                	// write the redacted data to. * The destination dataset must not exist.
                                                	// * The destination dataset must be in the same project and location as
                                                	// the source dataset. De-identifying data across multiple projects or
                                                	// locations is not supported.
                                                	DestinationDataset string `json:"destinationDataset,omitempty"`
                                                
                                                	// ForceSendFields is a list of field names (e.g. "Config") to
                                                	// unconditionally include in API requests. By default, fields with
                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                	// server regardless of whether the field is empty or not. This may be
                                                	// used to include empty fields in Patch requests.
                                                	ForceSendFields []string `json:"-"`
                                                
                                                	// NullFields is a list of field names (e.g. "Config") to include in API
                                                	// requests with the JSON null value. By default, fields with empty
                                                	// values are omitted from API requests. However, any field with an
                                                	// empty value appearing in NullFields will be sent to the server as
                                                	// null. It is an error if a field in this list has a non-empty value.
                                                	// This may be used to include null fields in Patch requests.
                                                	NullFields []string `json:"-"`
                                                }

                                                  DeidentifyDatasetRequest: Redacts identifying information from the specified dataset.

                                                  func (*DeidentifyDatasetRequest) MarshalJSON

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

                                                  type DeidentifyDicomStoreRequest

                                                  type DeidentifyDicomStoreRequest struct {
                                                  	// Config: De-identify configuration.
                                                  	Config *DeidentifyConfig `json:"config,omitempty"`
                                                  
                                                  	// DestinationStore: The name of the DICOM store to create and write the
                                                  	// redacted data to. For example,
                                                  	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/d
                                                  	// icomStores/{dicom_store_id}`. * The destination dataset must exist. *
                                                  	// The source dataset and destination dataset must both reside in the
                                                  	// same project. De-identifying data across multiple projects is not
                                                  	// supported. * The destination DICOM store must not exist. * The caller
                                                  	// must have the necessary permissions to create the destination DICOM
                                                  	// store.
                                                  	DestinationStore string `json:"destinationStore,omitempty"`
                                                  
                                                  	// FilterConfig: Filter configuration.
                                                  	FilterConfig *DicomFilterConfig `json:"filterConfig,omitempty"`
                                                  
                                                  	// ForceSendFields is a list of field names (e.g. "Config") to
                                                  	// unconditionally include in API requests. By default, fields with
                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                  	// server regardless of whether the field is empty or not. This may be
                                                  	// used to include empty fields in Patch requests.
                                                  	ForceSendFields []string `json:"-"`
                                                  
                                                  	// NullFields is a list of field names (e.g. "Config") to include in API
                                                  	// requests with the JSON null value. By default, fields with empty
                                                  	// values are omitted from API requests. However, any field with an
                                                  	// empty value appearing in NullFields will be sent to the server as
                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                  	// This may be used to include null fields in Patch requests.
                                                  	NullFields []string `json:"-"`
                                                  }

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

                                                    func (*DeidentifyDicomStoreRequest) MarshalJSON

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

                                                    type DeidentifyFhirStoreRequest

                                                    type DeidentifyFhirStoreRequest struct {
                                                    	// Config: Deidentify configuration.
                                                    	Config *DeidentifyConfig `json:"config,omitempty"`
                                                    
                                                    	// DestinationStore: The name of the FHIR store to create and write the
                                                    	// redacted data to. For example,
                                                    	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/f
                                                    	// hirStores/{fhir_store_id}`. * The destination dataset must exist. *
                                                    	// The source dataset and destination dataset must both reside in the
                                                    	// same project. De-identifying data across multiple projects is not
                                                    	// supported. * The destination FHIR store must exist. * The caller must
                                                    	// have the healthcare.fhirResources.update permission to write to the
                                                    	// destination FHIR store.
                                                    	DestinationStore string `json:"destinationStore,omitempty"`
                                                    
                                                    	// ResourceFilter: A filter specifying the resources to include in the
                                                    	// output. If not specified, all resources are included in the output.
                                                    	ResourceFilter *FhirFilter `json:"resourceFilter,omitempty"`
                                                    
                                                    	// ForceSendFields is a list of field names (e.g. "Config") to
                                                    	// unconditionally include in API requests. By default, fields with
                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                    	// server regardless of whether the field is empty or not. This may be
                                                    	// used to include empty fields in Patch requests.
                                                    	ForceSendFields []string `json:"-"`
                                                    
                                                    	// NullFields is a list of field names (e.g. "Config") to include in API
                                                    	// requests with the JSON null value. By default, fields with empty
                                                    	// values are omitted from API requests. However, any field with an
                                                    	// empty value appearing in NullFields will be sent to the server as
                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                    	// This may be used to include null fields in Patch requests.
                                                    	NullFields []string `json:"-"`
                                                    }

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

                                                      func (*DeidentifyFhirStoreRequest) MarshalJSON

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

                                                      type DeidentifySummary

                                                      type DeidentifySummary struct {
                                                      }

                                                        DeidentifySummary: Contains a summary of the Deidentify operation.

                                                        type DicomConfig

                                                        type DicomConfig struct {
                                                        	// FilterProfile: Tag filtering profile that determines which tags to
                                                        	// keep/remove.
                                                        	//
                                                        	// Possible values:
                                                        	//   "TAG_FILTER_PROFILE_UNSPECIFIED" - No tag filtration profile
                                                        	// provided. Same as KEEP_ALL_PROFILE.
                                                        	//   "MINIMAL_KEEP_LIST_PROFILE" - Keep only tags required to produce
                                                        	// valid DICOM.
                                                        	//   "ATTRIBUTE_CONFIDENTIALITY_BASIC_PROFILE" - Remove tags based on
                                                        	// DICOM Standard's Attribute Confidentiality Basic Profile (DICOM
                                                        	// Standard Edition 2018e)
                                                        	// http://dicom.nema.org/medical/dicom/2018e/output/chtml/part15/chapter_E.html.
                                                        	//   "KEEP_ALL_PROFILE" - Keep all tags.
                                                        	//   "DEIDENTIFY_TAG_CONTENTS" - Inspects within tag contents and
                                                        	// replaces sensitive text. The process can be configured using the
                                                        	// TextConfig. Applies to all tags with the following Value
                                                        	// Representation names: AE, LO, LT, PN, SH, ST, UC, UT, DA, DT, AS
                                                        	FilterProfile string `json:"filterProfile,omitempty"`
                                                        
                                                        	// KeepList: List of tags to keep. Remove all other tags.
                                                        	KeepList *TagFilterList `json:"keepList,omitempty"`
                                                        
                                                        	// RemoveList: List of tags to remove. Keep all other tags.
                                                        	RemoveList *TagFilterList `json:"removeList,omitempty"`
                                                        
                                                        	// SkipIdRedaction: If true, skip replacing StudyInstanceUID,
                                                        	// SeriesInstanceUID, SOPInstanceUID, and MediaStorageSOPInstanceUID and
                                                        	// leave them untouched. The Cloud Healthcare API regenerates these UIDs
                                                        	// by default based on the DICOM Standard's reasoning: "Whilst these
                                                        	// UIDs cannot be mapped directly to an individual out of context, given
                                                        	// access to the original images, or to a database of the original
                                                        	// images containing the UIDs, it would be possible to recover the
                                                        	// individual's identity."
                                                        	// http://dicom.nema.org/medical/dicom/current/output/chtml/part15/sect_E.3.9.html
                                                        	SkipIdRedaction bool `json:"skipIdRedaction,omitempty"`
                                                        
                                                        	// ForceSendFields is a list of field names (e.g. "FilterProfile") to
                                                        	// unconditionally include in API requests. By default, fields with
                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                        	// server regardless of whether the field is empty or not. This may be
                                                        	// used to include empty fields in Patch requests.
                                                        	ForceSendFields []string `json:"-"`
                                                        
                                                        	// NullFields is a list of field names (e.g. "FilterProfile") to include
                                                        	// in API requests with the JSON null value. By default, fields with
                                                        	// empty values are omitted from API requests. However, any field with
                                                        	// an empty value appearing in NullFields will be sent to the server as
                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                        	// This may be used to include null fields in Patch requests.
                                                        	NullFields []string `json:"-"`
                                                        }

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

                                                          func (*DicomConfig) MarshalJSON

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

                                                          type DicomFilterConfig

                                                          type DicomFilterConfig struct {
                                                          	// ResourcePathsGcsUri: The Cloud Storage location of the filter
                                                          	// configuration file. The `gcs_uri` must be in the format
                                                          	// `gs://bucket/path/to/object`. The filter configuration file must
                                                          	// contain a list of resource paths separated by newline characters (\n
                                                          	// or \r\n). Each resource path must be in the format
                                                          	// "/studies/{studyUID}[/series/{seriesUID}[/instances/{instanceUID}]]"
                                                          	// The Cloud Healthcare API service account must have the
                                                          	// `roles/storage.objectViewer` Cloud IAM role for this Cloud Storage
                                                          	// location.
                                                          	ResourcePathsGcsUri string `json:"resourcePathsGcsUri,omitempty"`
                                                          
                                                          	// ForceSendFields is a list of field names (e.g. "ResourcePathsGcsUri")
                                                          	// to unconditionally include in API requests. By default, fields with
                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                          	// server regardless of whether the field is empty or not. This may be
                                                          	// used to include empty fields in Patch requests.
                                                          	ForceSendFields []string `json:"-"`
                                                          
                                                          	// NullFields is a list of field names (e.g. "ResourcePathsGcsUri") to
                                                          	// include in API requests with the JSON null value. By default, fields
                                                          	// with empty values are omitted from API requests. However, any field
                                                          	// with an empty value appearing in NullFields will be sent to the
                                                          	// server as null. It is an error if a field in this list has a
                                                          	// non-empty value. This may be used to include null fields in Patch
                                                          	// requests.
                                                          	NullFields []string `json:"-"`
                                                          }

                                                            DicomFilterConfig: Specifies the filter configuration for DICOM resources.

                                                            func (*DicomFilterConfig) MarshalJSON

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

                                                            type DicomStore

                                                            type DicomStore struct {
                                                            	// Labels: User-supplied key-value pairs used to organize DICOM stores.
                                                            	// Label keys must be between 1 and 63 characters long, have a UTF-8
                                                            	// encoding of maximum 128 bytes, and must conform to the following PCRE
                                                            	// regular expression: \p{Ll}\p{Lo}{0,62} Label values are optional,
                                                            	// must be between 1 and 63 characters long, have a UTF-8 encoding of
                                                            	// maximum 128 bytes, and must conform to the following PCRE regular
                                                            	// expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63} No more than 64 labels can be
                                                            	// associated with a given store.
                                                            	Labels map[string]string `json:"labels,omitempty"`
                                                            
                                                            	// Name: Resource name of the DICOM store, of the form
                                                            	// `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/d
                                                            	// icomStores/{dicom_store_id}`.
                                                            	Name string `json:"name,omitempty"`
                                                            
                                                            	// NotificationConfig: Notification destination for new DICOM instances.
                                                            	// Supplied by the client.
                                                            	NotificationConfig *NotificationConfig `json:"notificationConfig,omitempty"`
                                                            
                                                            	// ServerResponse contains the HTTP response code and headers from the
                                                            	// server.
                                                            	googleapi.ServerResponse `json:"-"`
                                                            
                                                            	// ForceSendFields is a list of field names (e.g. "Labels") to
                                                            	// unconditionally include in API requests. By default, fields with
                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                            	// server regardless of whether the field is empty or not. This may be
                                                            	// used to include empty fields in Patch requests.
                                                            	ForceSendFields []string `json:"-"`
                                                            
                                                            	// NullFields is a list of field names (e.g. "Labels") to include in API
                                                            	// requests with the JSON null value. By default, fields with empty
                                                            	// values are omitted from API requests. However, any field with an
                                                            	// empty value appearing in NullFields will be sent to the server as
                                                            	// null. It is an error if a field in this list has a non-empty value.
                                                            	// This may be used to include null fields in Patch requests.
                                                            	NullFields []string `json:"-"`
                                                            }

                                                              DicomStore: Represents a DICOM store.

                                                              func (*DicomStore) MarshalJSON

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

                                                              type Empty

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

                                                                Empty: A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for `Empty` is empty JSON object `{}`.

                                                                type EvaluateUserConsentsRequest

                                                                type EvaluateUserConsentsRequest struct {
                                                                	// ConsentList: Optional. Specific Consents to evaluate the access
                                                                	// request against. These Consents must have the same `user_id` as the
                                                                	// User data mappings being evalauted, must exist in the current
                                                                	// `consent_store`, and must have a `state` of either `ACTIVE` or
                                                                	// `DRAFT`. A maximum of 100 Consents can be provided here. If
                                                                	// unspecified, all `ACTIVE` unexpired Consents in the current
                                                                	// `consent_store` will be evaluated.
                                                                	ConsentList *ConsentList `json:"consentList,omitempty"`
                                                                
                                                                	// PageSize: Optional. Limit on the number of User data mappings to
                                                                	// return in a single response. If not specified, 100 is used. May not
                                                                	// be larger than 1000.
                                                                	PageSize int64 `json:"pageSize,omitempty"`
                                                                
                                                                	// PageToken: Optional. Token to retrieve the next page of results, or
                                                                	// empty to get the first page.
                                                                	PageToken string `json:"pageToken,omitempty"`
                                                                
                                                                	// RequestAttributes: Required. The values of request attributes
                                                                	// associated with this access request.
                                                                	RequestAttributes map[string]string `json:"requestAttributes,omitempty"`
                                                                
                                                                	// ResourceAttributes: Optional. The values of resource attributes
                                                                	// associated with the resources being requested. If no values are
                                                                	// specified, then all resources are queried.
                                                                	ResourceAttributes map[string]string `json:"resourceAttributes,omitempty"`
                                                                
                                                                	// ResponseView: Optional. The view for EvaluateUserConsentsResponse. If
                                                                	// unspecified, defaults to `BASIC` and returns `consented` as `TRUE` or
                                                                	// `FALSE`.
                                                                	//
                                                                	// Possible values:
                                                                	//   "RESPONSE_VIEW_UNSPECIFIED" - No response view specified. The API
                                                                	// will default to the BASIC view.
                                                                	//   "BASIC" - Only the `data_id` and `consented` fields are populated
                                                                	// in the response.
                                                                	//   "FULL" - All fields within the response are populated. When set to
                                                                	// `FULL`, all `ACTIVE` Consents are evaluated even if a matching policy
                                                                	// is found during evaluation.
                                                                	ResponseView string `json:"responseView,omitempty"`
                                                                
                                                                	// UserId: Required. User ID to evaluate consents for.
                                                                	UserId string `json:"userId,omitempty"`
                                                                
                                                                	// ForceSendFields is a list of field names (e.g. "ConsentList") 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. "ConsentList") 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:"-"`
                                                                }

                                                                  EvaluateUserConsentsRequest: Evaluate a user's Consents for all matching User data mappings. Note: User data mappings are indexed asynchronously, causing slight delays between the time mappings are created or updated and when they are included in EvaluateUserConsents results.

                                                                  func (*EvaluateUserConsentsRequest) MarshalJSON

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

                                                                  type EvaluateUserConsentsResponse

                                                                  type EvaluateUserConsentsResponse struct {
                                                                  	// NextPageToken: Token to retrieve the next page of results, or empty
                                                                  	// if there are no more results in the list. This token is valid for 72
                                                                  	// hours after it is created.
                                                                  	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                  
                                                                  	// Results: The consent evaluation result for each `data_id`.
                                                                  	Results []*Result `json:"results,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:"-"`
                                                                  }

                                                                  func (*EvaluateUserConsentsResponse) MarshalJSON

                                                                  func (s *EvaluateUserConsentsResponse) 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 Cloud Healthcare Service Agent
                                                                  	// requires two IAM roles on the BigQuery location:
                                                                  	// `roles/bigquery.dataEditor` and `roles/bigquery.jobUser`.
                                                                  	BigqueryDestination *GoogleCloudHealthcareV1DicomBigQueryDestination `json:"bigqueryDestination,omitempty"`
                                                                  
                                                                  	// GcsDestination: The Cloud Storage output destination. The Cloud
                                                                  	// Healthcare Service Agent requires the `roles/storage.objectAdmin`
                                                                  	// Cloud IAM roles on the Cloud Storage location.
                                                                  	GcsDestination *GoogleCloudHealthcareV1DicomGcsDestination `json:"gcsDestination,omitempty"`
                                                                  
                                                                  	// ForceSendFields is a list of field names (e.g. "BigqueryDestination")
                                                                  	// to unconditionally include in API requests. By default, fields with
                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                  	// used to include empty fields in Patch requests.
                                                                  	ForceSendFields []string `json:"-"`
                                                                  
                                                                  	// NullFields is a list of field names (e.g. "BigqueryDestination") to
                                                                  	// include in API requests with the JSON null value. By default, fields
                                                                  	// with empty values are omitted from API requests. However, any field
                                                                  	// with an empty value appearing in NullFields will be sent to the
                                                                  	// server as null. It is an error if a field in this list has a
                                                                  	// non-empty value. This may be used to include null fields in Patch
                                                                  	// requests.
                                                                  	NullFields []string `json:"-"`
                                                                  }

                                                                    ExportDicomDataRequest: Exports data from the specified DICOM store. If a given resource, such as a DICOM object with the same SOPInstance UID, already exists in the output, it is overwritten with the version in the source dataset. Exported DICOM data persists when the DICOM store from which it was exported is deleted.

                                                                    func (*ExportDicomDataRequest) MarshalJSON

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

                                                                    type ExportDicomDataResponse

                                                                    type ExportDicomDataResponse struct {
                                                                    }

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

                                                                      type ExportResourcesRequest

                                                                      type ExportResourcesRequest struct {
                                                                      	// BigqueryDestination: The BigQuery output destination. The Cloud
                                                                      	// Healthcare Service Agent requires two IAM roles on the BigQuery
                                                                      	// location: `roles/bigquery.dataEditor` and `roles/bigquery.jobUser`.
                                                                      	// The output is one BigQuery table per resource type.
                                                                      	BigqueryDestination *GoogleCloudHealthcareV1FhirBigQueryDestination `json:"bigqueryDestination,omitempty"`
                                                                      
                                                                      	// GcsDestination: The Cloud Storage output destination. The Healthcare
                                                                      	// Service Agent account requires the `roles/storage.objectAdmin` role
                                                                      	// on the Cloud Storage location. The exported outputs are organized by
                                                                      	// FHIR resource types. The server creates one object per resource type.
                                                                      	// Each object contains newline delimited JSON, and each line is a FHIR
                                                                      	// resource.
                                                                      	GcsDestination *GoogleCloudHealthcareV1FhirGcsDestination `json:"gcsDestination,omitempty"`
                                                                      
                                                                      	// ForceSendFields is a list of field names (e.g. "BigqueryDestination")
                                                                      	// to unconditionally include in API requests. By default, fields with
                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                      	// used to include empty fields in Patch requests.
                                                                      	ForceSendFields []string `json:"-"`
                                                                      
                                                                      	// NullFields is a list of field names (e.g. "BigqueryDestination") to
                                                                      	// include in API requests with the JSON null value. By default, fields
                                                                      	// with empty values are omitted from API requests. However, any field
                                                                      	// with an empty value appearing in NullFields will be sent to the
                                                                      	// server as null. It is an error if a field in this list has a
                                                                      	// non-empty value. This may be used to include null fields in Patch
                                                                      	// requests.
                                                                      	NullFields []string `json:"-"`
                                                                      }

                                                                        ExportResourcesRequest: Request to export resources.

                                                                        func (*ExportResourcesRequest) MarshalJSON

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

                                                                        type ExportResourcesResponse

                                                                        type ExportResourcesResponse struct {
                                                                        }

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

                                                                          type Expr

                                                                          type Expr struct {
                                                                          	// Description: Optional. Description of the expression. This is a
                                                                          	// longer text which describes the expression, e.g. when hovered over it
                                                                          	// in a UI.
                                                                          	Description string `json:"description,omitempty"`
                                                                          
                                                                          	// Expression: Textual representation of an expression in Common
                                                                          	// Expression Language syntax.
                                                                          	Expression string `json:"expression,omitempty"`
                                                                          
                                                                          	// Location: Optional. String indicating the location of the expression
                                                                          	// for error reporting, e.g. a file name and a position in the file.
                                                                          	Location string `json:"location,omitempty"`
                                                                          
                                                                          	// Title: Optional. Title for the expression, i.e. a short string
                                                                          	// describing its purpose. This can be used e.g. in UIs which allow to
                                                                          	// enter the expression.
                                                                          	Title string `json:"title,omitempty"`
                                                                          
                                                                          	// ForceSendFields is a list of field names (e.g. "Description") to
                                                                          	// unconditionally include in API requests. By default, fields with
                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                          	// used to include empty fields in Patch requests.
                                                                          	ForceSendFields []string `json:"-"`
                                                                          
                                                                          	// NullFields is a list of field names (e.g. "Description") to include
                                                                          	// in API requests with the JSON null value. By default, fields with
                                                                          	// empty values are omitted from API requests. However, any field with
                                                                          	// an empty value appearing in NullFields will be sent to the server as
                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                          	// This may be used to include null fields in Patch requests.
                                                                          	NullFields []string `json:"-"`
                                                                          }

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

                                                                            func (*Expr) MarshalJSON

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

                                                                            type FhirConfig

                                                                            type FhirConfig struct {
                                                                            	// FieldMetadataList: Specifies FHIR paths to match and how to transform
                                                                            	// them. Any field that is not matched by a FieldMetadata is passed
                                                                            	// through to the output dataset unmodified. All extensions are removed
                                                                            	// in the output.
                                                                            	FieldMetadataList []*FieldMetadata `json:"fieldMetadataList,omitempty"`
                                                                            
                                                                            	// ForceSendFields is a list of field names (e.g. "FieldMetadataList")
                                                                            	// to unconditionally include in API requests. By default, fields with
                                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                                            	// server regardless of whether the field is empty or not. This may be
                                                                            	// used to include empty fields in Patch requests.
                                                                            	ForceSendFields []string `json:"-"`
                                                                            
                                                                            	// NullFields is a list of field names (e.g. "FieldMetadataList") to
                                                                            	// include in API requests with the JSON null value. By default, fields
                                                                            	// with empty values are omitted from API requests. However, any field
                                                                            	// with an empty value appearing in NullFields will be sent to the
                                                                            	// server as null. It is an error if a field in this list has a
                                                                            	// non-empty value. This may be used to include null fields in Patch
                                                                            	// requests.
                                                                            	NullFields []string `json:"-"`
                                                                            }

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

                                                                              func (*FhirConfig) MarshalJSON

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

                                                                              type FhirFilter

                                                                              type FhirFilter struct {
                                                                              	// Resources: List of resources to include in the output. If this list
                                                                              	// is empty or not specified, all resources are included in the output.
                                                                              	Resources *Resources `json:"resources,omitempty"`
                                                                              
                                                                              	// ForceSendFields is a list of field names (e.g. "Resources") to
                                                                              	// unconditionally include in API requests. By default, fields with
                                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                                              	// server regardless of whether the field is empty or not. This may be
                                                                              	// used to include empty fields in Patch requests.
                                                                              	ForceSendFields []string `json:"-"`
                                                                              
                                                                              	// NullFields is a list of field names (e.g. "Resources") to include in
                                                                              	// API requests with the JSON null value. By default, fields with empty
                                                                              	// values are omitted from API requests. However, any field with an
                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                              	// This may be used to include null fields in Patch requests.
                                                                              	NullFields []string `json:"-"`
                                                                              }

                                                                                FhirFilter: Filter configuration.

                                                                                func (*FhirFilter) MarshalJSON

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

                                                                                type FhirStore

                                                                                type FhirStore struct {
                                                                                	// DisableReferentialIntegrity: Immutable. Whether to disable
                                                                                	// referential integrity in this FHIR store. This field is immutable
                                                                                	// after FHIR store creation. The default value is false, meaning that
                                                                                	// the API enforces referential integrity and fails the requests that
                                                                                	// result in inconsistent state in the FHIR store. When this field is
                                                                                	// set to true, the API skips referential integrity checks.
                                                                                	// Consequently, operations that rely on references, such as
                                                                                	// GetPatientEverything, do not return all the results if broken
                                                                                	// references exist.
                                                                                	DisableReferentialIntegrity bool `json:"disableReferentialIntegrity,omitempty"`
                                                                                
                                                                                	// DisableResourceVersioning: Immutable. Whether to disable resource
                                                                                	// versioning for this FHIR store. This field can not be changed after
                                                                                	// the creation of FHIR store. If set to false, which is the default
                                                                                	// behavior, all write operations cause historical versions to be
                                                                                	// recorded automatically. The historical versions can be fetched
                                                                                	// through the history APIs, but cannot be updated. If set to true, no
                                                                                	// historical versions are kept. The server sends errors for attempts to
                                                                                	// read the historical versions.
                                                                                	DisableResourceVersioning bool `json:"disableResourceVersioning,omitempty"`
                                                                                
                                                                                	// EnableUpdateCreate: Whether this FHIR store has the updateCreate
                                                                                	// capability
                                                                                	// (https://www.hl7.org/fhir/capabilitystatement-definitions.html#CapabilityStatement.rest.resource.updateCreate).
                                                                                	// This determines if the client can use an Update operation to create a
                                                                                	// new resource with a client-specified ID. If false, all IDs are
                                                                                	// server-assigned through the Create operation and attempts to update a
                                                                                	// non-existent resource return errors. It is strongly advised not to
                                                                                	// include or encode any sensitive data such as patient identifiers in
                                                                                	// client-specified resource IDs. Those IDs are part of the FHIR
                                                                                	// resource path recorded in Cloud audit logs and Pub/Sub notifications.
                                                                                	// Those IDs can also be contained in reference fields within other
                                                                                	// resources.
                                                                                	EnableUpdateCreate bool `json:"enableUpdateCreate,omitempty"`
                                                                                
                                                                                	// Labels: User-supplied key-value pairs used to organize FHIR stores.
                                                                                	// Label keys must be between 1 and 63 characters long, have a UTF-8
                                                                                	// encoding of maximum 128 bytes, and must conform to the following PCRE
                                                                                	// regular expression: \p{Ll}\p{Lo}{0,62} Label values are optional,
                                                                                	// must be between 1 and 63 characters long, have a UTF-8 encoding of
                                                                                	// maximum 128 bytes, and must conform to the following PCRE regular
                                                                                	// expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63} No more than 64 labels can be
                                                                                	// associated with a given store.
                                                                                	Labels map[string]string `json:"labels,omitempty"`
                                                                                
                                                                                	// Name: Output only. Resource name of the FHIR store, of the form
                                                                                	// `projects/{project_id}/datasets/{dataset_id}/fhirStores/{fhir_store_id
                                                                                	// }`.
                                                                                	Name string `json:"name,omitempty"`
                                                                                
                                                                                	// NotificationConfig: If non-empty, publish all resource modifications
                                                                                	// of this FHIR store to this destination. The Pub/Sub message
                                                                                	// attributes contain a map with a string describing the action that has
                                                                                	// triggered the notification. For example, "action":"CreateResource".
                                                                                	NotificationConfig *NotificationConfig `json:"notificationConfig,omitempty"`
                                                                                
                                                                                	// StreamConfigs: A list of streaming configs that configure the
                                                                                	// destinations of streaming export for every resource mutation in this
                                                                                	// FHIR store. Each store is allowed to have up to 10 streaming configs.
                                                                                	// After a new config is added, the next resource mutation is streamed
                                                                                	// to the new location in addition to the existing ones. When a location
                                                                                	// is removed from the list, the server stops streaming to that
                                                                                	// location. Before adding a new config, you must add the required
                                                                                	// `bigquery.dataEditor`
                                                                                	// (https://cloud.google.com/bigquery/docs/access-control#bigquery.dataEditor)
                                                                                	// role to your project's **Cloud Healthcare Service Agent** service
                                                                                	// account (https://cloud.google.com/iam/docs/service-accounts). Some
                                                                                	// lag (typically on the order of dozens of seconds) is expected before
                                                                                	// the results show up in the streaming destination.
                                                                                	StreamConfigs []*StreamConfig `json:"streamConfigs,omitempty"`
                                                                                
                                                                                	// Version: Immutable. The FHIR specification version that this FHIR
                                                                                	// store supports natively. This field is immutable after store
                                                                                	// creation. Requests are rejected if they contain FHIR resources of a
                                                                                	// different version. Version is required for every FHIR store.
                                                                                	//
                                                                                	// Possible values:
                                                                                	//   "VERSION_UNSPECIFIED" - Users must specify a version on store
                                                                                	// creation or an error is returned.
                                                                                	//   "DSTU2" - Draft Standard for Trial Use, [Release
                                                                                	// 2](https://www.hl7.org/fhir/DSTU2)
                                                                                	//   "STU3" - Standard for Trial Use, [Release
                                                                                	// 3](https://www.hl7.org/fhir/STU3)
                                                                                	//   "R4" - [Release 4](https://www.hl7.org/fhir/R4)
                                                                                	Version string `json:"version,omitempty"`
                                                                                
                                                                                	// ServerResponse contains the HTTP response code and headers from the
                                                                                	// server.
                                                                                	googleapi.ServerResponse `json:"-"`
                                                                                
                                                                                	// ForceSendFields is a list of field names (e.g.
                                                                                	// "DisableReferentialIntegrity") to unconditionally include in API
                                                                                	// requests. By default, fields with empty values are omitted from API
                                                                                	// requests. However, any non-pointer, non-interface field appearing in
                                                                                	// ForceSendFields will be sent to the server regardless of whether the
                                                                                	// field is empty or not. This may be used to include empty fields in
                                                                                	// Patch requests.
                                                                                	ForceSendFields []string `json:"-"`
                                                                                
                                                                                	// NullFields is a list of field names (e.g.
                                                                                	// "DisableReferentialIntegrity") to include in API requests with the
                                                                                	// JSON null value. By default, fields with empty values are omitted
                                                                                	// from API requests. However, any field with an empty value appearing
                                                                                	// in NullFields will be sent to the server as null. It is an error if a
                                                                                	// field in this list has a non-empty value. This may be used to include
                                                                                	// null fields in Patch requests.
                                                                                	NullFields []string `json:"-"`
                                                                                }

                                                                                  FhirStore: Represents a FHIR store.

                                                                                  func (*FhirStore) MarshalJSON

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

                                                                                  type Field

                                                                                  type Field struct {
                                                                                  	// MaxOccurs: The maximum number of times this field can be repeated. 0
                                                                                  	// or -1 means unbounded.
                                                                                  	MaxOccurs int64 `json:"maxOccurs,omitempty"`
                                                                                  
                                                                                  	// MinOccurs: The minimum number of times this field must be
                                                                                  	// present/repeated.
                                                                                  	MinOccurs int64 `json:"minOccurs,omitempty"`
                                                                                  
                                                                                  	// Name: The name of the field. For example, "PID-1" or just "1".
                                                                                  	Name string `json:"name,omitempty"`
                                                                                  
                                                                                  	// Table: The HL7v2 table this field refers to. For example, PID-15
                                                                                  	// (Patient's Primary Language) usually refers to table "0296".
                                                                                  	Table string `json:"table,omitempty"`
                                                                                  
                                                                                  	// Type: The type of this field. A Type with this name must be defined
                                                                                  	// in an Hl7TypesConfig.
                                                                                  	Type string `json:"type,omitempty"`
                                                                                  
                                                                                  	// ForceSendFields is a list of field names (e.g. "MaxOccurs") 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. "MaxOccurs") 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:"-"`
                                                                                  }

                                                                                    Field: A (sub) field of a type.

                                                                                    func (*Field) MarshalJSON

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

                                                                                    type FieldMetadata

                                                                                    type FieldMetadata struct {
                                                                                    	// Action: Deidentify action for one field.
                                                                                    	//
                                                                                    	// Possible values:
                                                                                    	//   "ACTION_UNSPECIFIED" - No action specified.
                                                                                    	//   "TRANSFORM" - Transform the entire field.
                                                                                    	//   "INSPECT_AND_TRANSFORM" - Inspect and transform any found PHI.
                                                                                    	//   "DO_NOT_TRANSFORM" - Do not transform.
                                                                                    	Action string `json:"action,omitempty"`
                                                                                    
                                                                                    	// Paths: List of paths to FHIR fields to be redacted. Each path is a
                                                                                    	// period-separated list where each component is either a field name or
                                                                                    	// FHIR type name, for example: Patient, HumanName. For "choice" types
                                                                                    	// (those defined in the FHIR spec with the form: field[x]) we use two
                                                                                    	// separate components. For example, "deceasedAge.unit" is matched by
                                                                                    	// "Deceased.Age.unit". Supported types are: AdministrativeGenderCode,
                                                                                    	// Code, Date, DateTime, Decimal, HumanName, Id, LanguageCode, Markdown,
                                                                                    	// Oid, String, Uri, Uuid, Xhtml. Base64Binary is also supported, but
                                                                                    	// may only be kept as-is or have all the content removed.
                                                                                    	Paths []string `json:"paths,omitempty"`
                                                                                    
                                                                                    	// ForceSendFields is a list of field names (e.g. "Action") to
                                                                                    	// unconditionally include in API requests. By default, fields with
                                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                                    	// used to include empty fields in Patch requests.
                                                                                    	ForceSendFields []string `json:"-"`
                                                                                    
                                                                                    	// NullFields is a list of field names (e.g. "Action") to include in API
                                                                                    	// requests with the JSON null value. By default, fields with empty
                                                                                    	// values are omitted from API requests. However, any field with an
                                                                                    	// empty value appearing in NullFields will be sent to the server as
                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                    	NullFields []string `json:"-"`
                                                                                    }

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

                                                                                      func (*FieldMetadata) MarshalJSON

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

                                                                                      type GoogleCloudHealthcareV1ConsentGcsDestination

                                                                                      type GoogleCloudHealthcareV1ConsentGcsDestination struct {
                                                                                      	// UriPrefix: URI for a Cloud Storage directory where the server writes
                                                                                      	// result files, in the format
                                                                                      	// `gs://{bucket-id}/{path/to/destination/dir}`. If there is no trailing
                                                                                      	// slash, the service appends one when composing the object path. The
                                                                                      	// user is responsible for creating the Cloud Storage bucket and
                                                                                      	// directory 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:"-"`
                                                                                      }

                                                                                        GoogleCloudHealthcareV1ConsentGcsDestination: The Cloud Storage location for export.

                                                                                        func (*GoogleCloudHealthcareV1ConsentGcsDestination) MarshalJSON

                                                                                        type GoogleCloudHealthcareV1ConsentPolicy

                                                                                        type GoogleCloudHealthcareV1ConsentPolicy struct {
                                                                                        	// AuthorizationRule: Required. The request conditions to meet to grant
                                                                                        	// access. In addition to any supported comparison operators,
                                                                                        	// authorization rules may have `IN` operator as well as at most 10
                                                                                        	// logical operators that are limited to `AND` (`&&`), `OR` (`||`).
                                                                                        	AuthorizationRule *Expr `json:"authorizationRule,omitempty"`
                                                                                        
                                                                                        	// ResourceAttributes: The resources that this policy applies to. A
                                                                                        	// resource is a match if it matches all the attributes listed here. If
                                                                                        	// empty, this policy applies to all User data mappings for the given
                                                                                        	// user.
                                                                                        	ResourceAttributes []*Attribute `json:"resourceAttributes,omitempty"`
                                                                                        
                                                                                        	// ForceSendFields is a list of field names (e.g. "AuthorizationRule")
                                                                                        	// 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. "AuthorizationRule") 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:"-"`
                                                                                        }

                                                                                          GoogleCloudHealthcareV1ConsentPolicy: Represents a user's consent in terms of the resources that can be accessed and under what conditions.

                                                                                          func (*GoogleCloudHealthcareV1ConsentPolicy) MarshalJSON

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

                                                                                          type GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary

                                                                                          type GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary struct {
                                                                                          }

                                                                                            GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary: Contains a summary of the DeidentifyDicomStore operation.

                                                                                            type GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary

                                                                                            type GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary struct {
                                                                                            }

                                                                                              GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary: Contains a summary of the DeidentifyFhirStore operation.

                                                                                              type GoogleCloudHealthcareV1DicomBigQueryDestination

                                                                                              type GoogleCloudHealthcareV1DicomBigQueryDestination struct {
                                                                                              	// Force: If the destination table already exists and this flag is
                                                                                              	// `TRUE`, the table is overwritten by the contents of the DICOM store.
                                                                                              	// If the flag is not set and the destination table already exists, the
                                                                                              	// export call returns an error.
                                                                                              	Force bool `json:"force,omitempty"`
                                                                                              
                                                                                              	// TableUri: BigQuery URI to a table, up to 2000 characters long, in the
                                                                                              	// format `bq://projectId.bqDatasetId.tableId`
                                                                                              	TableUri string `json:"tableUri,omitempty"`
                                                                                              
                                                                                              	// ForceSendFields is a list of field names (e.g. "Force") to
                                                                                              	// unconditionally include in API requests. By default, fields with
                                                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                              	// server regardless of whether the field is empty or not. This may be
                                                                                              	// used to include empty fields in Patch requests.
                                                                                              	ForceSendFields []string `json:"-"`
                                                                                              
                                                                                              	// NullFields is a list of field names (e.g. "Force") to include in API
                                                                                              	// requests with the JSON null value. By default, fields with empty
                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                              	NullFields []string `json:"-"`
                                                                                              }

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

                                                                                                func (*GoogleCloudHealthcareV1DicomBigQueryDestination) MarshalJSON

                                                                                                type GoogleCloudHealthcareV1DicomGcsDestination

                                                                                                type GoogleCloudHealthcareV1DicomGcsDestination struct {
                                                                                                	// MimeType: MIME types supported by DICOM spec. Each file is written in
                                                                                                	// the following format:
                                                                                                	// `.../{study_id}/{series_id}/{instance_id}[/{frame_number}].{extension}
                                                                                                	// ` The frame_number component exists only for multi-frame instances.
                                                                                                	// Supported MIME types are consistent with supported formats in
                                                                                                	// DICOMweb:
                                                                                                	// https://cloud.google.com/healthcare/docs/dicom#retrieve_transaction.
                                                                                                	// Specifically, the following are supported: - application/dicom;
                                                                                                	// transfer-syntax=1.2.840.10008.1.2.1 (uncompressed DICOM) -
                                                                                                	// application/dicom; transfer-syntax=1.2.840.10008.1.2.4.50 (DICOM with
                                                                                                	// embedded JPEG Baseline) - application/dicom;
                                                                                                	// transfer-syntax=1.2.840.10008.1.2.4.90 (DICOM with embedded JPEG 2000
                                                                                                	// Lossless Only) - application/dicom;
                                                                                                	// transfer-syntax=1.2.840.10008.1.2.4.91 (DICOM with embedded JPEG
                                                                                                	// 2000) - application/dicom; transfer-syntax=* (DICOM with no
                                                                                                	// transcoding) - application/octet-stream;
                                                                                                	// transfer-syntax=1.2.840.10008.1.2.1 (raw uncompressed PixelData) -
                                                                                                	// application/octet-stream; transfer-syntax=* (raw PixelData in
                                                                                                	// whatever format it was uploaded in) - image/jpeg;
                                                                                                	// transfer-syntax=1.2.840.10008.1.2.4.50 (Consumer JPEG) - image/png
                                                                                                	// The following extensions are used for output files: -
                                                                                                	// application/dicom -> .dcm - image/jpeg -> .jpg - image/png -> .png -
                                                                                                	// application/octet-stream -> no extension If unspecified, the
                                                                                                	// instances are exported in the original DICOM format they were
                                                                                                	// uploaded in.
                                                                                                	MimeType string `json:"mimeType,omitempty"`
                                                                                                
                                                                                                	// UriPrefix: The Cloud Storage destination to export to. URI for a
                                                                                                	// Cloud Storage directory where the server writes the result files, in
                                                                                                	// the format `gs://{bucket-id}/{path/to/destination/dir}`). If there is
                                                                                                	// no trailing slash, the service appends one when composing the object
                                                                                                	// path. The user is responsible for creating the Cloud Storage bucket
                                                                                                	// referenced in `uri_prefix`.
                                                                                                	UriPrefix string `json:"uriPrefix,omitempty"`
                                                                                                
                                                                                                	// ForceSendFields is a list of field names (e.g. "MimeType") to
                                                                                                	// unconditionally include in API requests. By default, fields with
                                                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                	// server regardless of whether the field is empty or not. This may be
                                                                                                	// used to include empty fields in Patch requests.
                                                                                                	ForceSendFields []string `json:"-"`
                                                                                                
                                                                                                	// NullFields is a list of field names (e.g. "MimeType") to include in
                                                                                                	// API requests with the JSON null value. By default, fields with empty
                                                                                                	// values are omitted from API requests. However, any field with an
                                                                                                	// empty value appearing in NullFields will be sent to the server as
                                                                                                	// null. It is an error if a field in this list has a non-empty value.
                                                                                                	// This may be used to include null fields in Patch requests.
                                                                                                	NullFields []string `json:"-"`
                                                                                                }

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

                                                                                                  func (*GoogleCloudHealthcareV1DicomGcsDestination) MarshalJSON

                                                                                                  type GoogleCloudHealthcareV1DicomGcsSource

                                                                                                  type GoogleCloudHealthcareV1DicomGcsSource struct {
                                                                                                  	// Uri: Points to a Cloud Storage URI containing file(s) with content
                                                                                                  	// only. The URI must be in the following format:
                                                                                                  	// `gs://{bucket_id}/{object_id}`. The URI can include wildcards in
                                                                                                  	// `object_id` and thus identify multiple files. Supported wildcards: *
                                                                                                  	// '*' to match 0 or more non-separator characters * '**' to match 0 or
                                                                                                  	// more characters (including separators). Must be used at the end of a
                                                                                                  	// path and with no other wildcards in the path. Can also be used with a
                                                                                                  	// file extension (such as .dcm), which imports all files with the
                                                                                                  	// extension in the specified directory and its sub-directories. For
                                                                                                  	// example, `gs://my-bucket/my-directory/**.dcm` imports all files with
                                                                                                  	// .dcm extensions in `my-directory/` and its sub-directories. * '?' to
                                                                                                  	// match 1 character. All other URI formats are invalid. Files matching
                                                                                                  	// the wildcard are expected to contain content only, no metadata.
                                                                                                  	Uri string `json:"uri,omitempty"`
                                                                                                  
                                                                                                  	// ForceSendFields is a list of field names (e.g. "Uri") to
                                                                                                  	// unconditionally include in API requests. By default, fields with
                                                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                                  	// used to include empty fields in Patch requests.
                                                                                                  	ForceSendFields []string `json:"-"`
                                                                                                  
                                                                                                  	// NullFields is a list of field names (e.g. "Uri") to include in API
                                                                                                  	// requests with the JSON null value. By default, fields with empty
                                                                                                  	// values are omitted from API requests. However, any field with an
                                                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                  	NullFields []string `json:"-"`
                                                                                                  }

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

                                                                                                    func (*GoogleCloudHealthcareV1DicomGcsSource) MarshalJSON

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

                                                                                                    type GoogleCloudHealthcareV1FhirBigQueryDestination

                                                                                                    type GoogleCloudHealthcareV1FhirBigQueryDestination struct {
                                                                                                    	// DatasetUri: BigQuery URI to an existing dataset, up to 2000
                                                                                                    	// characters long, in the format `bq://projectId.bqDatasetId`.
                                                                                                    	DatasetUri string `json:"datasetUri,omitempty"`
                                                                                                    
                                                                                                    	// Force: If this flag is `TRUE`, all tables are deleted from the
                                                                                                    	// dataset before the new exported tables are written. If the flag is
                                                                                                    	// not set and the destination dataset contains tables, the export call
                                                                                                    	// returns an error. If `write_disposition` is specified, this parameter
                                                                                                    	// is ignored. force=false is equivalent to
                                                                                                    	// write_disposition=WRITE_EMPTY and force=true is equivalent to
                                                                                                    	// write_disposition=WRITE_TRUNCATE.
                                                                                                    	Force bool `json:"force,omitempty"`
                                                                                                    
                                                                                                    	// SchemaConfig: The configuration for the exported BigQuery schema.
                                                                                                    	SchemaConfig *SchemaConfig `json:"schemaConfig,omitempty"`
                                                                                                    
                                                                                                    	// WriteDisposition: Determines whether existing tables in the
                                                                                                    	// destination dataset are overwritten or appended to. If a
                                                                                                    	// write_disposition is specified, the `force` parameter is ignored.
                                                                                                    	//
                                                                                                    	// Possible values:
                                                                                                    	//   "WRITE_DISPOSITION_UNSPECIFIED" - Default behavior is the same as
                                                                                                    	// WRITE_EMPTY.
                                                                                                    	//   "WRITE_EMPTY" - Only export data if the destination tables are
                                                                                                    	// empty.
                                                                                                    	//   "WRITE_TRUNCATE" - Erase all existing data in the tables before
                                                                                                    	// writing the instances.
                                                                                                    	//   "WRITE_APPEND" - Append data to the existing tables.
                                                                                                    	WriteDisposition string `json:"writeDisposition,omitempty"`
                                                                                                    
                                                                                                    	// ForceSendFields is a list of field names (e.g. "DatasetUri") to
                                                                                                    	// unconditionally include in API requests. By default, fields with
                                                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                                                    	// used to include empty fields in Patch requests.
                                                                                                    	ForceSendFields []string `json:"-"`
                                                                                                    
                                                                                                    	// NullFields is a list of field names (e.g. "DatasetUri") to include in
                                                                                                    	// API requests with the JSON null value. By default, fields with empty
                                                                                                    	// values are omitted from API requests. However, any field with an
                                                                                                    	// empty value appearing in NullFields will be sent to the server as
                                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                                    	NullFields []string `json:"-"`
                                                                                                    }

                                                                                                      GoogleCloudHealthcareV1FhirBigQueryDestination: The configuration for exporting to BigQuery.

                                                                                                      func (*GoogleCloudHealthcareV1FhirBigQueryDestination) MarshalJSON

                                                                                                      type GoogleCloudHealthcareV1FhirGcsDestination

                                                                                                      type GoogleCloudHealthcareV1FhirGcsDestination struct {
                                                                                                      	// UriPrefix: URI for a Cloud Storage directory where result files
                                                                                                      	// should be written, in the format of
                                                                                                      	// `gs://{bucket-id}/{path/to/destination/dir}`. If there is no trailing
                                                                                                      	// slash, the service appends one when composing the object path. The
                                                                                                      	// user is responsible for creating the Cloud Storage bucket referenced
                                                                                                      	// in `uri_prefix`.
                                                                                                      	UriPrefix string `json:"uriPrefix,omitempty"`
                                                                                                      
                                                                                                      	// ForceSendFields is a list of field names (e.g. "UriPrefix") to
                                                                                                      	// unconditionally include in API requests. By default, fields with
                                                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                                                      	// used to include empty fields in Patch requests.
                                                                                                      	ForceSendFields []string `json:"-"`
                                                                                                      
                                                                                                      	// NullFields is a list of field names (e.g. "UriPrefix") to include in
                                                                                                      	// API requests with the JSON null value. By default, fields with empty
                                                                                                      	// values are omitted from API requests. However, any field with an
                                                                                                      	// empty value appearing in NullFields will be sent to the server as
                                                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                                                      	// This may be used to include null fields in Patch requests.
                                                                                                      	NullFields []string `json:"-"`
                                                                                                      }

                                                                                                        GoogleCloudHealthcareV1FhirGcsDestination: The configuration for exporting to Cloud Storage.

                                                                                                        func (*GoogleCloudHealthcareV1FhirGcsDestination) MarshalJSON

                                                                                                        type GoogleCloudHealthcareV1FhirGcsSource

                                                                                                        type GoogleCloudHealthcareV1FhirGcsSource struct {
                                                                                                        	// Uri: Points to a Cloud Storage URI containing file(s) to import. The
                                                                                                        	// URI must be in the following format: `gs://{bucket_id}/{object_id}`.
                                                                                                        	// The URI can include wildcards in `object_id` and thus identify
                                                                                                        	// multiple files. Supported wildcards: * `*` to match 0 or more
                                                                                                        	// non-separator characters * `**` to match 0 or more characters
                                                                                                        	// (including separators). Must be used at the end of a path and with no
                                                                                                        	// other wildcards in the path. Can also be used with a file extension
                                                                                                        	// (such as .ndjson), which imports all files with the extension in the
                                                                                                        	// specified directory and its sub-directories. For example,
                                                                                                        	// `gs://my-bucket/my-directory/**.ndjson` imports all files with
                                                                                                        	// `.ndjson` extensions in `my-directory/` and its sub-directories. *
                                                                                                        	// `?` to match 1 character Files matching the wildcard are expected to
                                                                                                        	// contain content only, no metadata.
                                                                                                        	Uri string `json:"uri,omitempty"`
                                                                                                        
                                                                                                        	// ForceSendFields is a list of field names (e.g. "Uri") to
                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                        
                                                                                                        	// NullFields is a list of field names (e.g. "Uri") to include in API
                                                                                                        	// requests with the JSON null value. By default, fields with empty
                                                                                                        	// values are omitted from API requests. However, any field with an
                                                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                                                        	// This may be used to include null fields in Patch requests.
                                                                                                        	NullFields []string `json:"-"`
                                                                                                        }

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

                                                                                                          func (*GoogleCloudHealthcareV1FhirGcsSource) MarshalJSON

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

                                                                                                          type GroupOrSegment

                                                                                                          type GroupOrSegment struct {
                                                                                                          	Group *SchemaGroup `json:"group,omitempty"`
                                                                                                          
                                                                                                          	Segment *SchemaSegment `json:"segment,omitempty"`
                                                                                                          
                                                                                                          	// ForceSendFields is a list of field names (e.g. "Group") 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. "Group") 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:"-"`
                                                                                                          }

                                                                                                            GroupOrSegment: Construct representing a logical group or a segment.

                                                                                                            func (*GroupOrSegment) MarshalJSON

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

                                                                                                            type Hl7SchemaConfig

                                                                                                            type Hl7SchemaConfig struct {
                                                                                                            	// MessageSchemaConfigs: Map from each HL7v2 message type and trigger
                                                                                                            	// event pair, such as ADT_A04, to its schema configuration root group.
                                                                                                            	MessageSchemaConfigs map[string]SchemaGroup `json:"messageSchemaConfigs,omitempty"`
                                                                                                            
                                                                                                            	// Version: Each VersionSource is tested and only if they all match is
                                                                                                            	// the schema used for the message.
                                                                                                            	Version []*VersionSource `json:"version,omitempty"`
                                                                                                            
                                                                                                            	// ForceSendFields is a list of field names (e.g.
                                                                                                            	// "MessageSchemaConfigs") 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. "MessageSchemaConfigs") 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:"-"`
                                                                                                            }

                                                                                                              Hl7SchemaConfig: Root config message for HL7v2 schema. This contains a schema structure of groups and segments, and filters that determine which messages to apply the schema structure to.

                                                                                                              func (*Hl7SchemaConfig) MarshalJSON

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

                                                                                                              type Hl7TypesConfig

                                                                                                              type Hl7TypesConfig struct {
                                                                                                              	// Type: The HL7v2 type definitions.
                                                                                                              	Type []*Type `json:"type,omitempty"`
                                                                                                              
                                                                                                              	// Version: The version selectors that this config applies to. A message
                                                                                                              	// must match ALL version sources to apply.
                                                                                                              	Version []*VersionSource `json:"version,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:"-"`
                                                                                                              }

                                                                                                                Hl7TypesConfig: Root config for HL7v2 datatype definitions for a specific HL7v2 version.

                                                                                                                func (*Hl7TypesConfig) MarshalJSON

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

                                                                                                                type Hl7V2NotificationConfig

                                                                                                                type Hl7V2NotificationConfig struct {
                                                                                                                	// Filter: Restricts notifications sent for messages matching a filter.
                                                                                                                	// If this is empty, all messages are matched. The following syntax is
                                                                                                                	// available: * A string field value can be written as text inside
                                                                                                                	// quotation marks, for example "query text". The only valid
                                                                                                                	// relational operation for text fields is equality (`=`), where text is
                                                                                                                	// searched within the field, rather than having the field be equal to
                                                                                                                	// the text. For example, "Comment = great" returns messages with
                                                                                                                	// `great` in the comment field. * A number field value can be written
                                                                                                                	// as an integer, a decimal, or an exponential. The valid relational
                                                                                                                	// operators for number fields are the equality operator (`=`), along
                                                                                                                	// with the less than/greater than operators (`<`, `<=`, `>`, `>=`).
                                                                                                                	// Note that there is no inequality (`!=`) operator. You can prepend the
                                                                                                                	// `NOT` operator to an expression to negate it. * A date field value
                                                                                                                	// must be written in `yyyy-mm-dd` form. Fields with date and time use
                                                                                                                	// the RFC3339 time format. Leading zeros are required for one-digit
                                                                                                                	// months and days. The valid relational operators for date fields are
                                                                                                                	// the equality operator (`=`) , along with the less than/greater than
                                                                                                                	// operators (`<`, `<=`, `>`, `>=`). Note that there is no inequality
                                                                                                                	// (`!=`) operator. You can prepend the `NOT` operator to an expression
                                                                                                                	// to negate it. * Multiple field query expressions can be combined in
                                                                                                                	// one query by adding `AND` or `OR` operators between the expressions.
                                                                                                                	// If a boolean operator appears within a quoted string, it is not
                                                                                                                	// treated as special, it's just another part of the character string to
                                                                                                                	// be matched. You can prepend the `NOT` operator to an expression to
                                                                                                                	// negate it. The following fields and functions are available for
                                                                                                                	// filtering: * `message_type`, from the MSH-9.1 field. For example,
                                                                                                                	// `NOT message_type = "ADT". * `send_date` or `sendDate`, the
                                                                                                                	// YYYY-MM-DD date the message was sent in the dataset's time_zone, from
                                                                                                                	// the MSH-7 segment. For example, `send_date < "2017-01-02". *
                                                                                                                	// `send_time`, the timestamp when the message was sent, using the
                                                                                                                	// RFC3339 time format for comparisons, from the MSH-7 segment. For
                                                                                                                	// example, `send_time < "2017-01-02T00:00:00-05:00". * `create_time`,
                                                                                                                	// the timestamp when the message was created in the HL7v2 store. Use
                                                                                                                	// the RFC3339 time format for comparisons. For example, `create_time <
                                                                                                                	// "2017-01-02T00:00:00-05:00". * `send_facility`, the care center that
                                                                                                                	// the message came from, from the MSH-4 segment. For example,
                                                                                                                	// `send_facility = "ABC". * `PatientId(value, type)`, which matches if
                                                                                                                	// the message lists a patient having an ID of the given value and type
                                                                                                                	// in the PID-2, PID-3, or PID-4 segments. For example,
                                                                                                                	// `PatientId("123456", "MRN")`. * `labels.x`, a string value of the
                                                                                                                	// label with key `x` as set using the Message.labels map. For example,
                                                                                                                	// `labels."priority"="high". The operator `:*` can be used to assert
                                                                                                                	// the existence of a label. For example, `labels."priority":*`.
                                                                                                                	Filter string `json:"filter,omitempty"`
                                                                                                                
                                                                                                                	// PubsubTopic: The Pub/Sub (https://cloud.google.com/pubsub/docs/)
                                                                                                                	// topic that notifications of changes are published on. Supplied by the
                                                                                                                	// client. The notification is a `PubsubMessage` with the following
                                                                                                                	// fields: * `PubsubMessage.Data` contains the resource name. *
                                                                                                                	// `PubsubMessage.MessageId` is the ID of this notification. It's
                                                                                                                	// guaranteed to be unique within the topic. *
                                                                                                                	// `PubsubMessage.PublishTime` is the time when the message was
                                                                                                                	// published. Note that notifications are only sent if the topic is
                                                                                                                	// non-empty. Topic names
                                                                                                                	// (https://cloud.google.com/pubsub/docs/overview#names) must be scoped
                                                                                                                	// to a project. The Cloud Healthcare API service account,
                                                                                                                	// service-PROJECT_NUMBER@gcp-sa-healthcare.iam.gserviceaccount.com,
                                                                                                                	// must have publisher permissions on the given Pub/Sub topic. Not
                                                                                                                	// having adequate permissions causes the calls that send notifications
                                                                                                                	// to fail. If a notification cannot be published to Pub/Sub, errors are
                                                                                                                	// logged to Cloud Logging. For more information, see Viewing error logs
                                                                                                                	// in Cloud Logging
                                                                                                                	// (https://cloud.google.com/healthcare/docs/how-tos/logging)).
                                                                                                                	PubsubTopic string `json:"pubsubTopic,omitempty"`
                                                                                                                
                                                                                                                	// ForceSendFields is a list of field names (e.g. "Filter") to
                                                                                                                	// unconditionally include in API requests. By default, fields with
                                                                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                	// server regardless of whether the field is empty or not. This may be
                                                                                                                	// used to include empty fields in Patch requests.
                                                                                                                	ForceSendFields []string `json:"-"`
                                                                                                                
                                                                                                                	// NullFields is a list of field names (e.g. "Filter") to include in API
                                                                                                                	// requests with the JSON null value. By default, fields with empty
                                                                                                                	// values are omitted from API requests. However, any field with an
                                                                                                                	// empty value appearing in NullFields will be sent to the server as
                                                                                                                	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                	// This may be used to include null fields in Patch requests.
                                                                                                                	NullFields []string `json:"-"`
                                                                                                                }

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

                                                                                                                  func (*Hl7V2NotificationConfig) MarshalJSON

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

                                                                                                                  type Hl7V2Store

                                                                                                                  type Hl7V2Store struct {
                                                                                                                  	// Labels: User-supplied key-value pairs used to organize HL7v2 stores.
                                                                                                                  	// Label keys must be between 1 and 63 characters long, have a UTF-8
                                                                                                                  	// encoding of maximum 128 bytes, and must conform to the following PCRE
                                                                                                                  	// regular expression: \p{Ll}\p{Lo}{0,62} Label values are optional,
                                                                                                                  	// must be between 1 and 63 characters long, have a UTF-8 encoding of
                                                                                                                  	// maximum 128 bytes, and must conform to the following PCRE regular
                                                                                                                  	// expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63} No more than 64 labels can be
                                                                                                                  	// associated with a given store.
                                                                                                                  	Labels map[string]string `json:"labels,omitempty"`
                                                                                                                  
                                                                                                                  	// Name: Resource name of the HL7v2 store, of the form
                                                                                                                  	// `projects/{project_id}/datasets/{dataset_id}/hl7V2Stores/{hl7v2_store_
                                                                                                                  	// id}`.
                                                                                                                  	Name string `json:"name,omitempty"`
                                                                                                                  
                                                                                                                  	// NotificationConfigs: A list of notification configs. Each
                                                                                                                  	// configuration uses a filter to determine whether to publish a message
                                                                                                                  	// (both Ingest & Create) on the corresponding notification destination.
                                                                                                                  	// Only the message name is sent as part of the notification. Supplied
                                                                                                                  	// by the client.
                                                                                                                  	NotificationConfigs []*Hl7V2NotificationConfig `json:"notificationConfigs,omitempty"`
                                                                                                                  
                                                                                                                  	// ParserConfig: The configuration for the parser. It determines how the
                                                                                                                  	// server parses the messages.
                                                                                                                  	ParserConfig *ParserConfig `json:"parserConfig,omitempty"`
                                                                                                                  
                                                                                                                  	// RejectDuplicateMessage: Determines whether to reject duplicate
                                                                                                                  	// messages. A duplicate message is a message with the same raw bytes as
                                                                                                                  	// a message that has already been ingested/created in this HL7v2 store.
                                                                                                                  	// The default value is false, meaning that the store accepts the
                                                                                                                  	// duplicate messages and it also returns the same ACK message in the
                                                                                                                  	// IngestMessageResponse as has been returned previously. Note that only
                                                                                                                  	// one resource is created in the store. When this field is set to true,
                                                                                                                  	// CreateMessage/IngestMessage requests with a duplicate message will be
                                                                                                                  	// rejected by the store, and IngestMessageErrorDetail returns a NACK
                                                                                                                  	// message upon rejection.
                                                                                                                  	RejectDuplicateMessage bool `json:"rejectDuplicateMessage,omitempty"`
                                                                                                                  
                                                                                                                  	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                  	// server.
                                                                                                                  	googleapi.ServerResponse `json:"-"`
                                                                                                                  
                                                                                                                  	// ForceSendFields is a list of field names (e.g. "Labels") to
                                                                                                                  	// unconditionally include in API requests. By default, fields with
                                                                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                                                  	// used to include empty fields in Patch requests.
                                                                                                                  	ForceSendFields []string `json:"-"`
                                                                                                                  
                                                                                                                  	// NullFields is a list of field names (e.g. "Labels") to include in API
                                                                                                                  	// requests with the JSON null value. By default, fields with empty
                                                                                                                  	// values are omitted from API requests. However, any field with an
                                                                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                                  	NullFields []string `json:"-"`
                                                                                                                  }

                                                                                                                    Hl7V2Store: Represents an HL7v2 store.

                                                                                                                    func (*Hl7V2Store) MarshalJSON

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

                                                                                                                    type HttpBody

                                                                                                                    type HttpBody struct {
                                                                                                                    	// ContentType: The HTTP Content-Type header value specifying the
                                                                                                                    	// content type of the body.
                                                                                                                    	ContentType string `json:"contentType,omitempty"`
                                                                                                                    
                                                                                                                    	// Data: The HTTP request/response body as raw binary.
                                                                                                                    	Data string `json:"data,omitempty"`
                                                                                                                    
                                                                                                                    	// Extensions: Application specific response metadata. Must be set in
                                                                                                                    	// the first response for streaming APIs.
                                                                                                                    	Extensions []googleapi.RawMessage `json:"extensions,omitempty"`
                                                                                                                    
                                                                                                                    	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                    	// server.
                                                                                                                    	googleapi.ServerResponse `json:"-"`
                                                                                                                    
                                                                                                                    	// ForceSendFields is a list of field names (e.g. "ContentType") to
                                                                                                                    	// unconditionally include in API requests. By default, fields with
                                                                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                                                                    	// used to include empty fields in Patch requests.
                                                                                                                    	ForceSendFields []string `json:"-"`
                                                                                                                    
                                                                                                                    	// NullFields is a list of field names (e.g. "ContentType") to include
                                                                                                                    	// in API requests with the JSON null value. By default, fields with
                                                                                                                    	// empty values are omitted from API requests. However, any field with
                                                                                                                    	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                                                    	NullFields []string `json:"-"`
                                                                                                                    }

                                                                                                                      HttpBody: Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged.

                                                                                                                      func (*HttpBody) MarshalJSON

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

                                                                                                                      type Image

                                                                                                                      type Image struct {
                                                                                                                      	// GcsUri: Input only. Points to a Cloud Storage URI containing the
                                                                                                                      	// consent artifact content. The URI must be in the following format:
                                                                                                                      	// `gs://{bucket_id}/{object_id}`. The Cloud Healthcare API service
                                                                                                                      	// account must have the `roles/storage.objectViewer` Cloud IAM role for
                                                                                                                      	// this Cloud Storage location. The consent artifact content at this URI
                                                                                                                      	// is copied to a Cloud Storage location managed by the Cloud Healthcare
                                                                                                                      	// API. Responses to fetching requests return the consent artifact
                                                                                                                      	// content in raw_bytes.
                                                                                                                      	GcsUri string `json:"gcsUri,omitempty"`
                                                                                                                      
                                                                                                                      	// RawBytes: Consent art