2
2
mirror of https://github.com/octoleo/restic.git synced 2024-12-11 13:52:31 +00:00
restic/vendor/google.golang.org/api/dlp/v2beta1/dlp-gen.go

7248 lines
289 KiB
Go
Raw Normal View History

// Package dlp provides access to the Cloud Data Loss Prevention (DLP) API.
2017-08-05 18:17:15 +00:00
//
// See https://cloud.google.com/dlp/docs/
//
// Usage example:
//
// import "google.golang.org/api/dlp/v2beta1"
// ...
// dlpService, err := dlp.New(oauthHttpClient)
package dlp // import "google.golang.org/api/dlp/v2beta1"
import (
"bytes"
"encoding/json"
"errors"
"fmt"
context "golang.org/x/net/context"
ctxhttp "golang.org/x/net/context/ctxhttp"
gensupport "google.golang.org/api/gensupport"
googleapi "google.golang.org/api/googleapi"
"io"
"net/http"
"net/url"
"strconv"
"strings"
)
// Always reference these packages, just in case the auto-generated code
// below doesn't.
var _ = bytes.NewBuffer
var _ = strconv.Itoa
var _ = fmt.Sprintf
var _ = json.NewDecoder
var _ = io.Copy
var _ = url.Parse
var _ = gensupport.MarshalJSON
var _ = googleapi.Version
var _ = errors.New
var _ = strings.Replace
var _ = context.Canceled
var _ = ctxhttp.Do
const apiId = "dlp:v2beta1"
const apiName = "dlp"
const apiVersion = "v2beta1"
const basePath = "https://dlp.googleapis.com/"
// OAuth2 scopes used by this API.
const (
// View and manage your data across Google Cloud Platform services
CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
)
func New(client *http.Client) (*Service, error) {
if client == nil {
return nil, errors.New("client is nil")
}
s := &Service{client: client, BasePath: basePath}
s.Content = NewContentService(s)
2017-09-21 15:48:45 +00:00
s.DataSource = NewDataSourceService(s)
2017-08-05 18:17:15 +00:00
s.Inspect = NewInspectService(s)
2017-09-13 12:09:48 +00:00
s.RiskAnalysis = NewRiskAnalysisService(s)
2017-08-05 18:17:15 +00:00
s.RootCategories = NewRootCategoriesService(s)
return s, nil
}
type Service struct {
client *http.Client
BasePath string // API endpoint base URL
UserAgent string // optional additional User-Agent fragment
Content *ContentService
2017-09-21 15:48:45 +00:00
DataSource *DataSourceService
2017-08-05 18:17:15 +00:00
Inspect *InspectService
2017-09-13 12:09:48 +00:00
RiskAnalysis *RiskAnalysisService
2017-08-05 18:17:15 +00:00
RootCategories *RootCategoriesService
}
func (s *Service) userAgent() string {
if s.UserAgent == "" {
return googleapi.UserAgent
}
return googleapi.UserAgent + " " + s.UserAgent
}
func NewContentService(s *Service) *ContentService {
rs := &ContentService{s: s}
return rs
}
type ContentService struct {
s *Service
}
2017-09-21 15:48:45 +00:00
func NewDataSourceService(s *Service) *DataSourceService {
rs := &DataSourceService{s: s}
return rs
}
type DataSourceService struct {
s *Service
}
2017-08-05 18:17:15 +00:00
func NewInspectService(s *Service) *InspectService {
rs := &InspectService{s: s}
rs.Operations = NewInspectOperationsService(s)
rs.Results = NewInspectResultsService(s)
return rs
}
type InspectService struct {
s *Service
Operations *InspectOperationsService
Results *InspectResultsService
}
func NewInspectOperationsService(s *Service) *InspectOperationsService {
rs := &InspectOperationsService{s: s}
return rs
}
type InspectOperationsService struct {
s *Service
}
func NewInspectResultsService(s *Service) *InspectResultsService {
rs := &InspectResultsService{s: s}
rs.Findings = NewInspectResultsFindingsService(s)
return rs
}
type InspectResultsService struct {
s *Service
Findings *InspectResultsFindingsService
}
func NewInspectResultsFindingsService(s *Service) *InspectResultsFindingsService {
rs := &InspectResultsFindingsService{s: s}
return rs
}
type InspectResultsFindingsService struct {
s *Service
}
2017-09-13 12:09:48 +00:00
func NewRiskAnalysisService(s *Service) *RiskAnalysisService {
rs := &RiskAnalysisService{s: s}
rs.Operations = NewRiskAnalysisOperationsService(s)
return rs
}
type RiskAnalysisService struct {
s *Service
Operations *RiskAnalysisOperationsService
}
func NewRiskAnalysisOperationsService(s *Service) *RiskAnalysisOperationsService {
rs := &RiskAnalysisOperationsService{s: s}
return rs
}
type RiskAnalysisOperationsService struct {
s *Service
}
2017-08-05 18:17:15 +00:00
func NewRootCategoriesService(s *Service) *RootCategoriesService {
rs := &RootCategoriesService{s: s}
rs.InfoTypes = NewRootCategoriesInfoTypesService(s)
return rs
}
type RootCategoriesService struct {
s *Service
InfoTypes *RootCategoriesInfoTypesService
}
func NewRootCategoriesInfoTypesService(s *Service) *RootCategoriesInfoTypesService {
rs := &RootCategoriesInfoTypesService{s: s}
return rs
}
type RootCategoriesInfoTypesService struct {
s *Service
}
// GoogleLongrunningCancelOperationRequest: The request message for
// Operations.CancelOperation.
type GoogleLongrunningCancelOperationRequest struct {
}
// GoogleLongrunningListOperationsResponse: The response message for
// Operations.ListOperations.
type GoogleLongrunningListOperationsResponse struct {
// NextPageToken: The standard List next-page token.
NextPageToken string `json:"nextPageToken,omitempty"`
// Operations: A list of operations that matches the specified filter in
// the request.
Operations []*GoogleLongrunningOperation `json:"operations,omitempty"`
// ServerResponse contains the HTTP response code and headers from the
// server.
googleapi.ServerResponse `json:"-"`
// ForceSendFields is a list of field names (e.g. "NextPageToken") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "NextPageToken") to include
// in API requests with the JSON null value. By default, fields with
// empty values are omitted from API requests. However, any field with
// an empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GoogleLongrunningListOperationsResponse) MarshalJSON() ([]byte, error) {
type NoMethod GoogleLongrunningListOperationsResponse
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GoogleLongrunningOperation: This resource represents a long-running
// operation that is the result of a
// network API call.
type GoogleLongrunningOperation struct {
// Done: If the value is `false`, it means the operation is still in
// progress.
2017-09-13 12:09:48 +00:00
// If `true`, the operation is completed, and either `error` or
// `response` is
2017-08-05 18:17:15 +00:00
// available.
Done bool `json:"done,omitempty"`
// Error: The error result of the operation in case of failure or
// cancellation.
Error *GoogleRpcStatus `json:"error,omitempty"`
2017-09-21 15:48:45 +00:00
// Metadata: This field will contain an InspectOperationMetadata object
// for `inspect.operations.create` or a RiskAnalysisOperationMetadata
// object for `dataSource.analyze`. This will always be returned with
// the Operation.
2017-08-05 18:17:15 +00:00
Metadata googleapi.RawMessage `json:"metadata,omitempty"`
2017-09-21 15:48:45 +00:00
// Name: The server-assigned name. The `name` should have the format of
2017-08-05 18:17:15 +00:00
// `inspect/operations/<identifier>`.
Name string `json:"name,omitempty"`
2017-09-21 15:48:45 +00:00
// Response: This field will contain an InspectOperationResult object
// for `inspect.operations.create` or a RiskAnalysisOperationResult
// object for `dataSource.analyze`.
2017-08-05 18:17:15 +00:00
Response googleapi.RawMessage `json:"response,omitempty"`
// ServerResponse contains the HTTP response code and headers from the
// server.
googleapi.ServerResponse `json:"-"`
// ForceSendFields is a list of field names (e.g. "Done") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "Done") to include in API
// requests with the JSON null value. By default, fields with empty
// values are omitted from API requests. However, any field with an
// empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GoogleLongrunningOperation) MarshalJSON() ([]byte, error) {
type NoMethod GoogleLongrunningOperation
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1AnalyzeDataSourceRiskRequest: Request for
// creating a risk analysis operation.
type GooglePrivacyDlpV2beta1AnalyzeDataSourceRiskRequest struct {
// PrivacyMetric: Privacy metric to compute.
PrivacyMetric *GooglePrivacyDlpV2beta1PrivacyMetric `json:"privacyMetric,omitempty"`
// SourceTable: Input dataset to compute metrics over.
SourceTable *GooglePrivacyDlpV2beta1BigQueryTable `json:"sourceTable,omitempty"`
// ForceSendFields is a list of field names (e.g. "PrivacyMetric") 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. "PrivacyMetric") 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 (s *GooglePrivacyDlpV2beta1AnalyzeDataSourceRiskRequest) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1AnalyzeDataSourceRiskRequest
raw := NoMethod(*s)
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1AuxiliaryTable: An auxiliary table contains
// statistical information on the relative
// frequency of different quasi-identifiers values. It has one or
// several
// quasi-identifiers columns, and one column that indicates the
// relative
// frequency of each quasi-identifier tuple.
// If a tuple is present in the data but not in the auxiliary table,
// the
// corresponding relative frequency is assumed to be zero (and thus,
// the
// tuple is highly reidentifiable).
type GooglePrivacyDlpV2beta1AuxiliaryTable struct {
// QuasiIds: Quasi-identifier columns. [required]
QuasiIds []*GooglePrivacyDlpV2beta1QuasiIdField `json:"quasiIds,omitempty"`
// RelativeFrequency: The relative frequency column must contain a
// floating-point number
// between 0 and 1 (inclusive). Null values are assumed to be
// zero.
// [required]
RelativeFrequency *GooglePrivacyDlpV2beta1FieldId `json:"relativeFrequency,omitempty"`
// Table: Auxiliary table location. [required]
Table *GooglePrivacyDlpV2beta1BigQueryTable `json:"table,omitempty"`
// ForceSendFields is a list of field names (e.g. "QuasiIds") 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. "QuasiIds") 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 (s *GooglePrivacyDlpV2beta1AuxiliaryTable) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1AuxiliaryTable
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1BigQueryKey: LINT.IfChange
// Row key for identifying a record in BigQuery table.
type GooglePrivacyDlpV2beta1BigQueryKey struct {
// RowNumber: Absolute number of the row from the beginning of the table
// at the time
// of scanning.
RowNumber int64 `json:"rowNumber,omitempty,string"`
// TableReference: Complete BigQuery table reference.
TableReference *GooglePrivacyDlpV2beta1BigQueryTable `json:"tableReference,omitempty"`
// ForceSendFields is a list of field names (e.g. "RowNumber") 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. "RowNumber") 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 (s *GooglePrivacyDlpV2beta1BigQueryKey) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1BigQueryKey
raw := NoMethod(*s)
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1BigQueryOptions: Options defining BigQuery
// table and row identifiers.
type GooglePrivacyDlpV2beta1BigQueryOptions struct {
// IdentifyingFields: References to fields uniquely identifying rows
// within the table.
2017-09-13 12:09:48 +00:00
// Nested fields in the format, like `person.birthdate.year`, are
// allowed.
2017-08-05 18:17:15 +00:00
IdentifyingFields []*GooglePrivacyDlpV2beta1FieldId `json:"identifyingFields,omitempty"`
// TableReference: Complete BigQuery table reference.
TableReference *GooglePrivacyDlpV2beta1BigQueryTable `json:"tableReference,omitempty"`
// ForceSendFields is a list of field names (e.g. "IdentifyingFields")
// 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. "IdentifyingFields") 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 (s *GooglePrivacyDlpV2beta1BigQueryOptions) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1BigQueryOptions
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1BigQueryTable: Message defining the location
// of a BigQuery table. A table is uniquely
2017-09-13 12:09:48 +00:00
// identified by its project_id, dataset_id, and table_name. Within a
// query
// a table is often referenced with a string in the format
// of:
// `<project_id>:<dataset_id>.<table_id>`
// or
// `<project_id>.<dataset_id>.<table_id>`.
2017-08-05 18:17:15 +00:00
type GooglePrivacyDlpV2beta1BigQueryTable struct {
// DatasetId: Dataset ID of the table.
DatasetId string `json:"datasetId,omitempty"`
2017-09-13 12:09:48 +00:00
// ProjectId: The Google Cloud Platform project ID of the project
// containing the table.
// If omitted, project ID is inferred from the API call.
2017-08-05 18:17:15 +00:00
ProjectId string `json:"projectId,omitempty"`
// TableId: Name of the table.
TableId string `json:"tableId,omitempty"`
// ForceSendFields is a list of field names (e.g. "DatasetId") 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. "DatasetId") 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 (s *GooglePrivacyDlpV2beta1BigQueryTable) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1BigQueryTable
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1Bucket: Buckets represented as ranges, along
// with replacement values. Ranges must
// be non-overlapping.
type GooglePrivacyDlpV2beta1Bucket struct {
// Max: Upper bound of the range, exclusive; type must match min.
Max *GooglePrivacyDlpV2beta1Value `json:"max,omitempty"`
// Min: Lower bound of the range, inclusive. Type should be the same as
// max if
// used.
Min *GooglePrivacyDlpV2beta1Value `json:"min,omitempty"`
// ReplacementValue: Replacement value for this bucket. If not
// provided
// the default behavior will be to hyphenate the min-max range.
ReplacementValue *GooglePrivacyDlpV2beta1Value `json:"replacementValue,omitempty"`
// ForceSendFields is a list of field names (e.g. "Max") 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. "Max") 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 (s *GooglePrivacyDlpV2beta1Bucket) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Bucket
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1BucketingConfig: Generalization function that
// buckets values based on ranges. The ranges and
// replacement values are dynamically provided by the user for custom
// behavior,
// such as 1-30 -> LOW 31-65 -> MEDIUM 66-100 -> HIGH
// This can be used on
// data of type: number, long, string, timestamp.
// If the bound `Value` type differs from the type of data being
// transformed, we
// will first attempt converting the type of the data to be transformed
// to match
// the type of the bound before comparing.
type GooglePrivacyDlpV2beta1BucketingConfig struct {
Buckets []*GooglePrivacyDlpV2beta1Bucket `json:"buckets,omitempty"`
// ForceSendFields is a list of field names (e.g. "Buckets") 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. "Buckets") 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 (s *GooglePrivacyDlpV2beta1BucketingConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1BucketingConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1CategoricalStatsConfig: Compute numerical
// stats over an individual column, including
// number of distinct values and value count distribution.
type GooglePrivacyDlpV2beta1CategoricalStatsConfig struct {
// Field: Field to compute categorical stats on. All column types
// are
// supported except for arrays and structs. However, it may be
// more
// informative to use NumericalStats when the field type is
// supported,
// depending on the data.
Field *GooglePrivacyDlpV2beta1FieldId `json:"field,omitempty"`
// ForceSendFields is a list of field names (e.g. "Field") 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. "Field") 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 (s *GooglePrivacyDlpV2beta1CategoricalStatsConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CategoricalStatsConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1CategoricalStatsHistogramBucket: Histogram
// bucket of value frequencies in the column.
type GooglePrivacyDlpV2beta1CategoricalStatsHistogramBucket struct {
// BucketSize: Total number of records in this bucket.
BucketSize int64 `json:"bucketSize,omitempty,string"`
// BucketValues: Sample of value frequencies in this bucket. The total
// number of
// values returned per bucket is capped at 20.
BucketValues []*GooglePrivacyDlpV2beta1ValueFrequency `json:"bucketValues,omitempty"`
// ValueFrequencyLowerBound: Lower bound on the value frequency of the
// values in this bucket.
ValueFrequencyLowerBound int64 `json:"valueFrequencyLowerBound,omitempty,string"`
// ValueFrequencyUpperBound: Upper bound on the value frequency of the
// values in this bucket.
ValueFrequencyUpperBound int64 `json:"valueFrequencyUpperBound,omitempty,string"`
// ForceSendFields is a list of field names (e.g. "BucketSize") 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. "BucketSize") 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 (s *GooglePrivacyDlpV2beta1CategoricalStatsHistogramBucket) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CategoricalStatsHistogramBucket
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1CategoricalStatsResult: Result of the
// categorical stats computation.
type GooglePrivacyDlpV2beta1CategoricalStatsResult struct {
// ValueFrequencyHistogramBuckets: Histogram of value frequencies in the
// column.
ValueFrequencyHistogramBuckets []*GooglePrivacyDlpV2beta1CategoricalStatsHistogramBucket `json:"valueFrequencyHistogramBuckets,omitempty"`
// ForceSendFields is a list of field names (e.g.
// "ValueFrequencyHistogramBuckets") 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.
// "ValueFrequencyHistogramBuckets") 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 (s *GooglePrivacyDlpV2beta1CategoricalStatsResult) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CategoricalStatsResult
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1CategoryDescription: Info Type Category
// description.
type GooglePrivacyDlpV2beta1CategoryDescription struct {
// DisplayName: Human readable form of the category name.
DisplayName string `json:"displayName,omitempty"`
// Name: Internal name of the category.
Name string `json:"name,omitempty"`
// ForceSendFields is a list of field names (e.g. "DisplayName") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "DisplayName") to include
// in API requests with the JSON null value. By default, fields with
// empty values are omitted from API requests. However, any field with
// an empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1CategoryDescription) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CategoryDescription
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1CharacterMaskConfig: Partially mask a string
// by replacing a given number of characters with a
// fixed character. Masking can start from the beginning or end of the
// string.
// This can be used on data of any type (numbers, longs, and so on) and
// when
// de-identifying structured data we'll attempt to preserve the original
// data's
// type. (This allows you to take a long like 123 and modify it to a
// string like
// **3.
type GooglePrivacyDlpV2beta1CharacterMaskConfig struct {
// CharactersToIgnore: When masking a string, items in this list will be
// skipped when replacing.
// For example, if your string is 555-555-5555 and you ask us to skip
// `-` and
// mask 5 chars with * we would produce ***-*55-5555.
CharactersToIgnore []*GooglePrivacyDlpV2beta1CharsToIgnore `json:"charactersToIgnore,omitempty"`
// MaskingCharacter: Character to mask the sensitive values&mdash;for
// example, "*" for an
// alphabetic string such as name, or "0" for a numeric string such as
// ZIP
// code or credit card number. String must have length 1. If not
// supplied, we
// will default to "*" for strings, 0 for digits.
MaskingCharacter string `json:"maskingCharacter,omitempty"`
// NumberToMask: Number of characters to mask. If not set, all matching
// chars will be
// masked. Skipped characters do not count towards this tally.
NumberToMask int64 `json:"numberToMask,omitempty"`
// ReverseOrder: Mask characters in reverse order. For example, if
// `masking_character` is
// '0', number_to_mask is 14, and `reverse_order` is false,
// then
// 1234-5678-9012-3456 -> 00000000000000-3456
// If `masking_character` is '*', `number_to_mask` is 3, and
// `reverse_order`
// is true, then 12345 -> 12***
ReverseOrder bool `json:"reverseOrder,omitempty"`
// ForceSendFields is a list of field names (e.g. "CharactersToIgnore")
// 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. "CharactersToIgnore") 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 (s *GooglePrivacyDlpV2beta1CharacterMaskConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CharacterMaskConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1CharsToIgnore: Characters to skip when doing
// deidentification of a value. These will be left
// alone and skipped.
type GooglePrivacyDlpV2beta1CharsToIgnore struct {
CharactersToSkip string `json:"charactersToSkip,omitempty"`
// Possible values:
// "CHARACTER_GROUP_UNSPECIFIED"
// "NUMERIC" - 0-9
// "ALPHA_UPPER_CASE" - A-Z
// "ALPHA_LOWER_CASE" - a-z
// "PUNCTUATION" - US Punctuation, one of
// !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
// "WHITESPACE" - Whitespace character, one of [ \t\n\x0B\f\r]
CommonCharactersToIgnore string `json:"commonCharactersToIgnore,omitempty"`
// ForceSendFields is a list of field names (e.g. "CharactersToSkip") 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. "CharactersToSkip") 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 (s *GooglePrivacyDlpV2beta1CharsToIgnore) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CharsToIgnore
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1CloudStorageKey: Record key for a finding in a
// Cloud Storage file.
type GooglePrivacyDlpV2beta1CloudStorageKey struct {
// FilePath: Path to the file.
FilePath string `json:"filePath,omitempty"`
// StartOffset: Byte offset of the referenced data in the file.
StartOffset int64 `json:"startOffset,omitempty,string"`
// ForceSendFields is a list of field names (e.g. "FilePath") 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. "FilePath") 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 (s *GooglePrivacyDlpV2beta1CloudStorageKey) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CloudStorageKey
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1CloudStorageOptions: Options defining a file
// or a set of files (path ending with *) within
// a Google Cloud Storage bucket.
type GooglePrivacyDlpV2beta1CloudStorageOptions struct {
FileSet *GooglePrivacyDlpV2beta1FileSet `json:"fileSet,omitempty"`
// ForceSendFields is a list of field names (e.g. "FileSet") 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. "FileSet") 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 (s *GooglePrivacyDlpV2beta1CloudStorageOptions) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CloudStorageOptions
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1CloudStoragePath: A location in Cloud Storage.
type GooglePrivacyDlpV2beta1CloudStoragePath struct {
// Path: The url, in the format of `gs://bucket/<path>`.
Path string `json:"path,omitempty"`
// ForceSendFields is a list of field names (e.g. "Path") 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. "Path") 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 (s *GooglePrivacyDlpV2beta1CloudStoragePath) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CloudStoragePath
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1Color: Represents a color in the RGB color
// space.
type GooglePrivacyDlpV2beta1Color struct {
// Blue: The amount of blue in the color as a value in the interval [0,
// 1].
Blue float64 `json:"blue,omitempty"`
// Green: The amount of green in the color as a value in the interval
// [0, 1].
Green float64 `json:"green,omitempty"`
// Red: The amount of red in the color as a value in the interval [0,
// 1].
Red float64 `json:"red,omitempty"`
// ForceSendFields is a list of field names (e.g. "Blue") 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. "Blue") 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 (s *GooglePrivacyDlpV2beta1Color) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Color
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
func (s *GooglePrivacyDlpV2beta1Color) UnmarshalJSON(data []byte) error {
type NoMethod GooglePrivacyDlpV2beta1Color
2017-08-05 18:17:15 +00:00
var s1 struct {
Blue gensupport.JSONFloat64 `json:"blue"`
Green gensupport.JSONFloat64 `json:"green"`
Red gensupport.JSONFloat64 `json:"red"`
*NoMethod
2017-08-05 18:17:15 +00:00
}
s1.NoMethod = (*NoMethod)(s)
2017-08-05 18:17:15 +00:00
if err := json.Unmarshal(data, &s1); err != nil {
return err
}
s.Blue = float64(s1.Blue)
s.Green = float64(s1.Green)
s.Red = float64(s1.Red)
return nil
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1Condition: The field type of `value` and
// `field` do not need to match to be
// considered equal, but not all comparisons are possible.
//
// A `value` of type:
//
// - `string` can be compared against all other types
// - `boolean` can only be compared against other booleans
// - `integer` can be compared against doubles or a string if the string
// value
// can be parsed as an integer.
// - `double` can be compared against integers or a string if the string
// can
// be parsed as a double.
// - `Timestamp` can be compared against strings in RFC 3339 date
// string
// format.
// - `TimeOfDay` can be compared against timestamps and strings in the
// format
// of 'HH:mm:ss'.
//
// If we fail to compare do to type mismatch, a warning will be given
// and
// the condition will evaluate to false.
type GooglePrivacyDlpV2beta1Condition struct {
// Field: Field within the record this condition is evaluated against.
// [required]
Field *GooglePrivacyDlpV2beta1FieldId `json:"field,omitempty"`
// Operator: Operator used to compare the field or info type to the
// value. [required]
//
// Possible values:
// "RELATIONAL_OPERATOR_UNSPECIFIED"
// "EQUAL_TO" - Equal.
// "NOT_EQUAL_TO" - Not equal to.
// "GREATER_THAN" - Greater than.
// "LESS_THAN" - Less than.
// "GREATER_THAN_OR_EQUALS" - Greater than or equals.
// "LESS_THAN_OR_EQUALS" - Less than or equals.
// "EXISTS" - Exists
Operator string `json:"operator,omitempty"`
// Value: Value to compare against. [Required, except for `EXISTS`
// tests.]
Value *GooglePrivacyDlpV2beta1Value `json:"value,omitempty"`
// ForceSendFields is a list of field names (e.g. "Field") 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. "Field") 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 (s *GooglePrivacyDlpV2beta1Condition) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Condition
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
type GooglePrivacyDlpV2beta1Conditions struct {
Conditions []*GooglePrivacyDlpV2beta1Condition `json:"conditions,omitempty"`
// ForceSendFields is a list of field names (e.g. "Conditions") 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. "Conditions") 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 (s *GooglePrivacyDlpV2beta1Conditions) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Conditions
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1ContentItem: Container structure for the
// content to inspect.
type GooglePrivacyDlpV2beta1ContentItem struct {
// Data: Content data to inspect or redact.
Data string `json:"data,omitempty"`
2017-09-13 12:09:48 +00:00
// Table: Structured content for inspection.
Table *GooglePrivacyDlpV2beta1Table `json:"table,omitempty"`
2017-08-05 18:17:15 +00:00
// Type: Type of the content, as defined in Content-Type HTTP
// header.
// Supported types are: all "text" types, octet streams, PNG
// images,
// JPEG images.
Type string `json:"type,omitempty"`
// Value: String data to inspect or redact.
Value string `json:"value,omitempty"`
// ForceSendFields is a list of field names (e.g. "Data") 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. "Data") 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 (s *GooglePrivacyDlpV2beta1ContentItem) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1ContentItem
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1CreateInspectOperationRequest: Request for
// scheduling a scan of a data subset from a Google Platform
// data
// repository.
type GooglePrivacyDlpV2beta1CreateInspectOperationRequest struct {
// InspectConfig: Configuration for the inspector.
InspectConfig *GooglePrivacyDlpV2beta1InspectConfig `json:"inspectConfig,omitempty"`
2017-09-13 12:09:48 +00:00
// OperationConfig: Additional configuration settings for long running
// operations.
OperationConfig *GooglePrivacyDlpV2beta1OperationConfig `json:"operationConfig,omitempty"`
// OutputConfig: Optional location to store findings.
2017-08-05 18:17:15 +00:00
OutputConfig *GooglePrivacyDlpV2beta1OutputStorageConfig `json:"outputConfig,omitempty"`
// StorageConfig: Specification of the data set to process.
StorageConfig *GooglePrivacyDlpV2beta1StorageConfig `json:"storageConfig,omitempty"`
// ForceSendFields is a list of field names (e.g. "InspectConfig") 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. "InspectConfig") 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 (s *GooglePrivacyDlpV2beta1CreateInspectOperationRequest) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CreateInspectOperationRequest
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1CryptoHashConfig: Pseudonymization method that
// generates surrogates via cryptographic hashing.
// Uses SHA-256.
// Outputs a 32 byte digest as an uppercase hex string
// (for example, 41D1567F7F99F1DC2A5FAB886DEE5BEE).
// Currently, only string and integer values can be hashed.
type GooglePrivacyDlpV2beta1CryptoHashConfig struct {
// CryptoKey: The key used by the hash function.
CryptoKey *GooglePrivacyDlpV2beta1CryptoKey `json:"cryptoKey,omitempty"`
2017-08-05 18:17:15 +00:00
2017-09-21 15:48:45 +00:00
// ForceSendFields is a list of field names (e.g. "CryptoKey") to
2017-08-05 18:17:15 +00:00
// 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:"-"`
2017-09-21 15:48:45 +00:00
// NullFields is a list of field names (e.g. "CryptoKey") to include in
2017-08-05 18:17:15 +00:00
// 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:"-"`
}
2017-09-21 15:48:45 +00:00
func (s *GooglePrivacyDlpV2beta1CryptoHashConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CryptoHashConfig
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1CryptoKey: This is a data encryption key (DEK)
// (as opposed to
// a key encryption key (KEK) stored by KMS).
// When using KMS to wrap/unwrap DEKs, be sure to set an appropriate
// IAM policy on the KMS CryptoKey (KEK) to ensure an attacker
// cannot
// unwrap the data crypto key.
type GooglePrivacyDlpV2beta1CryptoKey struct {
KmsWrapped *GooglePrivacyDlpV2beta1KmsWrappedCryptoKey `json:"kmsWrapped,omitempty"`
2017-08-05 18:17:15 +00:00
2017-09-21 15:48:45 +00:00
Transient *GooglePrivacyDlpV2beta1TransientCryptoKey `json:"transient,omitempty"`
2017-08-05 18:17:15 +00:00
2017-09-21 15:48:45 +00:00
Unwrapped *GooglePrivacyDlpV2beta1UnwrappedCryptoKey `json:"unwrapped,omitempty"`
2017-08-05 18:17:15 +00:00
2017-09-21 15:48:45 +00:00
// ForceSendFields is a list of field names (e.g. "KmsWrapped") to
2017-08-05 18:17:15 +00:00
// 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:"-"`
2017-09-21 15:48:45 +00:00
// NullFields is a list of field names (e.g. "KmsWrapped") to include in
// API requests with the JSON null value. By default, fields with empty
2017-08-05 18:17:15 +00:00
// 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:"-"`
}
2017-09-21 15:48:45 +00:00
func (s *GooglePrivacyDlpV2beta1CryptoKey) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CryptoKey
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1CryptoReplaceFfxFpeConfig: Replaces an
// identifier with a surrogate using FPE with the FFX
2017-09-21 15:48:45 +00:00
// mode of operation.
// The identifier must be representable by the US-ASCII character
// set.
2017-09-21 15:48:45 +00:00
// For a given crypto key and context, the same identifier will
// be
// replaced with the same surrogate.
// Identifiers must be at least two characters long.
// In the case that the identifier is the empty string, it will be
// skipped.
2017-09-21 15:48:45 +00:00
type GooglePrivacyDlpV2beta1CryptoReplaceFfxFpeConfig struct {
// Possible values:
// "FFX_COMMON_NATIVE_ALPHABET_UNSPECIFIED"
// "NUMERIC" - [0-9] (radix of 10)
// "HEXADECIMAL" - [0-9A-F] (radix of 16)
// "UPPER_CASE_ALPHA_NUMERIC" - [0-9A-Z] (radix of 36)
// "ALPHA_NUMERIC" - [0-9A-Za-z] (radix of 62)
CommonAlphabet string `json:"commonAlphabet,omitempty"`
// Context: A context may be used for higher security since the
// same
// identifier in two different contexts likely will be given a
// distinct
// surrogate. The principle is that the likeliness is inversely
// related
// to the ratio of the number of distinct identifiers per context over
// the
// number of possible surrogates: As long as this ratio is small,
// the
// likehood is large.
//
// If the context is not set, a default tweak will be used.
// If the context is set but:
//
// 1. there is no record present when transforming a given value or
// 1. the field is not present when transforming a given value,
//
// a default tweak will be used.
//
// Note that case (1) is expected when an `InfoTypeTransformation`
// is
// applied to both structured and non-structured
// `ContentItem`s.
// Currently, the referenced field may be of value type integer or
// string.
//
// The tweak is constructed as a sequence of bytes in big endian byte
// order
// such that:
//
// - a 64 bit integer is encoded followed by a single byte of value 1
// - a string is encoded in UTF-8 format followed by a single byte of
// value 2
//
// This is also known as the 'tweak', as in tweakable encryption.
Context *GooglePrivacyDlpV2beta1FieldId `json:"context,omitempty"`
// CryptoKey: The key used by the encryption algorithm. [required]
CryptoKey *GooglePrivacyDlpV2beta1CryptoKey `json:"cryptoKey,omitempty"`
// CustomAlphabet: This is supported by mapping these to the
// alphanumeric characters
// that the FFX mode natively supports. This happens
// before/after
// encryption/decryption.
// Each character listed must appear only once.
// Number of characters must be in the range [2, 62].
// This must be encoded as ASCII.
// The order of characters does not matter.
CustomAlphabet string `json:"customAlphabet,omitempty"`
// Radix: The native way to select the alphabet. Must be in the range
// [2, 62].
Radix int64 `json:"radix,omitempty"`
// SurrogateInfoType: The custom info type to annotate the surrogate
// with.
// This annotation will be applied to the surrogate by prefixing it
// with
// the name of the custom info type followed by the number of
// characters comprising the surrogate. The following scheme defines
// the
// format: info_type_name(surrogate_character_count):surrogate
//
// For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE'
// and
// the surrogate is 'abc', the full replacement value
// will be: 'MY_TOKEN_INFO_TYPE(3):abc'
//
// This annotation identifies the surrogate when inspecting content
// using the
// custom info
// type
// [`SurrogateType`](/dlp/docs/reference/rest/v2beta1/InspectConfig#
// surrogatetype).
// This facilitates reversal of the surrogate when it occurs in free
// text.
//
// In order for inspection to work properly, the name of this info type
// must
// not occur naturally anywhere in your data; otherwise, inspection
// may
// find a surrogate that does not correspond to an actual
// identifier.
// Therefore, choose your custom info type name carefully after
// considering
// what your data looks like. One way to select a name that has a high
// chance
// of yielding reliable detection is to include one or more unicode
// characters
// that are highly improbable to exist in your data.
// For example, assuming your data is entered from a regular ASCII
// keyboard,
// the symbol with the hex code point 29DD might be used like
// so:
// ⧝MY_TOKEN_TYPE
SurrogateInfoType *GooglePrivacyDlpV2beta1InfoType `json:"surrogateInfoType,omitempty"`
2017-09-21 15:48:45 +00:00
// ForceSendFields is a list of field names (e.g. "CommonAlphabet") 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. "CommonAlphabet") 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 (s *GooglePrivacyDlpV2beta1CryptoReplaceFfxFpeConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CryptoReplaceFfxFpeConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-10-22 08:07:36 +00:00
// GooglePrivacyDlpV2beta1CustomInfoType: Custom information type
// provided by the user. Used to find domain-specific
// sensitive information configurable to the data in question.
type GooglePrivacyDlpV2beta1CustomInfoType struct {
// Dictionary: Dictionary-based custom info type.
Dictionary *GooglePrivacyDlpV2beta1Dictionary `json:"dictionary,omitempty"`
// InfoType: Info type configuration. All custom info types must have
// configurations
// that do not conflict with built-in info types or other custom info
// types.
InfoType *GooglePrivacyDlpV2beta1InfoType `json:"infoType,omitempty"`
// SurrogateType: Surrogate info type.
SurrogateType *GooglePrivacyDlpV2beta1SurrogateType `json:"surrogateType,omitempty"`
2017-10-22 08:07:36 +00:00
// ForceSendFields is a list of field names (e.g. "Dictionary") 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. "Dictionary") 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 (s *GooglePrivacyDlpV2beta1CustomInfoType) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1CustomInfoType
raw := NoMethod(*s)
2017-10-22 08:07:36 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1DatastoreKey: Record key for a finding in
// Cloud Datastore.
type GooglePrivacyDlpV2beta1DatastoreKey struct {
// EntityKey: Datastore entity key.
EntityKey *GooglePrivacyDlpV2beta1Key `json:"entityKey,omitempty"`
// ForceSendFields is a list of field names (e.g. "EntityKey") 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. "EntityKey") 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 (s *GooglePrivacyDlpV2beta1DatastoreKey) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1DatastoreKey
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1DatastoreOptions: Options defining a data set
// within Google Cloud Datastore.
type GooglePrivacyDlpV2beta1DatastoreOptions struct {
// Kind: The kind to process.
Kind *GooglePrivacyDlpV2beta1KindExpression `json:"kind,omitempty"`
// PartitionId: A partition ID identifies a grouping of entities. The
// grouping is always
// by project and namespace, however the namespace ID may be empty.
PartitionId *GooglePrivacyDlpV2beta1PartitionId `json:"partitionId,omitempty"`
// Projection: Properties to scan. If none are specified, all properties
// will be scanned
// by default.
Projection []*GooglePrivacyDlpV2beta1Projection `json:"projection,omitempty"`
// ForceSendFields is a list of field names (e.g. "Kind") 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. "Kind") 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 (s *GooglePrivacyDlpV2beta1DatastoreOptions) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1DatastoreOptions
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1DeidentificationSummary: High level summary of
// deidentification.
type GooglePrivacyDlpV2beta1DeidentificationSummary struct {
// TransformationSummaries: Transformations applied to the dataset.
TransformationSummaries []*GooglePrivacyDlpV2beta1TransformationSummary `json:"transformationSummaries,omitempty"`
// TransformedBytes: Total size in bytes that were transformed in some
// way.
TransformedBytes int64 `json:"transformedBytes,omitempty,string"`
// ForceSendFields is a list of field names (e.g.
// "TransformationSummaries") 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. "TransformationSummaries")
// 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 (s *GooglePrivacyDlpV2beta1DeidentificationSummary) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1DeidentificationSummary
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1DeidentifyConfig: The configuration that
// controls how the data will change.
type GooglePrivacyDlpV2beta1DeidentifyConfig struct {
// InfoTypeTransformations: Treat the dataset as free-form text and
// apply the same free text
// transformation everywhere.
InfoTypeTransformations *GooglePrivacyDlpV2beta1InfoTypeTransformations `json:"infoTypeTransformations,omitempty"`
// RecordTransformations: Treat the dataset as structured.
// Transformations can be applied to
// specific locations within structured datasets, such as transforming
// a column within a table.
RecordTransformations *GooglePrivacyDlpV2beta1RecordTransformations `json:"recordTransformations,omitempty"`
// ForceSendFields is a list of field names (e.g.
// "InfoTypeTransformations") 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. "InfoTypeTransformations")
// 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 (s *GooglePrivacyDlpV2beta1DeidentifyConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1DeidentifyConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1DeidentifyContentRequest: Request to
// de-identify a list of items.
type GooglePrivacyDlpV2beta1DeidentifyContentRequest struct {
// DeidentifyConfig: Configuration for the de-identification of the list
// of content items.
DeidentifyConfig *GooglePrivacyDlpV2beta1DeidentifyConfig `json:"deidentifyConfig,omitempty"`
// InspectConfig: Configuration for the inspector.
InspectConfig *GooglePrivacyDlpV2beta1InspectConfig `json:"inspectConfig,omitempty"`
// Items: The list of items to inspect. Up to 100 are allowed per
// request.
// All items will be treated as text/*.
Items []*GooglePrivacyDlpV2beta1ContentItem `json:"items,omitempty"`
// ForceSendFields is a list of field names (e.g. "DeidentifyConfig") 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. "DeidentifyConfig") 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 (s *GooglePrivacyDlpV2beta1DeidentifyContentRequest) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1DeidentifyContentRequest
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1DeidentifyContentResponse: Results of
// de-identifying a list of items.
type GooglePrivacyDlpV2beta1DeidentifyContentResponse struct {
Items []*GooglePrivacyDlpV2beta1ContentItem `json:"items,omitempty"`
// Summaries: A review of the transformations that took place for each
// item.
Summaries []*GooglePrivacyDlpV2beta1DeidentificationSummary `json:"summaries,omitempty"`
// ServerResponse contains the HTTP response code and headers from the
// server.
googleapi.ServerResponse `json:"-"`
// ForceSendFields is a list of field names (e.g. "Items") 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. "Items") 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 (s *GooglePrivacyDlpV2beta1DeidentifyContentResponse) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1DeidentifyContentResponse
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-10-22 08:07:36 +00:00
// GooglePrivacyDlpV2beta1Dictionary: Custom information type based on a
// dictionary of words or phrases. This can
// be used to match sensitive information specific to the data, such as
// a list
// of employee IDs or job titles.
//
// Dictionary words are case-insensitive and all characters other than
// letters
// and digits in the unicode [Basic
// Multilingual
// Plane](https://en.wikipedia.org/wiki/Plane_%28Unicode%29#
// Basic_Multilingual_Plane)
2017-10-22 08:07:36 +00:00
// will be replaced with whitespace when scanning for matches, so
// the
// dictionary phrase "Sam Johnson" will match all three phrases "sam
// johnson",
// "Sam, Johnson", and "Sam (Johnson)". Additionally, the
// characters
// surrounding any match must be of a different type than the
// adjacent
// characters within the word, so letters must be next to non-letters
// and
// digits next to non-digits. For example, the dictionary word "jen"
// will
// match the first three letters of the text "jen123" but will return
// no
// matches for "jennifer".
//
// Dictionary words containing a large number of characters that are
// not
// letters or digits may result in unexpected findings because such
// characters
// are treated as whitespace.
type GooglePrivacyDlpV2beta1Dictionary struct {
// WordList: List of words or phrases to search for.
WordList *GooglePrivacyDlpV2beta1WordList `json:"wordList,omitempty"`
// ForceSendFields is a list of field names (e.g. "WordList") 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. "WordList") 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 (s *GooglePrivacyDlpV2beta1Dictionary) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Dictionary
raw := NoMethod(*s)
2017-10-22 08:07:36 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1EntityId: An entity in a dataset is a field or
// set of fields that correspond to a
// single person. For example, in medical records the `EntityId` might
// be
// a patient identifier, or for financial records it might be an
// account
// identifier. This message is used when generalizations or analysis
// must be
// consistent across multiple rows pertaining to the same entity.
type GooglePrivacyDlpV2beta1EntityId struct {
// Field: Composite key indicating which field contains the entity
// identifier.
Field *GooglePrivacyDlpV2beta1FieldId `json:"field,omitempty"`
// ForceSendFields is a list of field names (e.g. "Field") 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. "Field") 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 (s *GooglePrivacyDlpV2beta1EntityId) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1EntityId
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1Expressions: A collection of expressions
type GooglePrivacyDlpV2beta1Expressions struct {
Conditions *GooglePrivacyDlpV2beta1Conditions `json:"conditions,omitempty"`
// LogicalOperator: The operator to apply to the result of conditions.
// Default and currently
// only supported value is `AND`.
//
// Possible values:
// "LOGICAL_OPERATOR_UNSPECIFIED"
// "AND"
LogicalOperator string `json:"logicalOperator,omitempty"`
// ForceSendFields is a list of field names (e.g. "Conditions") 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. "Conditions") 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 (s *GooglePrivacyDlpV2beta1Expressions) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Expressions
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1FieldId: General identifier of a data field in
// a storage service.
type GooglePrivacyDlpV2beta1FieldId struct {
// ColumnName: Name describing the field.
ColumnName string `json:"columnName,omitempty"`
// ForceSendFields is a list of field names (e.g. "ColumnName") 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.
2017-08-05 18:17:15 +00:00
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "ColumnName") 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 (s *GooglePrivacyDlpV2beta1FieldId) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1FieldId
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1FieldTransformation: The transformation to
// apply to the field.
type GooglePrivacyDlpV2beta1FieldTransformation struct {
// Condition: Only apply the transformation if the condition evaluates
// to true for the
// given `RecordCondition`. The conditions are allowed to reference
// fields
// that are not used in the actual transformation. [optional]
//
// Example Use Cases:
//
// - Apply a different bucket transformation to an age column if the zip
// code
// column for the same record is within a specific range.
// - Redact a field if the date of birth field is greater than 85.
Condition *GooglePrivacyDlpV2beta1RecordCondition `json:"condition,omitempty"`
// Fields: Input field(s) to apply the transformation to. [required]
Fields []*GooglePrivacyDlpV2beta1FieldId `json:"fields,omitempty"`
// InfoTypeTransformations: Treat the contents of the field as free
// text, and selectively
// transform content that matches an `InfoType`.
InfoTypeTransformations *GooglePrivacyDlpV2beta1InfoTypeTransformations `json:"infoTypeTransformations,omitempty"`
// PrimitiveTransformation: Apply the transformation to the entire
// field.
PrimitiveTransformation *GooglePrivacyDlpV2beta1PrimitiveTransformation `json:"primitiveTransformation,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:"-"`
}
func (s *GooglePrivacyDlpV2beta1FieldTransformation) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1FieldTransformation
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1FileSet: Set of files to scan.
type GooglePrivacyDlpV2beta1FileSet struct {
// Url: The url, in the format `gs://<bucket>/<path>`. Trailing wildcard
// in the
// path is allowed.
Url string `json:"url,omitempty"`
// ForceSendFields is a list of field names (e.g. "Url") 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. "Url") 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 (s *GooglePrivacyDlpV2beta1FileSet) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1FileSet
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1Finding: Represents a piece of potentially
// sensitive content.
2017-08-05 18:17:15 +00:00
type GooglePrivacyDlpV2beta1Finding struct {
// CreateTime: Timestamp when finding was detected.
CreateTime string `json:"createTime,omitempty"`
// InfoType: The type of content that might have been found.
// Provided if requested by the `InspectConfig`.
2017-08-05 18:17:15 +00:00
InfoType *GooglePrivacyDlpV2beta1InfoType `json:"infoType,omitempty"`
// Likelihood: Estimate of how likely it is that the `info_type` is
2017-08-05 18:17:15 +00:00
// correct.
//
// Possible values:
// "LIKELIHOOD_UNSPECIFIED" - Default value; information with all
// likelihoods is included.
// "VERY_UNLIKELY" - Few matching elements.
// "UNLIKELY"
// "POSSIBLE" - Some matching elements.
// "LIKELY"
// "VERY_LIKELY" - Many matching elements.
Likelihood string `json:"likelihood,omitempty"`
// Location: Where the content was found.
2017-08-05 18:17:15 +00:00
Location *GooglePrivacyDlpV2beta1Location `json:"location,omitempty"`
// Quote: The content that was found. Even if the content is not
// textual, it
// may be converted to a textual representation here.
// Provided if requested by the `InspectConfig` and the finding is
// less than or equal to 4096 bytes long. If the finding exceeds 4096
// bytes
// in length, the quote may be omitted.
2017-08-05 18:17:15 +00:00
Quote string `json:"quote,omitempty"`
// ForceSendFields is a list of field names (e.g. "CreateTime") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "CreateTime") to include in
// API requests with the JSON null value. By default, fields with empty
// values are omitted from API requests. However, any field with an
// empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1Finding) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Finding
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1FixedSizeBucketingConfig: Buckets values based
// on fixed size ranges. The
// Bucketing transformation can provide all of this functionality,
// but requires more configuration. This message is provided as a
// convenience to
// the user for simple bucketing strategies.
// The resulting value will be a hyphenated string
// of
// lower_bound-upper_bound.
// This can be used on data of type: double, long.
// If the bound Value type differs from the type of data
// being transformed, we will first attempt converting the type of the
// data to
// be transformed to match the type of the bound before comparing.
type GooglePrivacyDlpV2beta1FixedSizeBucketingConfig struct {
// BucketSize: Size of each bucket (except for minimum and maximum
// buckets). So if
// `lower_bound` = 10, `upper_bound` = 89, and `bucket_size` = 10, then
// the
// following buckets would be used: -10, 10-20, 20-30, 30-40, 40-50,
// 50-60,
// 60-70, 70-80, 80-89, 89+. Precision up to 2 decimals works.
// [Required].
BucketSize float64 `json:"bucketSize,omitempty"`
// LowerBound: Lower bound value of buckets. All values less than
// `lower_bound` are
// grouped together into a single bucket; for example if `lower_bound` =
// 10,
// then all values less than 10 are replaced with the value “-10”.
// [Required].
LowerBound *GooglePrivacyDlpV2beta1Value `json:"lowerBound,omitempty"`
// UpperBound: Upper bound value of buckets. All values greater than
// upper_bound are
// grouped together into a single bucket; for example if `upper_bound` =
// 89,
// then all values greater than 89 are replaced with the value
// “89+”.
// [Required].
UpperBound *GooglePrivacyDlpV2beta1Value `json:"upperBound,omitempty"`
// ForceSendFields is a list of field names (e.g. "BucketSize") 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. "BucketSize") 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 (s *GooglePrivacyDlpV2beta1FixedSizeBucketingConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1FixedSizeBucketingConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
func (s *GooglePrivacyDlpV2beta1FixedSizeBucketingConfig) UnmarshalJSON(data []byte) error {
type NoMethod GooglePrivacyDlpV2beta1FixedSizeBucketingConfig
2017-09-21 15:48:45 +00:00
var s1 struct {
BucketSize gensupport.JSONFloat64 `json:"bucketSize"`
*NoMethod
2017-09-21 15:48:45 +00:00
}
s1.NoMethod = (*NoMethod)(s)
2017-09-21 15:48:45 +00:00
if err := json.Unmarshal(data, &s1); err != nil {
return err
}
s.BucketSize = float64(s1.BucketSize)
return nil
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1ImageLocation: Bounding box encompassing
// detected text within an image.
type GooglePrivacyDlpV2beta1ImageLocation struct {
// Height: Height of the bounding box in pixels.
Height int64 `json:"height,omitempty"`
// Left: Left coordinate of the bounding box. (0,0) is upper left.
Left int64 `json:"left,omitempty"`
// Top: Top coordinate of the bounding box. (0,0) is upper left.
Top int64 `json:"top,omitempty"`
// Width: Width of the bounding box in pixels.
Width int64 `json:"width,omitempty"`
// ForceSendFields is a list of field names (e.g. "Height") 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. "Height") 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 (s *GooglePrivacyDlpV2beta1ImageLocation) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1ImageLocation
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1ImageRedactionConfig: Configuration for
2017-10-22 08:07:36 +00:00
// determining how redaction of images should occur.
2017-08-05 18:17:15 +00:00
type GooglePrivacyDlpV2beta1ImageRedactionConfig struct {
// InfoType: Only one per info_type should be provided per request. If
// not
2017-09-13 12:09:48 +00:00
// specified, and redact_all_text is false, the DLP API will redact
2017-08-05 18:17:15 +00:00
// all
// text that it matches against all info_types that are found, but
// not
// specified in another ImageRedactionConfig.
InfoType *GooglePrivacyDlpV2beta1InfoType `json:"infoType,omitempty"`
2017-09-13 12:09:48 +00:00
// RedactAllText: If true, all text found in the image, regardless
// whether it matches an
2017-08-05 18:17:15 +00:00
// info_type, is redacted.
RedactAllText bool `json:"redactAllText,omitempty"`
// RedactionColor: The color to use when redacting content from an
// image. If not specified,
// the default is black.
RedactionColor *GooglePrivacyDlpV2beta1Color `json:"redactionColor,omitempty"`
// ForceSendFields is a list of field names (e.g. "InfoType") 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. "InfoType") 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 (s *GooglePrivacyDlpV2beta1ImageRedactionConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1ImageRedactionConfig
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1InfoType: Type of information detected by the
// API.
type GooglePrivacyDlpV2beta1InfoType struct {
// Name: Name of the information type.
Name string `json:"name,omitempty"`
// ForceSendFields is a list of field names (e.g. "Name") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "Name") to include in API
// requests with the JSON null value. By default, fields with empty
// values are omitted from API requests. However, any field with an
// empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1InfoType) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InfoType
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1InfoTypeDescription: Description of the
// information type (infoType).
2017-08-05 18:17:15 +00:00
type GooglePrivacyDlpV2beta1InfoTypeDescription struct {
2017-09-21 15:48:45 +00:00
// Categories: List of categories this infoType belongs to.
2017-08-05 18:17:15 +00:00
Categories []*GooglePrivacyDlpV2beta1CategoryDescription `json:"categories,omitempty"`
2017-09-21 15:48:45 +00:00
// DisplayName: Human readable form of the infoType name.
2017-08-05 18:17:15 +00:00
DisplayName string `json:"displayName,omitempty"`
2017-09-21 15:48:45 +00:00
// Name: Internal name of the infoType.
2017-08-05 18:17:15 +00:00
Name string `json:"name,omitempty"`
// ForceSendFields is a list of field names (e.g. "Categories") 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. "Categories") 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 (s *GooglePrivacyDlpV2beta1InfoTypeDescription) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InfoTypeDescription
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-13 12:09:48 +00:00
// GooglePrivacyDlpV2beta1InfoTypeLimit: Max findings configuration per
// info type, per content item or long running
// operation.
type GooglePrivacyDlpV2beta1InfoTypeLimit struct {
// InfoType: Type of information the findings limit applies to. Only one
// limit per
// info_type should be provided. If InfoTypeLimit does not have
// an
// info_type, the DLP API applies the limit against all info_types that
// are
// found but not specified in another InfoTypeLimit.
InfoType *GooglePrivacyDlpV2beta1InfoType `json:"infoType,omitempty"`
// MaxFindings: Max findings limit for the given infoType.
MaxFindings int64 `json:"maxFindings,omitempty"`
// ForceSendFields is a list of field names (e.g. "InfoType") 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. "InfoType") 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 (s *GooglePrivacyDlpV2beta1InfoTypeLimit) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InfoTypeLimit
raw := NoMethod(*s)
2017-09-13 12:09:48 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1InfoTypeStatistics: Statistics regarding a
// specific InfoType.
type GooglePrivacyDlpV2beta1InfoTypeStatistics struct {
// Count: Number of findings for this info type.
Count int64 `json:"count,omitempty,string"`
// InfoType: The type of finding this stat is for.
InfoType *GooglePrivacyDlpV2beta1InfoType `json:"infoType,omitempty"`
// ForceSendFields is a list of field names (e.g. "Count") 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. "Count") 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 (s *GooglePrivacyDlpV2beta1InfoTypeStatistics) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InfoTypeStatistics
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1InfoTypeTransformation: A transformation to
// apply to text that is identified as a specific
// info_type.
type GooglePrivacyDlpV2beta1InfoTypeTransformation struct {
// InfoTypes: Info types to apply the transformation to. Empty list will
// match all
// available info types for this transformation.
InfoTypes []*GooglePrivacyDlpV2beta1InfoType `json:"infoTypes,omitempty"`
// PrimitiveTransformation: Primitive transformation to apply to the
// info type. [required]
PrimitiveTransformation *GooglePrivacyDlpV2beta1PrimitiveTransformation `json:"primitiveTransformation,omitempty"`
// ForceSendFields is a list of field names (e.g. "InfoTypes") 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. "InfoTypes") 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 (s *GooglePrivacyDlpV2beta1InfoTypeTransformation) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InfoTypeTransformation
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1InfoTypeTransformations: A type of
// transformation that will scan unstructured text and
// apply various `PrimitiveTransformation`s to each finding, where
// the
// transformation is applied to only values that were identified as a
// specific
// info_type.
type GooglePrivacyDlpV2beta1InfoTypeTransformations struct {
// Transformations: Transformation for each info type. Cannot specify
// more than one
// for a given info type. [required]
Transformations []*GooglePrivacyDlpV2beta1InfoTypeTransformation `json:"transformations,omitempty"`
// ForceSendFields is a list of field names (e.g. "Transformations") 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. "Transformations") 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 (s *GooglePrivacyDlpV2beta1InfoTypeTransformations) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InfoTypeTransformations
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1InspectConfig: Configuration description of
// the scanning process.
// When used with redactContent only info_types and min_likelihood are
// currently
// used.
type GooglePrivacyDlpV2beta1InspectConfig struct {
2017-10-22 08:07:36 +00:00
// CustomInfoTypes: Custom info types provided by the user.
CustomInfoTypes []*GooglePrivacyDlpV2beta1CustomInfoType `json:"customInfoTypes,omitempty"`
2017-08-05 18:17:15 +00:00
// ExcludeTypes: When true, excludes type information of the findings.
ExcludeTypes bool `json:"excludeTypes,omitempty"`
// IncludeQuote: When true, a contextual quote from the data that
// triggered a finding is
// included in the response; see Finding.quote.
IncludeQuote bool `json:"includeQuote,omitempty"`
2017-09-13 12:09:48 +00:00
// InfoTypeLimits: Configuration of findings limit given for specified
// info types.
InfoTypeLimits []*GooglePrivacyDlpV2beta1InfoTypeLimit `json:"infoTypeLimits,omitempty"`
2017-08-05 18:17:15 +00:00
// InfoTypes: Restricts what info_types to look for. The values must
// correspond to
// InfoType values returned by ListInfoTypes or found in
// documentation.
// Empty info_types runs all enabled detectors.
InfoTypes []*GooglePrivacyDlpV2beta1InfoType `json:"infoTypes,omitempty"`
// MaxFindings: Limits the number of findings per content item or long
// running operation.
MaxFindings int64 `json:"maxFindings,omitempty"`
// MinLikelihood: Only returns findings equal or above this threshold.
//
// Possible values:
// "LIKELIHOOD_UNSPECIFIED" - Default value; information with all
// likelihoods is included.
// "VERY_UNLIKELY" - Few matching elements.
// "UNLIKELY"
// "POSSIBLE" - Some matching elements.
// "LIKELY"
// "VERY_LIKELY" - Many matching elements.
MinLikelihood string `json:"minLikelihood,omitempty"`
2017-10-22 08:07:36 +00:00
// ForceSendFields is a list of field names (e.g. "CustomInfoTypes") to
2017-08-05 18:17:15 +00:00
// 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:"-"`
2017-10-22 08:07:36 +00:00
// NullFields is a list of field names (e.g. "CustomInfoTypes") 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.
2017-08-05 18:17:15 +00:00
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1InspectConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InspectConfig
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1InspectContentRequest: Request to search for
// potentially sensitive info in a list of items.
type GooglePrivacyDlpV2beta1InspectContentRequest struct {
// InspectConfig: Configuration for the inspector.
InspectConfig *GooglePrivacyDlpV2beta1InspectConfig `json:"inspectConfig,omitempty"`
// Items: The list of items to inspect. Items in a single request
// are
// considered "related" unless inspect_config.independent_inputs is
// true.
// Up to 100 are allowed per request.
Items []*GooglePrivacyDlpV2beta1ContentItem `json:"items,omitempty"`
// ForceSendFields is a list of field names (e.g. "InspectConfig") 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. "InspectConfig") 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 (s *GooglePrivacyDlpV2beta1InspectContentRequest) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InspectContentRequest
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1InspectContentResponse: Results of inspecting
// a list of items.
type GooglePrivacyDlpV2beta1InspectContentResponse struct {
// Results: Each content_item from the request has a result in this
// list, in the
// same order as the request.
Results []*GooglePrivacyDlpV2beta1InspectResult `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. "Results") 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. "Results") 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 (s *GooglePrivacyDlpV2beta1InspectContentResponse) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InspectContentResponse
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1InspectOperationMetadata: Metadata returned
// within GetOperation for an inspect request.
type GooglePrivacyDlpV2beta1InspectOperationMetadata struct {
// CreateTime: The time which this request was started.
CreateTime string `json:"createTime,omitempty"`
InfoTypeStats []*GooglePrivacyDlpV2beta1InfoTypeStatistics `json:"infoTypeStats,omitempty"`
// ProcessedBytes: Total size in bytes that were processed.
ProcessedBytes int64 `json:"processedBytes,omitempty,string"`
// RequestInspectConfig: The inspect config used to create the
// Operation.
RequestInspectConfig *GooglePrivacyDlpV2beta1InspectConfig `json:"requestInspectConfig,omitempty"`
// RequestOutputConfig: Optional location to store findings.
RequestOutputConfig *GooglePrivacyDlpV2beta1OutputStorageConfig `json:"requestOutputConfig,omitempty"`
// RequestStorageConfig: The storage config used to create the
// Operation.
RequestStorageConfig *GooglePrivacyDlpV2beta1StorageConfig `json:"requestStorageConfig,omitempty"`
// TotalEstimatedBytes: Estimate of the number of bytes to process.
TotalEstimatedBytes int64 `json:"totalEstimatedBytes,omitempty,string"`
// ForceSendFields is a list of field names (e.g. "CreateTime") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "CreateTime") to include in
// API requests with the JSON null value. By default, fields with empty
// values are omitted from API requests. However, any field with an
// empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1InspectOperationMetadata) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InspectOperationMetadata
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1InspectOperationResult: The operational data.
type GooglePrivacyDlpV2beta1InspectOperationResult struct {
// Name: The server-assigned name, which is only unique within the same
// service that
// originally returns it. If you use the default HTTP mapping,
// the
// `name` should have the format of `inspect/results/{id}`.
Name string `json:"name,omitempty"`
// ForceSendFields is a list of field names (e.g. "Name") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "Name") to include in API
// requests with the JSON null value. By default, fields with empty
// values are omitted from API requests. However, any field with an
// empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1InspectOperationResult) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InspectOperationResult
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1InspectResult: All the findings for a single
// scanned item.
type GooglePrivacyDlpV2beta1InspectResult struct {
// Findings: List of findings for an item.
Findings []*GooglePrivacyDlpV2beta1Finding `json:"findings,omitempty"`
2017-09-21 15:48:45 +00:00
// FindingsTruncated: If true, then this item might have more findings
// than were returned,
// and the findings returned are an arbitrary subset of all
// findings.
// The findings list might be truncated because the input items were
// too
// large, or because the server reached the maximum amount of
// resources
// allowed for a single API call. For best results, divide the input
// into
// smaller batches.
FindingsTruncated bool `json:"findingsTruncated,omitempty"`
// ForceSendFields is a list of field names (e.g. "Findings") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "Findings") to include in
// API requests with the JSON null value. By default, fields with empty
// values are omitted from API requests. However, any field with an
// empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1InspectResult) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1InspectResult
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1KAnonymityConfig: k-anonymity metric, used for
// analysis of reidentification risk.
type GooglePrivacyDlpV2beta1KAnonymityConfig struct {
// EntityId: Optional message indicating that each distinct entity_id
2017-09-21 15:48:45 +00:00
// should not
// contribute to the k-anonymity count more than once per equivalence
// class.
// If an entity_id appears on several rows with different
// quasi-identifier
// tuples, it will contribute to each count exactly once.
//
// This can lead to unexpected results. Consider a table where ID 1
// is
// associated to quasi-identifier "foo", ID 2 to "bar", and ID 3 to
// *both*
// quasi-identifiers "foo" and "bar" (on separate rows), and where this
// ID
// is used as entity_id. Then, the anonymity value associated to ID 3
// will
// be 2, even if it is the only ID to be associated to both values "foo"
// and
// "bar".
2017-09-21 15:48:45 +00:00
EntityId *GooglePrivacyDlpV2beta1EntityId `json:"entityId,omitempty"`
// QuasiIds: Set of fields to compute k-anonymity over. When multiple
// fields are
// specified, they are considered a single composite key. Structs
// and
// repeated data types are not supported; however, nested fields
// are
// supported so long as they are not structs themselves or nested
// within
// a repeated field.
QuasiIds []*GooglePrivacyDlpV2beta1FieldId `json:"quasiIds,omitempty"`
// ForceSendFields is a list of field names (e.g. "EntityId") 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. "EntityId") 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 (s *GooglePrivacyDlpV2beta1KAnonymityConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1KAnonymityConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1KAnonymityEquivalenceClass: The set of
// columns' values that share the same k-anonymity value.
type GooglePrivacyDlpV2beta1KAnonymityEquivalenceClass struct {
// EquivalenceClassSize: Size of the equivalence class, for example
// number of rows with the
// above set of values.
EquivalenceClassSize int64 `json:"equivalenceClassSize,omitempty,string"`
// QuasiIdsValues: Set of values defining the equivalence class. One
// value per
// quasi-identifier column in the original KAnonymity metric
// message.
// The order is always the same as the original request.
QuasiIdsValues []*GooglePrivacyDlpV2beta1Value `json:"quasiIdsValues,omitempty"`
// ForceSendFields is a list of field names (e.g.
// "EquivalenceClassSize") 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. "EquivalenceClassSize") 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 (s *GooglePrivacyDlpV2beta1KAnonymityEquivalenceClass) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1KAnonymityEquivalenceClass
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1KAnonymityHistogramBucket: Histogram bucket of
// equivalence class sizes in the table.
type GooglePrivacyDlpV2beta1KAnonymityHistogramBucket struct {
// BucketSize: Total number of records in this bucket.
BucketSize int64 `json:"bucketSize,omitempty,string"`
// BucketValues: Sample of equivalence classes in this bucket. The total
// number of
// classes returned per bucket is capped at 20.
BucketValues []*GooglePrivacyDlpV2beta1KAnonymityEquivalenceClass `json:"bucketValues,omitempty"`
// EquivalenceClassSizeLowerBound: Lower bound on the size of the
// equivalence classes in this bucket.
EquivalenceClassSizeLowerBound int64 `json:"equivalenceClassSizeLowerBound,omitempty,string"`
// EquivalenceClassSizeUpperBound: Upper bound on the size of the
// equivalence classes in this bucket.
EquivalenceClassSizeUpperBound int64 `json:"equivalenceClassSizeUpperBound,omitempty,string"`
2017-08-05 18:17:15 +00:00
2017-09-21 15:48:45 +00:00
// ForceSendFields is a list of field names (e.g. "BucketSize") to
2017-08-05 18:17:15 +00:00
// 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:"-"`
2017-09-21 15:48:45 +00:00
// NullFields is a list of field names (e.g. "BucketSize") to include in
2017-08-05 18:17:15 +00:00
// 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:"-"`
}
2017-09-21 15:48:45 +00:00
func (s *GooglePrivacyDlpV2beta1KAnonymityHistogramBucket) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1KAnonymityHistogramBucket
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1KAnonymityResult: Result of the k-anonymity
// computation.
type GooglePrivacyDlpV2beta1KAnonymityResult struct {
// EquivalenceClassHistogramBuckets: Histogram of k-anonymity
// equivalence classes.
EquivalenceClassHistogramBuckets []*GooglePrivacyDlpV2beta1KAnonymityHistogramBucket `json:"equivalenceClassHistogramBuckets,omitempty"`
// ForceSendFields is a list of field names (e.g.
// "EquivalenceClassHistogramBuckets") 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.
// "EquivalenceClassHistogramBuckets") 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 (s *GooglePrivacyDlpV2beta1KAnonymityResult) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1KAnonymityResult
raw := NoMethod(*s)
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1KMapEstimationConfig: Reidentifiability
// metric. This corresponds to a risk model similar to what
// is called "journalist risk" in the literature, except the attack
// dataset is
// statistically modeled instead of being perfectly known. This can be
// done
// using publicly available data (like the US Census), or using a
// custom
// statistical model (indicated as one or several BigQuery tables), or
// by
// extrapolating from the distribution of values in the input dataset.
type GooglePrivacyDlpV2beta1KMapEstimationConfig struct {
// AuxiliaryTables: Several auxiliary tables can be used in the
// analysis. Each custom_tag
// used to tag a quasi-identifiers column must appear in exactly one
// column
// of one auxiliary table.
AuxiliaryTables []*GooglePrivacyDlpV2beta1AuxiliaryTable `json:"auxiliaryTables,omitempty"`
// QuasiIds: Fields considered to be quasi-identifiers. No two columns
// can have the
// same tag. [required]
QuasiIds []*GooglePrivacyDlpV2beta1TaggedField `json:"quasiIds,omitempty"`
// RegionCode: ISO 3166-1 alpha-2 region code to use in the statistical
// modeling.
// Required if no column is tagged with a region-specific InfoType
// (like
// US_ZIP_5) or a region code.
RegionCode string `json:"regionCode,omitempty"`
// ForceSendFields is a list of field names (e.g. "AuxiliaryTables") 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. "AuxiliaryTables") 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 (s *GooglePrivacyDlpV2beta1KMapEstimationConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1KMapEstimationConfig
raw := NoMethod(*s)
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1KMapEstimationHistogramBucket: A
// KMapEstimationHistogramBucket message with the following values:
// min_anonymity: 3
// max_anonymity: 5
// frequency: 42
// means that there are 42 records whose quasi-identifier values
// correspond
// to 3, 4 or 5 people in the overlying population. An important
// particular
// case is when min_anonymity = max_anonymity = 1: the frequency field
// then
// corresponds to the number of uniquely identifiable records.
type GooglePrivacyDlpV2beta1KMapEstimationHistogramBucket struct {
// BucketSize: Number of records within these anonymity bounds.
BucketSize int64 `json:"bucketSize,omitempty,string"`
// BucketValues: Sample of quasi-identifier tuple values in this bucket.
// The total
// number of classes returned per bucket is capped at 20.
BucketValues []*GooglePrivacyDlpV2beta1KMapEstimationQuasiIdValues `json:"bucketValues,omitempty"`
// MaxAnonymity: Always greater than or equal to min_anonymity.
MaxAnonymity int64 `json:"maxAnonymity,omitempty,string"`
// MinAnonymity: Always positive.
MinAnonymity int64 `json:"minAnonymity,omitempty,string"`
// ForceSendFields is a list of field names (e.g. "BucketSize") 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. "BucketSize") 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 (s *GooglePrivacyDlpV2beta1KMapEstimationHistogramBucket) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1KMapEstimationHistogramBucket
raw := NoMethod(*s)
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1KMapEstimationQuasiIdValues: A tuple of values
// for the quasi-identifier columns.
type GooglePrivacyDlpV2beta1KMapEstimationQuasiIdValues struct {
// EstimatedAnonymity: The estimated anonymity for these
// quasi-identifier values.
EstimatedAnonymity int64 `json:"estimatedAnonymity,omitempty,string"`
// QuasiIdsValues: The quasi-identifier values.
QuasiIdsValues []*GooglePrivacyDlpV2beta1Value `json:"quasiIdsValues,omitempty"`
// ForceSendFields is a list of field names (e.g. "EstimatedAnonymity")
// 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. "EstimatedAnonymity") 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 (s *GooglePrivacyDlpV2beta1KMapEstimationQuasiIdValues) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1KMapEstimationQuasiIdValues
raw := NoMethod(*s)
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1KMapEstimationResult: Result of the
// reidentifiability analysis. Note that these results are
// an
// estimation, not exact values.
type GooglePrivacyDlpV2beta1KMapEstimationResult struct {
// KMapEstimationHistogram: The intervals [min_anonymity, max_anonymity]
// do not overlap. If a value
// doesn't correspond to any such interval, the associated frequency
// is
// zero. For example, the following records:
// {min_anonymity: 1, max_anonymity: 1, frequency: 17}
// {min_anonymity: 2, max_anonymity: 3, frequency: 42}
// {min_anonymity: 5, max_anonymity: 10, frequency: 99}
// mean that there are no record with an estimated anonymity of 4, 5,
// or
// larger than 10.
KMapEstimationHistogram []*GooglePrivacyDlpV2beta1KMapEstimationHistogramBucket `json:"kMapEstimationHistogram,omitempty"`
// ForceSendFields is a list of field names (e.g.
// "KMapEstimationHistogram") 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. "KMapEstimationHistogram")
// 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 (s *GooglePrivacyDlpV2beta1KMapEstimationResult) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1KMapEstimationResult
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1Key: A unique identifier for a Datastore
// entity.
// If a key's partition ID or any of its path kinds or names
// are
// reserved/read-only, the key is reserved/read-only.
// A reserved/read-only key is forbidden in certain documented contexts.
type GooglePrivacyDlpV2beta1Key struct {
// PartitionId: Entities are partitioned into subsets, currently
// identified by a project
// ID and namespace ID.
// Queries are scoped to a single partition.
PartitionId *GooglePrivacyDlpV2beta1PartitionId `json:"partitionId,omitempty"`
// Path: The entity path.
// An entity path consists of one or more elements composed of a kind
// and a
// string or numerical identifier, which identify entities. The
// first
// element identifies a _root entity_, the second element identifies
// a _child_ of the root entity, the third element identifies a child of
// the
// second entity, and so forth. The entities identified by all prefixes
// of
// the path are called the element's _ancestors_.
//
// A path can never be empty, and a path can have at most 100 elements.
Path []*GooglePrivacyDlpV2beta1PathElement `json:"path,omitempty"`
// ForceSendFields is a list of field names (e.g. "PartitionId") 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. "PartitionId") 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 (s *GooglePrivacyDlpV2beta1Key) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Key
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1KindExpression: A representation of a
// Datastore kind.
type GooglePrivacyDlpV2beta1KindExpression struct {
// Name: The name of the kind.
Name string `json:"name,omitempty"`
// ForceSendFields is a list of field names (e.g. "Name") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "Name") to include in API
// requests with the JSON null value. By default, fields with empty
// values are omitted from API requests. However, any field with an
// empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1KindExpression) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1KindExpression
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1KmsWrappedCryptoKey: Include to use an
// existing data crypto key wrapped by KMS.
// Authorization requires the following IAM permissions when sending a
// request
// to perform a crypto transformation using a kms-wrapped crypto
// key:
// dlp.kms.encrypt
type GooglePrivacyDlpV2beta1KmsWrappedCryptoKey struct {
// CryptoKeyName: The resource name of the KMS CryptoKey to use for
// unwrapping. [required]
CryptoKeyName string `json:"cryptoKeyName,omitempty"`
// WrappedKey: The wrapped data crypto key. [required]
WrappedKey string `json:"wrappedKey,omitempty"`
// ForceSendFields is a list of field names (e.g. "CryptoKeyName") 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. "CryptoKeyName") 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 (s *GooglePrivacyDlpV2beta1KmsWrappedCryptoKey) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1KmsWrappedCryptoKey
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1LDiversityConfig: l-diversity metric, used for
// analysis of reidentification risk.
type GooglePrivacyDlpV2beta1LDiversityConfig struct {
// QuasiIds: Set of quasi-identifiers indicating how equivalence classes
// are
// defined for the l-diversity computation. When multiple fields
// are
// specified, they are considered a single composite key.
QuasiIds []*GooglePrivacyDlpV2beta1FieldId `json:"quasiIds,omitempty"`
// SensitiveAttribute: Sensitive field for computing the l-value.
SensitiveAttribute *GooglePrivacyDlpV2beta1FieldId `json:"sensitiveAttribute,omitempty"`
// ForceSendFields is a list of field names (e.g. "QuasiIds") 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. "QuasiIds") 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 (s *GooglePrivacyDlpV2beta1LDiversityConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1LDiversityConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1LDiversityEquivalenceClass: The set of
// columns' values that share the same l-diversity value.
type GooglePrivacyDlpV2beta1LDiversityEquivalenceClass struct {
// EquivalenceClassSize: Size of the k-anonymity equivalence class.
EquivalenceClassSize int64 `json:"equivalenceClassSize,omitempty,string"`
// NumDistinctSensitiveValues: Number of distinct sensitive values in
// this equivalence class.
NumDistinctSensitiveValues int64 `json:"numDistinctSensitiveValues,omitempty,string"`
// QuasiIdsValues: Quasi-identifier values defining the k-anonymity
// equivalence
// class. The order is always the same as the original request.
QuasiIdsValues []*GooglePrivacyDlpV2beta1Value `json:"quasiIdsValues,omitempty"`
// TopSensitiveValues: Estimated frequencies of top sensitive values.
TopSensitiveValues []*GooglePrivacyDlpV2beta1ValueFrequency `json:"topSensitiveValues,omitempty"`
// ForceSendFields is a list of field names (e.g.
// "EquivalenceClassSize") 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. "EquivalenceClassSize") 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 (s *GooglePrivacyDlpV2beta1LDiversityEquivalenceClass) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1LDiversityEquivalenceClass
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1LDiversityHistogramBucket: Histogram bucket of
// sensitive value frequencies in the table.
type GooglePrivacyDlpV2beta1LDiversityHistogramBucket struct {
// BucketSize: Total number of records in this bucket.
BucketSize int64 `json:"bucketSize,omitempty,string"`
// BucketValues: Sample of equivalence classes in this bucket. The total
// number of
// classes returned per bucket is capped at 20.
BucketValues []*GooglePrivacyDlpV2beta1LDiversityEquivalenceClass `json:"bucketValues,omitempty"`
// SensitiveValueFrequencyLowerBound: Lower bound on the sensitive value
// frequencies of the equivalence
// classes in this bucket.
SensitiveValueFrequencyLowerBound int64 `json:"sensitiveValueFrequencyLowerBound,omitempty,string"`
// SensitiveValueFrequencyUpperBound: Upper bound on the sensitive value
// frequencies of the equivalence
// classes in this bucket.
SensitiveValueFrequencyUpperBound int64 `json:"sensitiveValueFrequencyUpperBound,omitempty,string"`
// ForceSendFields is a list of field names (e.g. "BucketSize") 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. "BucketSize") 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 (s *GooglePrivacyDlpV2beta1LDiversityHistogramBucket) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1LDiversityHistogramBucket
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1LDiversityResult: Result of the l-diversity
// computation.
type GooglePrivacyDlpV2beta1LDiversityResult struct {
// SensitiveValueFrequencyHistogramBuckets: Histogram of l-diversity
// equivalence class sensitive value frequencies.
SensitiveValueFrequencyHistogramBuckets []*GooglePrivacyDlpV2beta1LDiversityHistogramBucket `json:"sensitiveValueFrequencyHistogramBuckets,omitempty"`
// ForceSendFields is a list of field names (e.g.
// "SensitiveValueFrequencyHistogramBuckets") 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.
// "SensitiveValueFrequencyHistogramBuckets") 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 (s *GooglePrivacyDlpV2beta1LDiversityResult) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1LDiversityResult
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1ListInfoTypesResponse: Response to the
// ListInfoTypes request.
type GooglePrivacyDlpV2beta1ListInfoTypesResponse struct {
// InfoTypes: Set of sensitive info types belonging to a category.
InfoTypes []*GooglePrivacyDlpV2beta1InfoTypeDescription `json:"infoTypes,omitempty"`
// ServerResponse contains the HTTP response code and headers from the
// server.
googleapi.ServerResponse `json:"-"`
// ForceSendFields is a list of field names (e.g. "InfoTypes") 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. "InfoTypes") 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 (s *GooglePrivacyDlpV2beta1ListInfoTypesResponse) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1ListInfoTypesResponse
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1ListInspectFindingsResponse: Response to the
// ListInspectFindings request.
type GooglePrivacyDlpV2beta1ListInspectFindingsResponse struct {
// NextPageToken: If not empty, indicates that there may be more results
// that match the
// request; this value should be passed in a new
// `ListInspectFindingsRequest`.
NextPageToken string `json:"nextPageToken,omitempty"`
// Result: The results.
Result *GooglePrivacyDlpV2beta1InspectResult `json:"result,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 (s *GooglePrivacyDlpV2beta1ListInspectFindingsResponse) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1ListInspectFindingsResponse
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1ListRootCategoriesResponse: Response for
// ListRootCategories request.
type GooglePrivacyDlpV2beta1ListRootCategoriesResponse struct {
// Categories: List of all into type categories supported by the API.
Categories []*GooglePrivacyDlpV2beta1CategoryDescription `json:"categories,omitempty"`
// ServerResponse contains the HTTP response code and headers from the
// server.
googleapi.ServerResponse `json:"-"`
// ForceSendFields is a list of field names (e.g. "Categories") 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. "Categories") 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 (s *GooglePrivacyDlpV2beta1ListRootCategoriesResponse) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1ListRootCategoriesResponse
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1Location: Specifies the location of the
// finding.
2017-08-05 18:17:15 +00:00
type GooglePrivacyDlpV2beta1Location struct {
// ByteRange: Zero-based byte offsets delimiting the finding.
// These are relative to the finding's containing element.
// Note that when the content is not textual, this references
// the UTF-8 encoded textual representation of the content.
// Omitted if content is an image.
2017-08-05 18:17:15 +00:00
ByteRange *GooglePrivacyDlpV2beta1Range `json:"byteRange,omitempty"`
// CodepointRange: Unicode character offsets delimiting the
// finding.
// These are relative to the finding's containing element.
// Provided when the content is text.
2017-08-05 18:17:15 +00:00
CodepointRange *GooglePrivacyDlpV2beta1Range `json:"codepointRange,omitempty"`
// FieldId: The pointer to the property or cell that contained the
// finding.
// Provided when the finding's containing element is a cell in a
// table
// or a property of storage object.
2017-08-05 18:17:15 +00:00
FieldId *GooglePrivacyDlpV2beta1FieldId `json:"fieldId,omitempty"`
// ImageBoxes: The area within the image that contained the
// finding.
// Provided when the content is an image.
2017-08-05 18:17:15 +00:00
ImageBoxes []*GooglePrivacyDlpV2beta1ImageLocation `json:"imageBoxes,omitempty"`
// RecordKey: The pointer to the record in storage that contained the
// field the
// finding was found in.
// Provided when the finding's containing element is a property
// of a storage object.
2017-08-05 18:17:15 +00:00
RecordKey *GooglePrivacyDlpV2beta1RecordKey `json:"recordKey,omitempty"`
// TableLocation: The pointer to the row of the table that contained the
// finding.
// Provided when the finding's containing element is a cell of a table.
2017-09-13 12:09:48 +00:00
TableLocation *GooglePrivacyDlpV2beta1TableLocation `json:"tableLocation,omitempty"`
2017-08-05 18:17:15 +00:00
// ForceSendFields is a list of field names (e.g. "ByteRange") 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. "ByteRange") 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 (s *GooglePrivacyDlpV2beta1Location) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Location
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1NumericalStatsConfig: Compute numerical stats
// over an individual column, including
// min, max, and quantiles.
type GooglePrivacyDlpV2beta1NumericalStatsConfig struct {
// Field: Field to compute numerical stats on. Supported types
// are
// integer, float, date, datetime, timestamp, time.
Field *GooglePrivacyDlpV2beta1FieldId `json:"field,omitempty"`
// ForceSendFields is a list of field names (e.g. "Field") 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. "Field") 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 (s *GooglePrivacyDlpV2beta1NumericalStatsConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1NumericalStatsConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1NumericalStatsResult: Result of the numerical
// stats computation.
type GooglePrivacyDlpV2beta1NumericalStatsResult struct {
// MaxValue: Maximum value appearing in the column.
MaxValue *GooglePrivacyDlpV2beta1Value `json:"maxValue,omitempty"`
// MinValue: Minimum value appearing in the column.
MinValue *GooglePrivacyDlpV2beta1Value `json:"minValue,omitempty"`
// QuantileValues: List of 99 values that partition the set of field
// values into 100 equal
// sized buckets.
QuantileValues []*GooglePrivacyDlpV2beta1Value `json:"quantileValues,omitempty"`
// ForceSendFields is a list of field names (e.g. "MaxValue") 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. "MaxValue") 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 (s *GooglePrivacyDlpV2beta1NumericalStatsResult) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1NumericalStatsResult
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-13 12:09:48 +00:00
// GooglePrivacyDlpV2beta1OperationConfig: Additional configuration for
// inspect long running operations.
type GooglePrivacyDlpV2beta1OperationConfig struct {
// MaxItemFindings: Max number of findings per file, Datastore entity,
// or database row.
MaxItemFindings int64 `json:"maxItemFindings,omitempty,string"`
// ForceSendFields is a list of field names (e.g. "MaxItemFindings") 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. "MaxItemFindings") 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 (s *GooglePrivacyDlpV2beta1OperationConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1OperationConfig
raw := NoMethod(*s)
2017-09-13 12:09:48 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1OutputStorageConfig: Cloud repository for
// storing output.
type GooglePrivacyDlpV2beta1OutputStorageConfig struct {
// StoragePath: The path to a Google Cloud Storage location to store
// output.
// The bucket must already exist and
// the Google APIs service account for DLP must have write permission
// to
// write to the given bucket.
// Results are split over multiple csv files with each file name
// matching
// the pattern "[operation_id]_[count].csv", for
// example
// `3094877188788974909_1.csv`. The `operation_id` matches
// the
// identifier for the Operation, and the `count` is a counter used
// for
// tracking the number of files written.
//
// The CSV file(s) contain the following columns regardless of storage
// type
// scanned:
// - id
// - info_type
// - likelihood
// - byte size of finding
// - quote
// - timestamp
//
// For Cloud Storage the next columns are:
//
// - file_path
// - start_offset
//
// For Cloud Datastore the next columns are:
//
// - project_id
// - namespace_id
// - path
// - column_name
// - offset
//
// For BigQuery the next columns are:
//
// - row_number
// - project_id
// - dataset_id
// - table_id
2017-08-05 18:17:15 +00:00
StoragePath *GooglePrivacyDlpV2beta1CloudStoragePath `json:"storagePath,omitempty"`
// Table: Store findings in a new table in the dataset.
Table *GooglePrivacyDlpV2beta1BigQueryTable `json:"table,omitempty"`
// ForceSendFields is a list of field names (e.g. "StoragePath") 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. "StoragePath") 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 (s *GooglePrivacyDlpV2beta1OutputStorageConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1OutputStorageConfig
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1PartitionId: Datastore partition ID.
// A partition ID identifies a grouping of entities. The grouping is
// always
// by project and namespace, however the namespace ID may be empty.
//
// A partition ID contains several dimensions:
// project ID and namespace ID.
type GooglePrivacyDlpV2beta1PartitionId struct {
// NamespaceId: If not empty, the ID of the namespace to which the
// entities belong.
NamespaceId string `json:"namespaceId,omitempty"`
// ProjectId: The ID of the project to which the entities belong.
ProjectId string `json:"projectId,omitempty"`
// ForceSendFields is a list of field names (e.g. "NamespaceId") 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. "NamespaceId") 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 (s *GooglePrivacyDlpV2beta1PartitionId) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1PartitionId
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1PathElement: A (kind, ID/name) pair used to
// construct a key path.
//
// If either name or ID is set, the element is complete.
// If neither is set, the element is incomplete.
type GooglePrivacyDlpV2beta1PathElement struct {
// Id: The auto-allocated ID of the entity.
// Never equal to zero. Values less than zero are discouraged and may
// not
// be supported in the future.
Id int64 `json:"id,omitempty,string"`
// Kind: The kind of the entity.
// A kind matching regex `__.*__` is reserved/read-only.
// A kind must not contain more than 1500 bytes when UTF-8
// encoded.
// Cannot be "".
Kind string `json:"kind,omitempty"`
// Name: The name of the entity.
// A name matching regex `__.*__` is reserved/read-only.
// A name must not be more than 1500 bytes when UTF-8 encoded.
// Cannot be "".
Name string `json:"name,omitempty"`
// ForceSendFields is a list of field names (e.g. "Id") 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. "Id") 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 (s *GooglePrivacyDlpV2beta1PathElement) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1PathElement
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1PrimitiveTransformation: A rule for
// transforming a value.
type GooglePrivacyDlpV2beta1PrimitiveTransformation struct {
BucketingConfig *GooglePrivacyDlpV2beta1BucketingConfig `json:"bucketingConfig,omitempty"`
CharacterMaskConfig *GooglePrivacyDlpV2beta1CharacterMaskConfig `json:"characterMaskConfig,omitempty"`
CryptoHashConfig *GooglePrivacyDlpV2beta1CryptoHashConfig `json:"cryptoHashConfig,omitempty"`
CryptoReplaceFfxFpeConfig *GooglePrivacyDlpV2beta1CryptoReplaceFfxFpeConfig `json:"cryptoReplaceFfxFpeConfig,omitempty"`
FixedSizeBucketingConfig *GooglePrivacyDlpV2beta1FixedSizeBucketingConfig `json:"fixedSizeBucketingConfig,omitempty"`
RedactConfig *GooglePrivacyDlpV2beta1RedactConfig `json:"redactConfig,omitempty"`
ReplaceConfig *GooglePrivacyDlpV2beta1ReplaceValueConfig `json:"replaceConfig,omitempty"`
ReplaceWithInfoTypeConfig *GooglePrivacyDlpV2beta1ReplaceWithInfoTypeConfig `json:"replaceWithInfoTypeConfig,omitempty"`
TimePartConfig *GooglePrivacyDlpV2beta1TimePartConfig `json:"timePartConfig,omitempty"`
// ForceSendFields is a list of field names (e.g. "BucketingConfig") 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. "BucketingConfig") 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 (s *GooglePrivacyDlpV2beta1PrimitiveTransformation) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1PrimitiveTransformation
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1PrivacyMetric: Privacy metric to compute for
// reidentification risk analysis.
type GooglePrivacyDlpV2beta1PrivacyMetric struct {
CategoricalStatsConfig *GooglePrivacyDlpV2beta1CategoricalStatsConfig `json:"categoricalStatsConfig,omitempty"`
KAnonymityConfig *GooglePrivacyDlpV2beta1KAnonymityConfig `json:"kAnonymityConfig,omitempty"`
KMapEstimationConfig *GooglePrivacyDlpV2beta1KMapEstimationConfig `json:"kMapEstimationConfig,omitempty"`
2017-09-21 15:48:45 +00:00
LDiversityConfig *GooglePrivacyDlpV2beta1LDiversityConfig `json:"lDiversityConfig,omitempty"`
NumericalStatsConfig *GooglePrivacyDlpV2beta1NumericalStatsConfig `json:"numericalStatsConfig,omitempty"`
// ForceSendFields is a list of field names (e.g.
// "CategoricalStatsConfig") 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. "CategoricalStatsConfig")
// 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 (s *GooglePrivacyDlpV2beta1PrivacyMetric) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1PrivacyMetric
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1Projection: A representation of a Datastore
// property in a projection.
type GooglePrivacyDlpV2beta1Projection struct {
// Property: The property to project.
Property *GooglePrivacyDlpV2beta1PropertyReference `json:"property,omitempty"`
// ForceSendFields is a list of field names (e.g. "Property") 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. "Property") 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 (s *GooglePrivacyDlpV2beta1Projection) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Projection
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1PropertyReference: A reference to a property
// relative to the Datastore kind expressions.
type GooglePrivacyDlpV2beta1PropertyReference struct {
// Name: The name of the property.
// If name includes "."s, it may be interpreted as a property name path.
Name string `json:"name,omitempty"`
// ForceSendFields is a list of field names (e.g. "Name") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "Name") to include in API
// requests with the JSON null value. By default, fields with empty
// values are omitted from API requests. However, any field with an
// empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1PropertyReference) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1PropertyReference
raw := NoMethod(*s)
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1QuasiIdField: A quasi-identifier column has a
// custom_tag, used to know which column
// in the data corresponds to which column in the statistical model.
type GooglePrivacyDlpV2beta1QuasiIdField struct {
CustomTag string `json:"customTag,omitempty"`
Field *GooglePrivacyDlpV2beta1FieldId `json:"field,omitempty"`
// ForceSendFields is a list of field names (e.g. "CustomTag") 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. "CustomTag") 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 (s *GooglePrivacyDlpV2beta1QuasiIdField) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1QuasiIdField
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1Range: Generic half-open interval [start, end)
type GooglePrivacyDlpV2beta1Range struct {
// End: Index of the last character of the range (exclusive).
End int64 `json:"end,omitempty,string"`
// Start: Index of the first character of the range (inclusive).
Start int64 `json:"start,omitempty,string"`
// ForceSendFields is a list of field names (e.g. "End") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "End") to include in API
// requests with the JSON null value. By default, fields with empty
// values are omitted from API requests. However, any field with an
// empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1Range) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Range
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-10-22 08:07:36 +00:00
// GooglePrivacyDlpV2beta1RecordCondition: A condition for determining
2017-09-21 15:48:45 +00:00
// whether a transformation should be applied to
// a field.
type GooglePrivacyDlpV2beta1RecordCondition struct {
Expressions *GooglePrivacyDlpV2beta1Expressions `json:"expressions,omitempty"`
2017-08-05 18:17:15 +00:00
2017-09-21 15:48:45 +00:00
// ForceSendFields is a list of field names (e.g. "Expressions") to
2017-08-05 18:17:15 +00:00
// 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:"-"`
2017-09-21 15:48:45 +00:00
// NullFields is a list of field names (e.g. "Expressions") 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
2017-08-05 18:17:15 +00:00
// 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:"-"`
}
2017-09-21 15:48:45 +00:00
func (s *GooglePrivacyDlpV2beta1RecordCondition) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1RecordCondition
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1RecordKey: Message for a unique key indicating
// a record that contains a finding.
type GooglePrivacyDlpV2beta1RecordKey struct {
BigQueryKey *GooglePrivacyDlpV2beta1BigQueryKey `json:"bigQueryKey,omitempty"`
2017-08-05 18:17:15 +00:00
CloudStorageKey *GooglePrivacyDlpV2beta1CloudStorageKey `json:"cloudStorageKey,omitempty"`
DatastoreKey *GooglePrivacyDlpV2beta1DatastoreKey `json:"datastoreKey,omitempty"`
// ForceSendFields is a list of field names (e.g. "BigQueryKey") to
2017-08-05 18:17:15 +00:00
// 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. "BigQueryKey") 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.
2017-08-05 18:17:15 +00:00
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1RecordKey) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1RecordKey
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1RecordSuppression: Configuration to suppress
// records whose suppression conditions evaluate to
// true.
type GooglePrivacyDlpV2beta1RecordSuppression struct {
Condition *GooglePrivacyDlpV2beta1RecordCondition `json:"condition,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:"-"`
}
func (s *GooglePrivacyDlpV2beta1RecordSuppression) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1RecordSuppression
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1RecordTransformations: A type of
// transformation that is applied over structured data such as a
// table.
type GooglePrivacyDlpV2beta1RecordTransformations struct {
// FieldTransformations: Transform the record by applying various field
// transformations.
FieldTransformations []*GooglePrivacyDlpV2beta1FieldTransformation `json:"fieldTransformations,omitempty"`
// RecordSuppressions: Configuration defining which records get
// suppressed entirely. Records that
// match any suppression rule are omitted from the output [optional].
RecordSuppressions []*GooglePrivacyDlpV2beta1RecordSuppression `json:"recordSuppressions,omitempty"`
// ForceSendFields is a list of field names (e.g.
// "FieldTransformations") 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. "FieldTransformations") 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 (s *GooglePrivacyDlpV2beta1RecordTransformations) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1RecordTransformations
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1RedactConfig: Redact a given value. For
// example, if used with an `InfoTypeTransformation`
// transforming PHONE_NUMBER, and input 'My phone number is
// 206-555-0123', the
// output would be 'My phone number is '.
type GooglePrivacyDlpV2beta1RedactConfig struct {
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1RedactContentRequest: Request to search for
// potentially sensitive info in a list of items
// and replace it with a default or provided content.
type GooglePrivacyDlpV2beta1RedactContentRequest struct {
// ImageRedactionConfigs: The configuration for specifying what content
// to redact from images.
ImageRedactionConfigs []*GooglePrivacyDlpV2beta1ImageRedactionConfig `json:"imageRedactionConfigs,omitempty"`
// InspectConfig: Configuration for the inspector.
InspectConfig *GooglePrivacyDlpV2beta1InspectConfig `json:"inspectConfig,omitempty"`
// Items: The list of items to inspect. Up to 100 are allowed per
// request.
Items []*GooglePrivacyDlpV2beta1ContentItem `json:"items,omitempty"`
// ReplaceConfigs: The strings to replace findings text findings with.
// Must specify at least
// one of these or one ImageRedactionConfig if redacting images.
ReplaceConfigs []*GooglePrivacyDlpV2beta1ReplaceConfig `json:"replaceConfigs,omitempty"`
// ForceSendFields is a list of field names (e.g.
// "ImageRedactionConfigs") 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. "ImageRedactionConfigs") 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 (s *GooglePrivacyDlpV2beta1RedactContentRequest) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1RedactContentRequest
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1RedactContentResponse: Results of redacting a
// list of items.
type GooglePrivacyDlpV2beta1RedactContentResponse struct {
// Items: The redacted content.
Items []*GooglePrivacyDlpV2beta1ContentItem `json:"items,omitempty"`
// ServerResponse contains the HTTP response code and headers from the
// server.
googleapi.ServerResponse `json:"-"`
// ForceSendFields is a list of field names (e.g. "Items") 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. "Items") 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 (s *GooglePrivacyDlpV2beta1RedactContentResponse) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1RedactContentResponse
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
type GooglePrivacyDlpV2beta1ReplaceConfig struct {
// InfoType: Type of information to replace. Only one ReplaceConfig per
// info_type
// should be provided. If ReplaceConfig does not have an info_type, the
// DLP
// API matches it against all info_types that are found but not
// specified in
// another ReplaceConfig.
InfoType *GooglePrivacyDlpV2beta1InfoType `json:"infoType,omitempty"`
// ReplaceWith: Content replacing sensitive information of given type.
// Max 256 chars.
ReplaceWith string `json:"replaceWith,omitempty"`
// ForceSendFields is a list of field names (e.g. "InfoType") 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. "InfoType") 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 (s *GooglePrivacyDlpV2beta1ReplaceConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1ReplaceConfig
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1ReplaceValueConfig: Replace each input value
// with a given `Value`.
type GooglePrivacyDlpV2beta1ReplaceValueConfig struct {
// NewValue: Value to replace it with.
NewValue *GooglePrivacyDlpV2beta1Value `json:"newValue,omitempty"`
// ForceSendFields is a list of field names (e.g. "NewValue") 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. "NewValue") 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 (s *GooglePrivacyDlpV2beta1ReplaceValueConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1ReplaceValueConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1ReplaceWithInfoTypeConfig: Replace each
// matching finding with the name of the info_type.
type GooglePrivacyDlpV2beta1ReplaceWithInfoTypeConfig struct {
}
// GooglePrivacyDlpV2beta1RiskAnalysisOperationMetadata: Metadata
// returned within
// the
// [`riskAnalysis.operations.get`](/dlp/docs/reference/rest/v2beta1/r
// iskAnalysis.operations/get)
// for risk analysis.
type GooglePrivacyDlpV2beta1RiskAnalysisOperationMetadata struct {
// CreateTime: The time which this request was started.
CreateTime string `json:"createTime,omitempty"`
// RequestedPrivacyMetric: Privacy metric to compute.
RequestedPrivacyMetric *GooglePrivacyDlpV2beta1PrivacyMetric `json:"requestedPrivacyMetric,omitempty"`
// RequestedSourceTable: Input dataset to compute metrics over.
RequestedSourceTable *GooglePrivacyDlpV2beta1BigQueryTable `json:"requestedSourceTable,omitempty"`
// ForceSendFields is a list of field names (e.g. "CreateTime") to
// unconditionally include in API requests. By default, fields with
// empty values are omitted from API requests. However, any non-pointer,
// non-interface field appearing in ForceSendFields will be sent to the
// server regardless of whether the field is empty or not. This may be
// used to include empty fields in Patch requests.
ForceSendFields []string `json:"-"`
// NullFields is a list of field names (e.g. "CreateTime") to include in
// API requests with the JSON null value. By default, fields with empty
// values are omitted from API requests. However, any field with an
// empty value appearing in NullFields will be sent to the server as
// null. It is an error if a field in this list has a non-empty value.
// This may be used to include null fields in Patch requests.
NullFields []string `json:"-"`
}
func (s *GooglePrivacyDlpV2beta1RiskAnalysisOperationMetadata) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1RiskAnalysisOperationMetadata
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1RiskAnalysisOperationResult: Result of a risk
// analysis
// [`Operation`](/dlp/docs/reference/rest/v2beta1/inspect.operat
// ions)
// request.
type GooglePrivacyDlpV2beta1RiskAnalysisOperationResult struct {
CategoricalStatsResult *GooglePrivacyDlpV2beta1CategoricalStatsResult `json:"categoricalStatsResult,omitempty"`
KAnonymityResult *GooglePrivacyDlpV2beta1KAnonymityResult `json:"kAnonymityResult,omitempty"`
KMapEstimationResult *GooglePrivacyDlpV2beta1KMapEstimationResult `json:"kMapEstimationResult,omitempty"`
2017-09-21 15:48:45 +00:00
LDiversityResult *GooglePrivacyDlpV2beta1LDiversityResult `json:"lDiversityResult,omitempty"`
NumericalStatsResult *GooglePrivacyDlpV2beta1NumericalStatsResult `json:"numericalStatsResult,omitempty"`
// ForceSendFields is a list of field names (e.g.
// "CategoricalStatsResult") 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. "CategoricalStatsResult")
// 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 (s *GooglePrivacyDlpV2beta1RiskAnalysisOperationResult) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1RiskAnalysisOperationResult
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-13 12:09:48 +00:00
type GooglePrivacyDlpV2beta1Row struct {
Values []*GooglePrivacyDlpV2beta1Value `json:"values,omitempty"`
// ForceSendFields is a list of field names (e.g. "Values") 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. "Values") 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 (s *GooglePrivacyDlpV2beta1Row) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Row
raw := NoMethod(*s)
2017-09-13 12:09:48 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GooglePrivacyDlpV2beta1StorageConfig: Shared message indicating Cloud
// storage type.
type GooglePrivacyDlpV2beta1StorageConfig struct {
// BigQueryOptions: BigQuery options specification.
BigQueryOptions *GooglePrivacyDlpV2beta1BigQueryOptions `json:"bigQueryOptions,omitempty"`
// CloudStorageOptions: Google Cloud Storage options specification.
CloudStorageOptions *GooglePrivacyDlpV2beta1CloudStorageOptions `json:"cloudStorageOptions,omitempty"`
// DatastoreOptions: Google Cloud Datastore options specification.
DatastoreOptions *GooglePrivacyDlpV2beta1DatastoreOptions `json:"datastoreOptions,omitempty"`
// ForceSendFields is a list of field names (e.g. "BigQueryOptions") 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. "BigQueryOptions") 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:"-"`
}
2017-09-21 15:48:45 +00:00
func (s *GooglePrivacyDlpV2beta1StorageConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1StorageConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1SummaryResult: A collection that informs the
// user the number of times a particular
// `TransformationResultCode` and error details occurred.
type GooglePrivacyDlpV2beta1SummaryResult struct {
// Possible values:
// "TRANSFORMATION_RESULT_CODE_UNSPECIFIED"
// "SUCCESS"
// "ERROR"
Code string `json:"code,omitempty"`
Count int64 `json:"count,omitempty,string"`
// Details: A place for warnings or errors to show up if a
// transformation didn't
// work as expected.
Details string `json:"details,omitempty"`
// ForceSendFields is a list of field names (e.g. "Code") 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. "Code") 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 (s *GooglePrivacyDlpV2beta1SummaryResult) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1SummaryResult
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1SurrogateType: Message for detecting output
// from deidentification transformations
// such
// as
// [`CryptoReplaceFfxFpeConfig`](/dlp/docs/reference/rest/v2beta1/cont
// ent/deidentify#CryptoReplaceFfxFpeConfig).
// These types of transformations are
// those that perform pseudonymization, thereby producing a "surrogate"
// as
// output. This should be used in conjunction with a field on
// the
// transformation such as `surrogate_info_type`. This custom info type
// does
// not support the use of `detection_rules`.
type GooglePrivacyDlpV2beta1SurrogateType struct {
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1Table: Structured content to inspect. Up to
// 50,000 `Value`s per request allowed.
type GooglePrivacyDlpV2beta1Table struct {
Headers []*GooglePrivacyDlpV2beta1FieldId `json:"headers,omitempty"`
Rows []*GooglePrivacyDlpV2beta1Row `json:"rows,omitempty"`
// ForceSendFields is a list of field names (e.g. "Headers") 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. "Headers") 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 (s *GooglePrivacyDlpV2beta1Table) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Table
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1TableLocation: Location of a finding within a
// table.
2017-09-21 15:48:45 +00:00
type GooglePrivacyDlpV2beta1TableLocation struct {
// RowIndex: The zero-based index of the row where the finding is
// located.
RowIndex int64 `json:"rowIndex,omitempty,string"`
// ForceSendFields is a list of field names (e.g. "RowIndex") 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. "RowIndex") 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 (s *GooglePrivacyDlpV2beta1TableLocation) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1TableLocation
raw := NoMethod(*s)
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1TaggedField: A column with a semantic tag
// attached.
type GooglePrivacyDlpV2beta1TaggedField struct {
// CustomTag: A column can be tagged with a custom tag. In this case,
// the user must
// indicate an auxiliary table that contains statistical information
// on
// the possible values of this column (below).
CustomTag string `json:"customTag,omitempty"`
// Field: Identifies the column. [required]
Field *GooglePrivacyDlpV2beta1FieldId `json:"field,omitempty"`
// Inferred: If no semantic tag is indicated, we infer the statistical
// model from
// the distribution of values in the input data
Inferred *GoogleProtobufEmpty `json:"inferred,omitempty"`
// InfoType: A column can be tagged with a InfoType to use the relevant
// public
// dataset as a statistical model of population, if available.
// We
// currently support US ZIP codes, region codes, ages and genders.
InfoType *GooglePrivacyDlpV2beta1InfoType `json:"infoType,omitempty"`
// ForceSendFields is a list of field names (e.g. "CustomTag") 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. "CustomTag") 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 (s *GooglePrivacyDlpV2beta1TaggedField) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1TaggedField
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1TimePartConfig: For use with `Date`,
// `Timestamp`, and `TimeOfDay`, extract or preserve a
// portion of the value.
type GooglePrivacyDlpV2beta1TimePartConfig struct {
// Possible values:
// "TIME_PART_UNSPECIFIED"
// "YEAR" - [000-9999]
// "MONTH" - [1-12]
// "DAY_OF_MONTH" - [1-31]
// "DAY_OF_WEEK" - [1-7]
// "WEEK_OF_YEAR" - [1-52]
// "HOUR_OF_DAY" - [0-24]
PartToExtract string `json:"partToExtract,omitempty"`
// ForceSendFields is a list of field names (e.g. "PartToExtract") 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. "PartToExtract") 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 (s *GooglePrivacyDlpV2beta1TimePartConfig) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1TimePartConfig
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1TransformationSummary: Summary of a single
// tranformation.
// Only one of 'transformation', 'field_transformation', or
// 'record_suppress'
// will be set.
2017-09-21 15:48:45 +00:00
type GooglePrivacyDlpV2beta1TransformationSummary struct {
// Field: Set if the transformation was limited to a specific FieldId.
Field *GooglePrivacyDlpV2beta1FieldId `json:"field,omitempty"`
// FieldTransformations: The field transformation that was applied.
// If multiple field transformations are requested for a single
// field,
// this list will contain all of them; otherwise, only one is supplied.
2017-09-21 15:48:45 +00:00
FieldTransformations []*GooglePrivacyDlpV2beta1FieldTransformation `json:"fieldTransformations,omitempty"`
// InfoType: Set if the transformation was limited to a specific
// info_type.
InfoType *GooglePrivacyDlpV2beta1InfoType `json:"infoType,omitempty"`
// RecordSuppress: The specific suppression option these stats apply to.
RecordSuppress *GooglePrivacyDlpV2beta1RecordSuppression `json:"recordSuppress,omitempty"`
Results []*GooglePrivacyDlpV2beta1SummaryResult `json:"results,omitempty"`
// Transformation: The specific transformation these stats apply to.
Transformation *GooglePrivacyDlpV2beta1PrimitiveTransformation `json:"transformation,omitempty"`
// TransformedBytes: Total size in bytes that were transformed in some
// way.
TransformedBytes int64 `json:"transformedBytes,omitempty,string"`
2017-09-21 15:48:45 +00:00
// ForceSendFields is a list of field names (e.g. "Field") 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. "Field") 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 (s *GooglePrivacyDlpV2beta1TransformationSummary) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1TransformationSummary
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1TransientCryptoKey: Use this to have a random
// data crypto key generated.
// It will be discarded after the operation/request finishes.
type GooglePrivacyDlpV2beta1TransientCryptoKey struct {
// Name: Name of the key. [required]
// This is an arbitrary string used to differentiate different keys.
// A unique key is generated per name: two separate
// `TransientCryptoKey`
// protos share the same generated key if their names are the same.
// When the data crypto key is generated, this name is not used in any
// way
// (repeating the api call will result in a different key being
// generated).
Name string `json:"name,omitempty"`
2017-09-13 12:09:48 +00:00
2017-09-21 15:48:45 +00:00
// ForceSendFields is a list of field names (e.g. "Name") to
2017-09-13 12:09:48 +00:00
// 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:"-"`
2017-09-21 15:48:45 +00:00
// 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
2017-09-13 12:09:48 +00:00
// 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:"-"`
}
2017-09-21 15:48:45 +00:00
func (s *GooglePrivacyDlpV2beta1TransientCryptoKey) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1TransientCryptoKey
raw := NoMethod(*s)
2017-09-13 12:09:48 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1UnwrappedCryptoKey: Using raw keys is prone to
// security risks due to accidentally
// leaking the key. Choose another type of key if possible.
type GooglePrivacyDlpV2beta1UnwrappedCryptoKey struct {
// Key: The AES 128/192/256 bit key. [required]
Key string `json:"key,omitempty"`
2017-09-13 12:09:48 +00:00
2017-09-21 15:48:45 +00:00
// ForceSendFields is a list of field names (e.g. "Key") to
2017-09-13 12:09:48 +00:00
// 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:"-"`
2017-09-21 15:48:45 +00:00
// NullFields is a list of field names (e.g. "Key") to include in API
// requests with the JSON null value. By default, fields with empty
2017-09-13 12:09:48 +00:00
// 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:"-"`
}
2017-09-21 15:48:45 +00:00
func (s *GooglePrivacyDlpV2beta1UnwrappedCryptoKey) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1UnwrappedCryptoKey
raw := NoMethod(*s)
2017-09-13 12:09:48 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GooglePrivacyDlpV2beta1Value: Set of primitive values supported by
// the system.
// Note that for the purposes of inspection or transformation, the
// number
// of bytes considered to comprise a 'Value' is based on its
// representation
// as a UTF-8 encoded string. For example, if 'integer_value' is set
// to
// 123456789, the number of bytes would be counted as 9, even though
// an
// int64 only holds up to 8 bytes of data.
2017-09-13 12:09:48 +00:00
type GooglePrivacyDlpV2beta1Value struct {
BooleanValue bool `json:"booleanValue,omitempty"`
DateValue *GoogleTypeDate `json:"dateValue,omitempty"`
FloatValue float64 `json:"floatValue,omitempty"`
IntegerValue int64 `json:"integerValue,omitempty,string"`
StringValue string `json:"stringValue,omitempty"`
TimeValue *GoogleTypeTimeOfDay `json:"timeValue,omitempty"`
TimestampValue string `json:"timestampValue,omitempty"`
// ForceSendFields is a list of field names (e.g. "BooleanValue") 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. "BooleanValue") 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 (s *GooglePrivacyDlpV2beta1Value) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1Value
raw := NoMethod(*s)
2017-09-13 12:09:48 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
func (s *GooglePrivacyDlpV2beta1Value) UnmarshalJSON(data []byte) error {
type NoMethod GooglePrivacyDlpV2beta1Value
2017-09-13 12:09:48 +00:00
var s1 struct {
FloatValue gensupport.JSONFloat64 `json:"floatValue"`
*NoMethod
2017-09-13 12:09:48 +00:00
}
s1.NoMethod = (*NoMethod)(s)
2017-09-13 12:09:48 +00:00
if err := json.Unmarshal(data, &s1); err != nil {
return err
}
s.FloatValue = float64(s1.FloatValue)
return nil
}
2017-09-21 15:48:45 +00:00
// GooglePrivacyDlpV2beta1ValueFrequency: A value of a field, including
// its frequency.
type GooglePrivacyDlpV2beta1ValueFrequency struct {
// Count: How many times the value is contained in the field.
Count int64 `json:"count,omitempty,string"`
// Value: A value contained in the field in question.
Value *GooglePrivacyDlpV2beta1Value `json:"value,omitempty"`
// ForceSendFields is a list of field names (e.g. "Count") 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. "Count") 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 (s *GooglePrivacyDlpV2beta1ValueFrequency) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1ValueFrequency
raw := NoMethod(*s)
2017-09-21 15:48:45 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-10-22 08:07:36 +00:00
// GooglePrivacyDlpV2beta1WordList: Message defining a list of words or
// phrases to search for in the data.
type GooglePrivacyDlpV2beta1WordList struct {
// Words: Words or phrases defining the dictionary. The dictionary must
// contain
// at least one phrase and every phrase must contain at least 2
// characters
// that are letters or digits. [required]
Words []string `json:"words,omitempty"`
// ForceSendFields is a list of field names (e.g. "Words") 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. "Words") 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 (s *GooglePrivacyDlpV2beta1WordList) MarshalJSON() ([]byte, error) {
type NoMethod GooglePrivacyDlpV2beta1WordList
raw := NoMethod(*s)
2017-10-22 08:07:36 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-08-05 18:17:15 +00:00
// GoogleProtobufEmpty: 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 GoogleProtobufEmpty struct {
// ServerResponse contains the HTTP response code and headers from the
// server.
googleapi.ServerResponse `json:"-"`
}
// GoogleRpcStatus: The `Status` type defines a logical error model that
// is suitable for different
// programming environments, including REST APIs and RPC APIs. It is
// used by
// [gRPC](https://github.com/grpc). The error model is designed to
// be:
//
// - Simple to use and understand for most users
// - Flexible enough to meet unexpected needs
//
// # Overview
//
// The `Status` message contains three pieces of data: error code, error
// message,
// and error details. The error code should be an enum value
// of
// google.rpc.Code, but it may accept additional error codes if needed.
// The
// error message should be a developer-facing English message that
// helps
// developers *understand* and *resolve* the error. If a localized
// user-facing
// error message is needed, put the localized message in the error
// details or
// localize it in the client. The optional error details may contain
// arbitrary
// information about the error. There is a predefined set of error
// detail types
// in the package `google.rpc` that can be used for common error
// conditions.
//
// # Language mapping
//
// The `Status` message is the logical representation of the error
// model, but it
// is not necessarily the actual wire format. When the `Status` message
// is
// exposed in different client libraries and different wire protocols,
// it can be
// mapped differently. For example, it will likely be mapped to some
// exceptions
// in Java, but more likely mapped to some error codes in C.
//
// # Other uses
//
// The error model and the `Status` message can be used in a variety
// of
// environments, either with or without APIs, to provide a
// consistent developer experience across different
// environments.
//
// Example uses of this error model include:
//
// - Partial errors. If a service needs to return partial errors to the
// client,
// it may embed the `Status` in the normal response to indicate the
// partial
// errors.
//
// - Workflow errors. A typical workflow has multiple steps. Each step
// may
// have a `Status` message for error reporting.
//
// - Batch operations. If a client uses batch request and batch
// response, the
// `Status` message should be used directly inside batch response,
// one for
// each error sub-response.
//
// - Asynchronous operations. If an API call embeds asynchronous
// operation
// results in its response, the status of those operations should
// be
// represented directly using the `Status` message.
//
// - Logging. If some API errors are stored in logs, the message
// `Status` could
// be used directly after any stripping needed for security/privacy
// reasons.
type GoogleRpcStatus struct {
// Code: The status code, which should be an enum value of
// google.rpc.Code.
Code int64 `json:"code,omitempty"`
// Details: A list of messages that carry the error details. There is a
// common set of
// message types for APIs to use.
Details []googleapi.RawMessage `json:"details,omitempty"`
// Message: A developer-facing error message, which should be in
// English. Any
// user-facing error message should be localized and sent in
// the
// google.rpc.Status.details field, or localized by the client.
Message string `json:"message,omitempty"`
// ForceSendFields is a list of field names (e.g. "Code") 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. "Code") 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 (s *GoogleRpcStatus) MarshalJSON() ([]byte, error) {
type NoMethod GoogleRpcStatus
raw := NoMethod(*s)
2017-08-05 18:17:15 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-13 12:09:48 +00:00
// GoogleTypeDate: Represents a whole calendar date, e.g. date of birth.
// The time of day and
// time zone are either specified elsewhere or are not significant. The
// date
// is relative to the Proleptic Gregorian Calendar. The day may be 0
// to
// represent a year and month where the day is not significant, e.g.
// credit card
// expiration date. The year may be 0 to represent a month and day
// independent
// of year, e.g. anniversary date. Related types are
// google.type.TimeOfDay
// and `google.protobuf.Timestamp`.
type GoogleTypeDate struct {
// Day: Day of month. Must be from 1 to 31 and valid for the year and
// month, or 0
// if specifying a year/month where the day is not significant.
Day int64 `json:"day,omitempty"`
// Month: Month of year. Must be from 1 to 12.
Month int64 `json:"month,omitempty"`
// Year: Year of date. Must be from 1 to 9999, or 0 if specifying a date
// without
// a year.
Year int64 `json:"year,omitempty"`
// ForceSendFields is a list of field names (e.g. "Day") 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. "Day") 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 (s *GoogleTypeDate) MarshalJSON() ([]byte, error) {
type NoMethod GoogleTypeDate
raw := NoMethod(*s)
2017-09-13 12:09:48 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
// GoogleTypeTimeOfDay: Represents a time of day. The date and time zone
// are either not significant
// or are specified elsewhere. An API may choose to allow leap seconds.
// Related
// types are google.type.Date and `google.protobuf.Timestamp`.
type GoogleTypeTimeOfDay struct {
// Hours: Hours of day in 24 hour format. Should be from 0 to 23. An API
// may choose
// to allow the value "24:00:00" for scenarios like business closing
// time.
Hours int64 `json:"hours,omitempty"`
// Minutes: Minutes of hour of day. Must be from 0 to 59.
Minutes int64 `json:"minutes,omitempty"`
// Nanos: Fractions of seconds in nanoseconds. Must be from 0 to
// 999,999,999.
Nanos int64 `json:"nanos,omitempty"`
// Seconds: Seconds of minutes of the time. Must normally be from 0 to
// 59. An API may
// allow the value 60 if it allows leap-seconds.
Seconds int64 `json:"seconds,omitempty"`
// ForceSendFields is a list of field names (e.g. "Hours") 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. "Hours") 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 (s *GoogleTypeTimeOfDay) MarshalJSON() ([]byte, error) {
type NoMethod GoogleTypeTimeOfDay
raw := NoMethod(*s)
2017-09-13 12:09:48 +00:00
return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
}
2017-09-21 15:48:45 +00:00
// method id "dlp.content.deidentify":
type ContentDeidentifyCall struct {
s *Service
googleprivacydlpv2beta1deidentifycontentrequest *GooglePrivacyDlpV2beta1DeidentifyContentRequest
urlParams_ gensupport.URLParams
ctx_ context.Context
header_ http.Header
}
// Deidentify: De-identifies potentially sensitive info from a list of
// strings.
// This method has limits on input size and output size.
func (r *ContentService) Deidentify(googleprivacydlpv2beta1deidentifycontentrequest *GooglePrivacyDlpV2beta1DeidentifyContentRequest) *ContentDeidentifyCall {
c := &ContentDeidentifyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.googleprivacydlpv2beta1deidentifycontentrequest = googleprivacydlpv2beta1deidentifycontentrequest
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *ContentDeidentifyCall) Fields(s ...googleapi.Field) *ContentDeidentifyCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *ContentDeidentifyCall) Context(ctx context.Context) *ContentDeidentifyCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *ContentDeidentifyCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *ContentDeidentifyCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleprivacydlpv2beta1deidentifycontentrequest)
if err != nil {
return nil, err
}
reqHeaders.Set("Content-Type", "application/json")
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/content:deidentify")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("POST", urls, body)
req.Header = reqHeaders
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.content.deidentify" call.
// Exactly one of *GooglePrivacyDlpV2beta1DeidentifyContentResponse or
// error will be non-nil. Any non-2xx status code is an error. Response
// headers are in either
// *GooglePrivacyDlpV2beta1DeidentifyContentResponse.ServerResponse.Heade
// r or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was
// returned.
func (c *ContentDeidentifyCall) Do(opts ...googleapi.CallOption) (*GooglePrivacyDlpV2beta1DeidentifyContentResponse, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GooglePrivacyDlpV2beta1DeidentifyContentResponse{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-09-21 15:48:45 +00:00
return nil, err
}
return ret, nil
// {
// "description": "De-identifies potentially sensitive info from a list of strings.\nThis method has limits on input size and output size.",
// "flatPath": "v2beta1/content:deidentify",
// "httpMethod": "POST",
// "id": "dlp.content.deidentify",
// "parameterOrder": [],
// "parameters": {},
// "path": "v2beta1/content:deidentify",
// "request": {
// "$ref": "GooglePrivacyDlpV2beta1DeidentifyContentRequest"
// },
// "response": {
// "$ref": "GooglePrivacyDlpV2beta1DeidentifyContentResponse"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
2017-08-05 18:17:15 +00:00
// method id "dlp.content.inspect":
type ContentInspectCall struct {
s *Service
googleprivacydlpv2beta1inspectcontentrequest *GooglePrivacyDlpV2beta1InspectContentRequest
urlParams_ gensupport.URLParams
ctx_ context.Context
header_ http.Header
}
// Inspect: Finds potentially sensitive info in a list of strings.
// This method has limits on input size, processing time, and output
// size.
func (r *ContentService) Inspect(googleprivacydlpv2beta1inspectcontentrequest *GooglePrivacyDlpV2beta1InspectContentRequest) *ContentInspectCall {
c := &ContentInspectCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.googleprivacydlpv2beta1inspectcontentrequest = googleprivacydlpv2beta1inspectcontentrequest
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *ContentInspectCall) Fields(s ...googleapi.Field) *ContentInspectCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *ContentInspectCall) Context(ctx context.Context) *ContentInspectCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *ContentInspectCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *ContentInspectCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleprivacydlpv2beta1inspectcontentrequest)
if err != nil {
return nil, err
}
reqHeaders.Set("Content-Type", "application/json")
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/content:inspect")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("POST", urls, body)
req.Header = reqHeaders
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.content.inspect" call.
// Exactly one of *GooglePrivacyDlpV2beta1InspectContentResponse or
// error will be non-nil. Any non-2xx status code is an error. Response
// headers are in either
// *GooglePrivacyDlpV2beta1InspectContentResponse.ServerResponse.Header
// or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was
// returned.
func (c *ContentInspectCall) Do(opts ...googleapi.CallOption) (*GooglePrivacyDlpV2beta1InspectContentResponse, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GooglePrivacyDlpV2beta1InspectContentResponse{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-08-05 18:17:15 +00:00
return nil, err
}
return ret, nil
// {
// "description": "Finds potentially sensitive info in a list of strings.\nThis method has limits on input size, processing time, and output size.",
// "flatPath": "v2beta1/content:inspect",
// "httpMethod": "POST",
// "id": "dlp.content.inspect",
// "parameterOrder": [],
// "parameters": {},
// "path": "v2beta1/content:inspect",
// "request": {
// "$ref": "GooglePrivacyDlpV2beta1InspectContentRequest"
// },
// "response": {
// "$ref": "GooglePrivacyDlpV2beta1InspectContentResponse"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// method id "dlp.content.redact":
type ContentRedactCall struct {
s *Service
googleprivacydlpv2beta1redactcontentrequest *GooglePrivacyDlpV2beta1RedactContentRequest
urlParams_ gensupport.URLParams
ctx_ context.Context
header_ http.Header
}
// Redact: Redacts potentially sensitive info from a list of
// strings.
// This method has limits on input size, processing time, and output
// size.
func (r *ContentService) Redact(googleprivacydlpv2beta1redactcontentrequest *GooglePrivacyDlpV2beta1RedactContentRequest) *ContentRedactCall {
c := &ContentRedactCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.googleprivacydlpv2beta1redactcontentrequest = googleprivacydlpv2beta1redactcontentrequest
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *ContentRedactCall) Fields(s ...googleapi.Field) *ContentRedactCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *ContentRedactCall) Context(ctx context.Context) *ContentRedactCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *ContentRedactCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *ContentRedactCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleprivacydlpv2beta1redactcontentrequest)
if err != nil {
return nil, err
}
reqHeaders.Set("Content-Type", "application/json")
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/content:redact")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("POST", urls, body)
req.Header = reqHeaders
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.content.redact" call.
// Exactly one of *GooglePrivacyDlpV2beta1RedactContentResponse or error
// will be non-nil. Any non-2xx status code is an error. Response
// headers are in either
// *GooglePrivacyDlpV2beta1RedactContentResponse.ServerResponse.Header
// or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was
// returned.
func (c *ContentRedactCall) Do(opts ...googleapi.CallOption) (*GooglePrivacyDlpV2beta1RedactContentResponse, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GooglePrivacyDlpV2beta1RedactContentResponse{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-08-05 18:17:15 +00:00
return nil, err
}
return ret, nil
// {
// "description": "Redacts potentially sensitive info from a list of strings.\nThis method has limits on input size, processing time, and output size.",
// "flatPath": "v2beta1/content:redact",
// "httpMethod": "POST",
// "id": "dlp.content.redact",
// "parameterOrder": [],
// "parameters": {},
// "path": "v2beta1/content:redact",
// "request": {
// "$ref": "GooglePrivacyDlpV2beta1RedactContentRequest"
// },
// "response": {
// "$ref": "GooglePrivacyDlpV2beta1RedactContentResponse"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
2017-09-21 15:48:45 +00:00
// method id "dlp.dataSource.analyze":
type DataSourceAnalyzeCall struct {
s *Service
googleprivacydlpv2beta1analyzedatasourceriskrequest *GooglePrivacyDlpV2beta1AnalyzeDataSourceRiskRequest
urlParams_ gensupport.URLParams
ctx_ context.Context
header_ http.Header
}
// Analyze: Schedules a job to compute risk analysis metrics over
// content in a Google
// Cloud Platform repository.
func (r *DataSourceService) Analyze(googleprivacydlpv2beta1analyzedatasourceriskrequest *GooglePrivacyDlpV2beta1AnalyzeDataSourceRiskRequest) *DataSourceAnalyzeCall {
c := &DataSourceAnalyzeCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.googleprivacydlpv2beta1analyzedatasourceriskrequest = googleprivacydlpv2beta1analyzedatasourceriskrequest
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *DataSourceAnalyzeCall) Fields(s ...googleapi.Field) *DataSourceAnalyzeCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *DataSourceAnalyzeCall) Context(ctx context.Context) *DataSourceAnalyzeCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *DataSourceAnalyzeCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *DataSourceAnalyzeCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleprivacydlpv2beta1analyzedatasourceriskrequest)
if err != nil {
return nil, err
}
reqHeaders.Set("Content-Type", "application/json")
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/dataSource:analyze")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("POST", urls, body)
req.Header = reqHeaders
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.dataSource.analyze" call.
// Exactly one of *GoogleLongrunningOperation or error will be non-nil.
// Any non-2xx status code is an error. Response headers are in either
// *GoogleLongrunningOperation.ServerResponse.Header or (if a response
// was returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was
// because http.StatusNotModified was returned.
func (c *DataSourceAnalyzeCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GoogleLongrunningOperation{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-09-21 15:48:45 +00:00
return nil, err
}
return ret, nil
// {
// "description": "Schedules a job to compute risk analysis metrics over content in a Google\nCloud Platform repository.",
// "flatPath": "v2beta1/dataSource:analyze",
// "httpMethod": "POST",
// "id": "dlp.dataSource.analyze",
// "parameterOrder": [],
// "parameters": {},
// "path": "v2beta1/dataSource:analyze",
// "request": {
// "$ref": "GooglePrivacyDlpV2beta1AnalyzeDataSourceRiskRequest"
// },
// "response": {
// "$ref": "GoogleLongrunningOperation"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
2017-08-05 18:17:15 +00:00
// method id "dlp.inspect.operations.cancel":
type InspectOperationsCancelCall struct {
s *Service
name string
googlelongrunningcanceloperationrequest *GoogleLongrunningCancelOperationRequest
urlParams_ gensupport.URLParams
ctx_ context.Context
header_ http.Header
}
2017-09-21 15:48:45 +00:00
// Cancel: Cancels an operation. Use the `inspect.operations.get` to
// check whether the cancellation succeeded or the operation completed
// despite cancellation.
2017-08-05 18:17:15 +00:00
func (r *InspectOperationsService) Cancel(name string, googlelongrunningcanceloperationrequest *GoogleLongrunningCancelOperationRequest) *InspectOperationsCancelCall {
c := &InspectOperationsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.name = name
c.googlelongrunningcanceloperationrequest = googlelongrunningcanceloperationrequest
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *InspectOperationsCancelCall) Fields(s ...googleapi.Field) *InspectOperationsCancelCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *InspectOperationsCancelCall) Context(ctx context.Context) *InspectOperationsCancelCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *InspectOperationsCancelCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *InspectOperationsCancelCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlelongrunningcanceloperationrequest)
if err != nil {
return nil, err
}
reqHeaders.Set("Content-Type", "application/json")
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+name}:cancel")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("POST", urls, body)
req.Header = reqHeaders
googleapi.Expand(req.URL, map[string]string{
"name": c.name,
})
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.inspect.operations.cancel" call.
// Exactly one of *GoogleProtobufEmpty or error will be non-nil. Any
// non-2xx status code is an error. Response headers are in either
// *GoogleProtobufEmpty.ServerResponse.Header or (if a response was
// returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was
// because http.StatusNotModified was returned.
func (c *InspectOperationsCancelCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GoogleProtobufEmpty{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-08-05 18:17:15 +00:00
return nil, err
}
return ret, nil
// {
2017-09-21 15:48:45 +00:00
// "description": "Cancels an operation. Use the `inspect.operations.get` to check whether the cancellation succeeded or the operation completed despite cancellation.",
2017-08-05 18:17:15 +00:00
// "flatPath": "v2beta1/inspect/operations/{operationsId}:cancel",
// "httpMethod": "POST",
// "id": "dlp.inspect.operations.cancel",
// "parameterOrder": [
// "name"
// ],
// "parameters": {
// "name": {
// "description": "The name of the operation resource to be cancelled.",
// "location": "path",
// "pattern": "^inspect/operations/[^/]+$",
// "required": true,
// "type": "string"
// }
// },
// "path": "v2beta1/{+name}:cancel",
// "request": {
// "$ref": "GoogleLongrunningCancelOperationRequest"
// },
// "response": {
// "$ref": "GoogleProtobufEmpty"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// method id "dlp.inspect.operations.create":
type InspectOperationsCreateCall struct {
s *Service
googleprivacydlpv2beta1createinspectoperationrequest *GooglePrivacyDlpV2beta1CreateInspectOperationRequest
urlParams_ gensupport.URLParams
ctx_ context.Context
header_ http.Header
}
// Create: Schedules a job scanning content in a Google Cloud Platform
// data
// repository.
func (r *InspectOperationsService) Create(googleprivacydlpv2beta1createinspectoperationrequest *GooglePrivacyDlpV2beta1CreateInspectOperationRequest) *InspectOperationsCreateCall {
c := &InspectOperationsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.googleprivacydlpv2beta1createinspectoperationrequest = googleprivacydlpv2beta1createinspectoperationrequest
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *InspectOperationsCreateCall) Fields(s ...googleapi.Field) *InspectOperationsCreateCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *InspectOperationsCreateCall) Context(ctx context.Context) *InspectOperationsCreateCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *InspectOperationsCreateCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *InspectOperationsCreateCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleprivacydlpv2beta1createinspectoperationrequest)
if err != nil {
return nil, err
}
reqHeaders.Set("Content-Type", "application/json")
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/inspect/operations")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("POST", urls, body)
req.Header = reqHeaders
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.inspect.operations.create" call.
// Exactly one of *GoogleLongrunningOperation or error will be non-nil.
// Any non-2xx status code is an error. Response headers are in either
// *GoogleLongrunningOperation.ServerResponse.Header or (if a response
// was returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was
// because http.StatusNotModified was returned.
func (c *InspectOperationsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GoogleLongrunningOperation{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-08-05 18:17:15 +00:00
return nil, err
}
return ret, nil
// {
// "description": "Schedules a job scanning content in a Google Cloud Platform data\nrepository.",
// "flatPath": "v2beta1/inspect/operations",
// "httpMethod": "POST",
// "id": "dlp.inspect.operations.create",
// "parameterOrder": [],
// "parameters": {},
// "path": "v2beta1/inspect/operations",
// "request": {
// "$ref": "GooglePrivacyDlpV2beta1CreateInspectOperationRequest"
// },
// "response": {
// "$ref": "GoogleLongrunningOperation"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// method id "dlp.inspect.operations.delete":
type InspectOperationsDeleteCall struct {
s *Service
name string
urlParams_ gensupport.URLParams
ctx_ context.Context
header_ http.Header
}
// Delete: This method is not supported and the server returns
// `UNIMPLEMENTED`.
func (r *InspectOperationsService) Delete(name string) *InspectOperationsDeleteCall {
c := &InspectOperationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.name = name
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *InspectOperationsDeleteCall) Fields(s ...googleapi.Field) *InspectOperationsDeleteCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *InspectOperationsDeleteCall) Context(ctx context.Context) *InspectOperationsDeleteCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *InspectOperationsDeleteCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *InspectOperationsDeleteCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
var body io.Reader = nil
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+name}")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("DELETE", urls, body)
req.Header = reqHeaders
googleapi.Expand(req.URL, map[string]string{
"name": c.name,
})
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.inspect.operations.delete" call.
// Exactly one of *GoogleProtobufEmpty or error will be non-nil. Any
// non-2xx status code is an error. Response headers are in either
// *GoogleProtobufEmpty.ServerResponse.Header or (if a response was
// returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was
// because http.StatusNotModified was returned.
func (c *InspectOperationsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GoogleProtobufEmpty{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-08-05 18:17:15 +00:00
return nil, err
}
return ret, nil
// {
// "description": "This method is not supported and the server returns `UNIMPLEMENTED`.",
// "flatPath": "v2beta1/inspect/operations/{operationsId}",
// "httpMethod": "DELETE",
// "id": "dlp.inspect.operations.delete",
// "parameterOrder": [
// "name"
// ],
// "parameters": {
// "name": {
// "description": "The name of the operation resource to be deleted.",
// "location": "path",
// "pattern": "^inspect/operations/[^/]+$",
// "required": true,
// "type": "string"
// }
// },
// "path": "v2beta1/{+name}",
// "response": {
// "$ref": "GoogleProtobufEmpty"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// method id "dlp.inspect.operations.get":
type InspectOperationsGetCall struct {
s *Service
name string
urlParams_ gensupport.URLParams
ifNoneMatch_ string
ctx_ context.Context
header_ http.Header
}
// Get: Gets the latest state of a long-running operation. Clients can
// use this
// method to poll the operation result at intervals as recommended by
// the API
// service.
func (r *InspectOperationsService) Get(name string) *InspectOperationsGetCall {
c := &InspectOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.name = name
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *InspectOperationsGetCall) Fields(s ...googleapi.Field) *InspectOperationsGetCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// IfNoneMatch sets the optional parameter which makes the operation
// fail if the object's ETag matches the given value. This is useful for
// getting updates only after the object has changed since the last
// request. Use googleapi.IsNotModified to check whether the response
// error from Do is the result of In-None-Match.
func (c *InspectOperationsGetCall) IfNoneMatch(entityTag string) *InspectOperationsGetCall {
c.ifNoneMatch_ = entityTag
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *InspectOperationsGetCall) Context(ctx context.Context) *InspectOperationsGetCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *InspectOperationsGetCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *InspectOperationsGetCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
if c.ifNoneMatch_ != "" {
reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
}
var body io.Reader = nil
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+name}")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("GET", urls, body)
req.Header = reqHeaders
googleapi.Expand(req.URL, map[string]string{
"name": c.name,
})
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.inspect.operations.get" call.
// Exactly one of *GoogleLongrunningOperation or error will be non-nil.
// Any non-2xx status code is an error. Response headers are in either
// *GoogleLongrunningOperation.ServerResponse.Header or (if a response
// was returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was
// because http.StatusNotModified was returned.
func (c *InspectOperationsGetCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GoogleLongrunningOperation{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-08-05 18:17:15 +00:00
return nil, err
}
return ret, nil
// {
// "description": "Gets the latest state of a long-running operation. Clients can use this\nmethod to poll the operation result at intervals as recommended by the API\nservice.",
// "flatPath": "v2beta1/inspect/operations/{operationsId}",
// "httpMethod": "GET",
// "id": "dlp.inspect.operations.get",
// "parameterOrder": [
// "name"
// ],
// "parameters": {
// "name": {
// "description": "The name of the operation resource.",
// "location": "path",
// "pattern": "^inspect/operations/[^/]+$",
// "required": true,
// "type": "string"
// }
// },
// "path": "v2beta1/{+name}",
// "response": {
// "$ref": "GoogleLongrunningOperation"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// method id "dlp.inspect.operations.list":
type InspectOperationsListCall struct {
s *Service
name string
urlParams_ gensupport.URLParams
ifNoneMatch_ string
ctx_ context.Context
header_ http.Header
}
2017-09-21 15:48:45 +00:00
// List: Fetches the list of long running operations.
2017-08-05 18:17:15 +00:00
func (r *InspectOperationsService) List(name string) *InspectOperationsListCall {
c := &InspectOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.name = name
return c
}
2017-09-21 15:48:45 +00:00
// Filter sets the optional parameter "filter": Filters by `done`. That
// is, `done=true` or `done=false`.
2017-08-05 18:17:15 +00:00
func (c *InspectOperationsListCall) Filter(filter string) *InspectOperationsListCall {
c.urlParams_.Set("filter", filter)
return c
}
// PageSize sets the optional parameter "pageSize": The list page size.
2017-09-21 15:48:45 +00:00
// The maximum allowed value is 256 and the default is 100.
2017-08-05 18:17:15 +00:00
func (c *InspectOperationsListCall) PageSize(pageSize int64) *InspectOperationsListCall {
c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
return c
}
// PageToken sets the optional parameter "pageToken": The standard list
// page token.
func (c *InspectOperationsListCall) PageToken(pageToken string) *InspectOperationsListCall {
c.urlParams_.Set("pageToken", pageToken)
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *InspectOperationsListCall) Fields(s ...googleapi.Field) *InspectOperationsListCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// IfNoneMatch sets the optional parameter which makes the operation
// fail if the object's ETag matches the given value. This is useful for
// getting updates only after the object has changed since the last
// request. Use googleapi.IsNotModified to check whether the response
// error from Do is the result of In-None-Match.
func (c *InspectOperationsListCall) IfNoneMatch(entityTag string) *InspectOperationsListCall {
c.ifNoneMatch_ = entityTag
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *InspectOperationsListCall) Context(ctx context.Context) *InspectOperationsListCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *InspectOperationsListCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *InspectOperationsListCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
if c.ifNoneMatch_ != "" {
reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
}
var body io.Reader = nil
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+name}")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("GET", urls, body)
req.Header = reqHeaders
googleapi.Expand(req.URL, map[string]string{
"name": c.name,
})
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.inspect.operations.list" call.
// Exactly one of *GoogleLongrunningListOperationsResponse or error will
// be non-nil. Any non-2xx status code is an error. Response headers are
// in either
// *GoogleLongrunningListOperationsResponse.ServerResponse.Header or (if
// a response was returned at all) in error.(*googleapi.Error).Header.
// Use googleapi.IsNotModified to check whether the returned error was
// because http.StatusNotModified was returned.
func (c *InspectOperationsListCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningListOperationsResponse, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GoogleLongrunningListOperationsResponse{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-08-05 18:17:15 +00:00
return nil, err
}
return ret, nil
// {
2017-09-21 15:48:45 +00:00
// "description": "Fetches the list of long running operations.",
2017-08-05 18:17:15 +00:00
// "flatPath": "v2beta1/inspect/operations",
// "httpMethod": "GET",
// "id": "dlp.inspect.operations.list",
// "parameterOrder": [
// "name"
// ],
// "parameters": {
// "filter": {
2017-09-21 15:48:45 +00:00
// "description": "Filters by `done`. That is, `done=true` or `done=false`.",
2017-08-05 18:17:15 +00:00
// "location": "query",
// "type": "string"
// },
// "name": {
// "description": "The name of the operation's parent resource.",
// "location": "path",
// "pattern": "^inspect/operations$",
// "required": true,
// "type": "string"
// },
// "pageSize": {
2017-09-21 15:48:45 +00:00
// "description": "The list page size. The maximum allowed value is 256 and the default is 100.",
2017-08-05 18:17:15 +00:00
// "format": "int32",
// "location": "query",
// "type": "integer"
// },
// "pageToken": {
// "description": "The standard list page token.",
// "location": "query",
// "type": "string"
// }
// },
// "path": "v2beta1/{+name}",
// "response": {
// "$ref": "GoogleLongrunningListOperationsResponse"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *InspectOperationsListCall) Pages(ctx context.Context, f func(*GoogleLongrunningListOperationsResponse) error) error {
c.ctx_ = ctx
defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point
for {
x, err := c.Do()
if err != nil {
return err
}
if err := f(x); err != nil {
return err
}
if x.NextPageToken == "" {
return nil
}
c.PageToken(x.NextPageToken)
}
}
// method id "dlp.inspect.results.findings.list":
type InspectResultsFindingsListCall struct {
s *Service
name string
urlParams_ gensupport.URLParams
ifNoneMatch_ string
ctx_ context.Context
header_ http.Header
}
// List: Returns list of results for given inspect operation result set
// id.
func (r *InspectResultsFindingsService) List(name string) *InspectResultsFindingsListCall {
c := &InspectResultsFindingsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.name = name
return c
}
// Filter sets the optional parameter "filter": Restricts findings to
2017-09-13 12:09:48 +00:00
// items that match. Supports info_type and likelihood.
2017-09-21 15:48:45 +00:00
//
2017-09-13 12:09:48 +00:00
// Examples:
2017-09-21 15:48:45 +00:00
//
2017-09-13 12:09:48 +00:00
// - info_type=EMAIL_ADDRESS
// - info_type=PHONE_NUMBER,EMAIL_ADDRESS
// - likelihood=VERY_LIKELY
// - likelihood=VERY_LIKELY,LIKELY
// - info_type=EMAIL_ADDRESS,likelihood=VERY_LIKELY,LIKELY
2017-08-05 18:17:15 +00:00
func (c *InspectResultsFindingsListCall) Filter(filter string) *InspectResultsFindingsListCall {
c.urlParams_.Set("filter", filter)
return c
}
// PageSize sets the optional parameter "pageSize": Maximum number of
// results to return.
// If 0, the implementation selects a reasonable value.
func (c *InspectResultsFindingsListCall) PageSize(pageSize int64) *InspectResultsFindingsListCall {
c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
return c
}
// PageToken sets the optional parameter "pageToken": The value returned
// by the last `ListInspectFindingsResponse`; indicates
// that this is a continuation of a prior `ListInspectFindings` call,
// and that
// the system should return the next page of data.
func (c *InspectResultsFindingsListCall) PageToken(pageToken string) *InspectResultsFindingsListCall {
c.urlParams_.Set("pageToken", pageToken)
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *InspectResultsFindingsListCall) Fields(s ...googleapi.Field) *InspectResultsFindingsListCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// IfNoneMatch sets the optional parameter which makes the operation
// fail if the object's ETag matches the given value. This is useful for
// getting updates only after the object has changed since the last
// request. Use googleapi.IsNotModified to check whether the response
// error from Do is the result of In-None-Match.
func (c *InspectResultsFindingsListCall) IfNoneMatch(entityTag string) *InspectResultsFindingsListCall {
c.ifNoneMatch_ = entityTag
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *InspectResultsFindingsListCall) Context(ctx context.Context) *InspectResultsFindingsListCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *InspectResultsFindingsListCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *InspectResultsFindingsListCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
if c.ifNoneMatch_ != "" {
reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
}
var body io.Reader = nil
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+name}/findings")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("GET", urls, body)
req.Header = reqHeaders
googleapi.Expand(req.URL, map[string]string{
"name": c.name,
})
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.inspect.results.findings.list" call.
// Exactly one of *GooglePrivacyDlpV2beta1ListInspectFindingsResponse or
// error will be non-nil. Any non-2xx status code is an error. Response
// headers are in either
// *GooglePrivacyDlpV2beta1ListInspectFindingsResponse.ServerResponse.Hea
// der or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was
// returned.
func (c *InspectResultsFindingsListCall) Do(opts ...googleapi.CallOption) (*GooglePrivacyDlpV2beta1ListInspectFindingsResponse, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GooglePrivacyDlpV2beta1ListInspectFindingsResponse{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-08-05 18:17:15 +00:00
return nil, err
}
return ret, nil
// {
// "description": "Returns list of results for given inspect operation result set id.",
// "flatPath": "v2beta1/inspect/results/{resultsId}/findings",
// "httpMethod": "GET",
// "id": "dlp.inspect.results.findings.list",
// "parameterOrder": [
// "name"
// ],
// "parameters": {
// "filter": {
2017-09-21 15:48:45 +00:00
// "description": "Restricts findings to items that match. Supports info_type and likelihood.\n\nExamples:\n\n- info_type=EMAIL_ADDRESS\n- info_type=PHONE_NUMBER,EMAIL_ADDRESS\n- likelihood=VERY_LIKELY\n- likelihood=VERY_LIKELY,LIKELY\n- info_type=EMAIL_ADDRESS,likelihood=VERY_LIKELY,LIKELY",
2017-08-05 18:17:15 +00:00
// "location": "query",
// "type": "string"
// },
// "name": {
2017-09-13 12:09:48 +00:00
// "description": "Identifier of the results set returned as metadata of\nthe longrunning operation created by a call to InspectDataSource.\nShould be in the format of `inspect/results/{id}`.",
2017-08-05 18:17:15 +00:00
// "location": "path",
// "pattern": "^inspect/results/[^/]+$",
// "required": true,
// "type": "string"
// },
// "pageSize": {
// "description": "Maximum number of results to return.\nIf 0, the implementation selects a reasonable value.",
// "format": "int32",
// "location": "query",
// "type": "integer"
// },
// "pageToken": {
// "description": "The value returned by the last `ListInspectFindingsResponse`; indicates\nthat this is a continuation of a prior `ListInspectFindings` call, and that\nthe system should return the next page of data.",
// "location": "query",
// "type": "string"
// }
// },
// "path": "v2beta1/{+name}/findings",
// "response": {
// "$ref": "GooglePrivacyDlpV2beta1ListInspectFindingsResponse"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *InspectResultsFindingsListCall) Pages(ctx context.Context, f func(*GooglePrivacyDlpV2beta1ListInspectFindingsResponse) error) error {
2017-09-13 12:09:48 +00:00
c.ctx_ = ctx
defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point
for {
x, err := c.Do()
if err != nil {
return err
}
if err := f(x); err != nil {
return err
}
if x.NextPageToken == "" {
return nil
}
c.PageToken(x.NextPageToken)
}
}
// method id "dlp.riskAnalysis.operations.cancel":
type RiskAnalysisOperationsCancelCall struct {
s *Service
name string
googlelongrunningcanceloperationrequest *GoogleLongrunningCancelOperationRequest
urlParams_ gensupport.URLParams
ctx_ context.Context
header_ http.Header
}
2017-09-21 15:48:45 +00:00
// Cancel: Cancels an operation. Use the `inspect.operations.get` to
// check whether the cancellation succeeded or the operation completed
// despite cancellation.
2017-09-13 12:09:48 +00:00
func (r *RiskAnalysisOperationsService) Cancel(name string, googlelongrunningcanceloperationrequest *GoogleLongrunningCancelOperationRequest) *RiskAnalysisOperationsCancelCall {
c := &RiskAnalysisOperationsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.name = name
c.googlelongrunningcanceloperationrequest = googlelongrunningcanceloperationrequest
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *RiskAnalysisOperationsCancelCall) Fields(s ...googleapi.Field) *RiskAnalysisOperationsCancelCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *RiskAnalysisOperationsCancelCall) Context(ctx context.Context) *RiskAnalysisOperationsCancelCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *RiskAnalysisOperationsCancelCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *RiskAnalysisOperationsCancelCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
var body io.Reader = nil
body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlelongrunningcanceloperationrequest)
if err != nil {
return nil, err
}
reqHeaders.Set("Content-Type", "application/json")
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+name}:cancel")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("POST", urls, body)
req.Header = reqHeaders
googleapi.Expand(req.URL, map[string]string{
"name": c.name,
})
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.riskAnalysis.operations.cancel" call.
// Exactly one of *GoogleProtobufEmpty or error will be non-nil. Any
// non-2xx status code is an error. Response headers are in either
// *GoogleProtobufEmpty.ServerResponse.Header or (if a response was
// returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was
// because http.StatusNotModified was returned.
func (c *RiskAnalysisOperationsCancelCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GoogleProtobufEmpty{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-09-13 12:09:48 +00:00
return nil, err
}
return ret, nil
// {
2017-09-21 15:48:45 +00:00
// "description": "Cancels an operation. Use the `inspect.operations.get` to check whether the cancellation succeeded or the operation completed despite cancellation.",
2017-09-13 12:09:48 +00:00
// "flatPath": "v2beta1/riskAnalysis/operations/{operationsId}:cancel",
// "httpMethod": "POST",
// "id": "dlp.riskAnalysis.operations.cancel",
// "parameterOrder": [
// "name"
// ],
// "parameters": {
// "name": {
// "description": "The name of the operation resource to be cancelled.",
// "location": "path",
// "pattern": "^riskAnalysis/operations/[^/]+$",
// "required": true,
// "type": "string"
// }
// },
// "path": "v2beta1/{+name}:cancel",
// "request": {
// "$ref": "GoogleLongrunningCancelOperationRequest"
// },
// "response": {
// "$ref": "GoogleProtobufEmpty"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// method id "dlp.riskAnalysis.operations.delete":
type RiskAnalysisOperationsDeleteCall struct {
s *Service
name string
urlParams_ gensupport.URLParams
ctx_ context.Context
header_ http.Header
}
// Delete: This method is not supported and the server returns
// `UNIMPLEMENTED`.
func (r *RiskAnalysisOperationsService) Delete(name string) *RiskAnalysisOperationsDeleteCall {
c := &RiskAnalysisOperationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.name = name
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *RiskAnalysisOperationsDeleteCall) Fields(s ...googleapi.Field) *RiskAnalysisOperationsDeleteCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *RiskAnalysisOperationsDeleteCall) Context(ctx context.Context) *RiskAnalysisOperationsDeleteCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *RiskAnalysisOperationsDeleteCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *RiskAnalysisOperationsDeleteCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
var body io.Reader = nil
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+name}")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("DELETE", urls, body)
req.Header = reqHeaders
googleapi.Expand(req.URL, map[string]string{
"name": c.name,
})
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.riskAnalysis.operations.delete" call.
// Exactly one of *GoogleProtobufEmpty or error will be non-nil. Any
// non-2xx status code is an error. Response headers are in either
// *GoogleProtobufEmpty.ServerResponse.Header or (if a response was
// returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was
// because http.StatusNotModified was returned.
func (c *RiskAnalysisOperationsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GoogleProtobufEmpty{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-09-13 12:09:48 +00:00
return nil, err
}
return ret, nil
// {
// "description": "This method is not supported and the server returns `UNIMPLEMENTED`.",
// "flatPath": "v2beta1/riskAnalysis/operations/{operationsId}",
// "httpMethod": "DELETE",
// "id": "dlp.riskAnalysis.operations.delete",
// "parameterOrder": [
// "name"
// ],
// "parameters": {
// "name": {
// "description": "The name of the operation resource to be deleted.",
// "location": "path",
// "pattern": "^riskAnalysis/operations/[^/]+$",
// "required": true,
// "type": "string"
// }
// },
// "path": "v2beta1/{+name}",
// "response": {
// "$ref": "GoogleProtobufEmpty"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// method id "dlp.riskAnalysis.operations.get":
type RiskAnalysisOperationsGetCall struct {
s *Service
name string
urlParams_ gensupport.URLParams
ifNoneMatch_ string
ctx_ context.Context
header_ http.Header
}
// Get: Gets the latest state of a long-running operation. Clients can
// use this
// method to poll the operation result at intervals as recommended by
// the API
// service.
func (r *RiskAnalysisOperationsService) Get(name string) *RiskAnalysisOperationsGetCall {
c := &RiskAnalysisOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.name = name
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *RiskAnalysisOperationsGetCall) Fields(s ...googleapi.Field) *RiskAnalysisOperationsGetCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// IfNoneMatch sets the optional parameter which makes the operation
// fail if the object's ETag matches the given value. This is useful for
// getting updates only after the object has changed since the last
// request. Use googleapi.IsNotModified to check whether the response
// error from Do is the result of In-None-Match.
func (c *RiskAnalysisOperationsGetCall) IfNoneMatch(entityTag string) *RiskAnalysisOperationsGetCall {
c.ifNoneMatch_ = entityTag
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *RiskAnalysisOperationsGetCall) Context(ctx context.Context) *RiskAnalysisOperationsGetCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *RiskAnalysisOperationsGetCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *RiskAnalysisOperationsGetCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
if c.ifNoneMatch_ != "" {
reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
}
var body io.Reader = nil
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+name}")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("GET", urls, body)
req.Header = reqHeaders
googleapi.Expand(req.URL, map[string]string{
"name": c.name,
})
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.riskAnalysis.operations.get" call.
// Exactly one of *GoogleLongrunningOperation or error will be non-nil.
// Any non-2xx status code is an error. Response headers are in either
// *GoogleLongrunningOperation.ServerResponse.Header or (if a response
// was returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was
// because http.StatusNotModified was returned.
func (c *RiskAnalysisOperationsGetCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GoogleLongrunningOperation{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-09-13 12:09:48 +00:00
return nil, err
}
return ret, nil
// {
// "description": "Gets the latest state of a long-running operation. Clients can use this\nmethod to poll the operation result at intervals as recommended by the API\nservice.",
// "flatPath": "v2beta1/riskAnalysis/operations/{operationsId}",
// "httpMethod": "GET",
// "id": "dlp.riskAnalysis.operations.get",
// "parameterOrder": [
// "name"
// ],
// "parameters": {
// "name": {
// "description": "The name of the operation resource.",
// "location": "path",
// "pattern": "^riskAnalysis/operations/[^/]+$",
// "required": true,
// "type": "string"
// }
// },
// "path": "v2beta1/{+name}",
// "response": {
// "$ref": "GoogleLongrunningOperation"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// method id "dlp.riskAnalysis.operations.list":
type RiskAnalysisOperationsListCall struct {
s *Service
name string
urlParams_ gensupport.URLParams
ifNoneMatch_ string
ctx_ context.Context
header_ http.Header
}
2017-09-21 15:48:45 +00:00
// List: Fetches the list of long running operations.
2017-09-13 12:09:48 +00:00
func (r *RiskAnalysisOperationsService) List(name string) *RiskAnalysisOperationsListCall {
c := &RiskAnalysisOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.name = name
return c
}
2017-09-21 15:48:45 +00:00
// Filter sets the optional parameter "filter": Filters by `done`. That
// is, `done=true` or `done=false`.
2017-09-13 12:09:48 +00:00
func (c *RiskAnalysisOperationsListCall) Filter(filter string) *RiskAnalysisOperationsListCall {
c.urlParams_.Set("filter", filter)
return c
}
// PageSize sets the optional parameter "pageSize": The list page size.
2017-09-21 15:48:45 +00:00
// The maximum allowed value is 256 and the default is 100.
2017-09-13 12:09:48 +00:00
func (c *RiskAnalysisOperationsListCall) PageSize(pageSize int64) *RiskAnalysisOperationsListCall {
c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
return c
}
// PageToken sets the optional parameter "pageToken": The standard list
// page token.
func (c *RiskAnalysisOperationsListCall) PageToken(pageToken string) *RiskAnalysisOperationsListCall {
c.urlParams_.Set("pageToken", pageToken)
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *RiskAnalysisOperationsListCall) Fields(s ...googleapi.Field) *RiskAnalysisOperationsListCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// IfNoneMatch sets the optional parameter which makes the operation
// fail if the object's ETag matches the given value. This is useful for
// getting updates only after the object has changed since the last
// request. Use googleapi.IsNotModified to check whether the response
// error from Do is the result of In-None-Match.
func (c *RiskAnalysisOperationsListCall) IfNoneMatch(entityTag string) *RiskAnalysisOperationsListCall {
c.ifNoneMatch_ = entityTag
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *RiskAnalysisOperationsListCall) Context(ctx context.Context) *RiskAnalysisOperationsListCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *RiskAnalysisOperationsListCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *RiskAnalysisOperationsListCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
if c.ifNoneMatch_ != "" {
reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
}
var body io.Reader = nil
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+name}")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("GET", urls, body)
req.Header = reqHeaders
googleapi.Expand(req.URL, map[string]string{
"name": c.name,
})
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.riskAnalysis.operations.list" call.
// Exactly one of *GoogleLongrunningListOperationsResponse or error will
// be non-nil. Any non-2xx status code is an error. Response headers are
// in either
// *GoogleLongrunningListOperationsResponse.ServerResponse.Header or (if
// a response was returned at all) in error.(*googleapi.Error).Header.
// Use googleapi.IsNotModified to check whether the returned error was
// because http.StatusNotModified was returned.
func (c *RiskAnalysisOperationsListCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningListOperationsResponse, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GoogleLongrunningListOperationsResponse{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-09-13 12:09:48 +00:00
return nil, err
}
return ret, nil
// {
2017-09-21 15:48:45 +00:00
// "description": "Fetches the list of long running operations.",
2017-09-13 12:09:48 +00:00
// "flatPath": "v2beta1/riskAnalysis/operations",
// "httpMethod": "GET",
// "id": "dlp.riskAnalysis.operations.list",
// "parameterOrder": [
// "name"
// ],
// "parameters": {
// "filter": {
2017-09-21 15:48:45 +00:00
// "description": "Filters by `done`. That is, `done=true` or `done=false`.",
2017-09-13 12:09:48 +00:00
// "location": "query",
// "type": "string"
// },
// "name": {
// "description": "The name of the operation's parent resource.",
// "location": "path",
// "pattern": "^riskAnalysis/operations$",
// "required": true,
// "type": "string"
// },
// "pageSize": {
2017-09-21 15:48:45 +00:00
// "description": "The list page size. The maximum allowed value is 256 and the default is 100.",
2017-09-13 12:09:48 +00:00
// "format": "int32",
// "location": "query",
// "type": "integer"
// },
// "pageToken": {
// "description": "The standard list page token.",
// "location": "query",
// "type": "string"
// }
// },
// "path": "v2beta1/{+name}",
// "response": {
// "$ref": "GoogleLongrunningListOperationsResponse"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *RiskAnalysisOperationsListCall) Pages(ctx context.Context, f func(*GoogleLongrunningListOperationsResponse) error) error {
2017-08-05 18:17:15 +00:00
c.ctx_ = ctx
defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point
for {
x, err := c.Do()
if err != nil {
return err
}
if err := f(x); err != nil {
return err
}
if x.NextPageToken == "" {
return nil
}
c.PageToken(x.NextPageToken)
}
}
// method id "dlp.rootCategories.list":
type RootCategoriesListCall struct {
s *Service
urlParams_ gensupport.URLParams
ifNoneMatch_ string
ctx_ context.Context
header_ http.Header
}
// List: Returns the list of root categories of sensitive information.
func (r *RootCategoriesService) List() *RootCategoriesListCall {
c := &RootCategoriesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
return c
}
// LanguageCode sets the optional parameter "languageCode": Optional
// language code for localized friendly category names.
// If omitted or if localized strings are not available,
// en-US strings will be returned.
func (c *RootCategoriesListCall) LanguageCode(languageCode string) *RootCategoriesListCall {
c.urlParams_.Set("languageCode", languageCode)
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *RootCategoriesListCall) Fields(s ...googleapi.Field) *RootCategoriesListCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// IfNoneMatch sets the optional parameter which makes the operation
// fail if the object's ETag matches the given value. This is useful for
// getting updates only after the object has changed since the last
// request. Use googleapi.IsNotModified to check whether the response
// error from Do is the result of In-None-Match.
func (c *RootCategoriesListCall) IfNoneMatch(entityTag string) *RootCategoriesListCall {
c.ifNoneMatch_ = entityTag
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *RootCategoriesListCall) Context(ctx context.Context) *RootCategoriesListCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *RootCategoriesListCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *RootCategoriesListCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
if c.ifNoneMatch_ != "" {
reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
}
var body io.Reader = nil
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/rootCategories")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("GET", urls, body)
req.Header = reqHeaders
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.rootCategories.list" call.
// Exactly one of *GooglePrivacyDlpV2beta1ListRootCategoriesResponse or
// error will be non-nil. Any non-2xx status code is an error. Response
// headers are in either
// *GooglePrivacyDlpV2beta1ListRootCategoriesResponse.ServerResponse.Head
// er or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was
// returned.
func (c *RootCategoriesListCall) Do(opts ...googleapi.CallOption) (*GooglePrivacyDlpV2beta1ListRootCategoriesResponse, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GooglePrivacyDlpV2beta1ListRootCategoriesResponse{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-08-05 18:17:15 +00:00
return nil, err
}
return ret, nil
// {
// "description": "Returns the list of root categories of sensitive information.",
// "flatPath": "v2beta1/rootCategories",
// "httpMethod": "GET",
// "id": "dlp.rootCategories.list",
// "parameterOrder": [],
// "parameters": {
// "languageCode": {
// "description": "Optional language code for localized friendly category names.\nIf omitted or if localized strings are not available,\nen-US strings will be returned.",
// "location": "query",
// "type": "string"
// }
// },
// "path": "v2beta1/rootCategories",
// "response": {
// "$ref": "GooglePrivacyDlpV2beta1ListRootCategoriesResponse"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}
// method id "dlp.rootCategories.infoTypes.list":
type RootCategoriesInfoTypesListCall struct {
s *Service
category string
urlParams_ gensupport.URLParams
ifNoneMatch_ string
ctx_ context.Context
header_ http.Header
}
// List: Returns sensitive information types for given category.
func (r *RootCategoriesInfoTypesService) List(category string) *RootCategoriesInfoTypesListCall {
c := &RootCategoriesInfoTypesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.category = category
return c
}
// LanguageCode sets the optional parameter "languageCode": Optional
// BCP-47 language code for localized info type friendly
// names. If omitted, or if localized strings are not available,
// en-US strings will be returned.
func (c *RootCategoriesInfoTypesListCall) LanguageCode(languageCode string) *RootCategoriesInfoTypesListCall {
c.urlParams_.Set("languageCode", languageCode)
return c
}
// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
// for more information.
func (c *RootCategoriesInfoTypesListCall) Fields(s ...googleapi.Field) *RootCategoriesInfoTypesListCall {
c.urlParams_.Set("fields", googleapi.CombineFields(s))
return c
}
// IfNoneMatch sets the optional parameter which makes the operation
// fail if the object's ETag matches the given value. This is useful for
// getting updates only after the object has changed since the last
// request. Use googleapi.IsNotModified to check whether the response
// error from Do is the result of In-None-Match.
func (c *RootCategoriesInfoTypesListCall) IfNoneMatch(entityTag string) *RootCategoriesInfoTypesListCall {
c.ifNoneMatch_ = entityTag
return c
}
// Context sets the context to be used in this call's Do method. Any
// pending HTTP request will be aborted if the provided context is
// canceled.
func (c *RootCategoriesInfoTypesListCall) Context(ctx context.Context) *RootCategoriesInfoTypesListCall {
c.ctx_ = ctx
return c
}
// Header returns an http.Header that can be modified by the caller to
// add HTTP headers to the request.
func (c *RootCategoriesInfoTypesListCall) Header() http.Header {
if c.header_ == nil {
c.header_ = make(http.Header)
}
return c.header_
}
func (c *RootCategoriesInfoTypesListCall) doRequest(alt string) (*http.Response, error) {
reqHeaders := make(http.Header)
for k, v := range c.header_ {
reqHeaders[k] = v
}
reqHeaders.Set("User-Agent", c.s.userAgent())
if c.ifNoneMatch_ != "" {
reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
}
var body io.Reader = nil
c.urlParams_.Set("alt", alt)
urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/rootCategories/{+category}/infoTypes")
urls += "?" + c.urlParams_.Encode()
req, _ := http.NewRequest("GET", urls, body)
req.Header = reqHeaders
googleapi.Expand(req.URL, map[string]string{
"category": c.category,
})
return gensupport.SendRequest(c.ctx_, c.s.client, req)
}
// Do executes the "dlp.rootCategories.infoTypes.list" call.
// Exactly one of *GooglePrivacyDlpV2beta1ListInfoTypesResponse or error
// will be non-nil. Any non-2xx status code is an error. Response
// headers are in either
// *GooglePrivacyDlpV2beta1ListInfoTypesResponse.ServerResponse.Header
// or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was
// returned.
func (c *RootCategoriesInfoTypesListCall) Do(opts ...googleapi.CallOption) (*GooglePrivacyDlpV2beta1ListInfoTypesResponse, error) {
gensupport.SetOptions(c.urlParams_, opts...)
res, err := c.doRequest("json")
if res != nil && res.StatusCode == http.StatusNotModified {
if res.Body != nil {
res.Body.Close()
}
return nil, &googleapi.Error{
Code: res.StatusCode,
Header: res.Header,
}
}
if err != nil {
return nil, err
}
defer googleapi.CloseBody(res)
if err := googleapi.CheckResponse(res); err != nil {
return nil, err
}
ret := &GooglePrivacyDlpV2beta1ListInfoTypesResponse{
ServerResponse: googleapi.ServerResponse{
Header: res.Header,
HTTPStatusCode: res.StatusCode,
},
}
target := &ret
if err := gensupport.DecodeResponse(target, res); err != nil {
2017-08-05 18:17:15 +00:00
return nil, err
}
return ret, nil
// {
// "description": "Returns sensitive information types for given category.",
// "flatPath": "v2beta1/rootCategories/{rootCategoriesId}/infoTypes",
// "httpMethod": "GET",
// "id": "dlp.rootCategories.infoTypes.list",
// "parameterOrder": [
// "category"
// ],
// "parameters": {
// "category": {
// "description": "Category name as returned by ListRootCategories.",
// "location": "path",
// "pattern": "^[^/]+$",
// "required": true,
// "type": "string"
// },
// "languageCode": {
// "description": "Optional BCP-47 language code for localized info type friendly\nnames. If omitted, or if localized strings are not available,\nen-US strings will be returned.",
// "location": "query",
// "type": "string"
// }
// },
// "path": "v2beta1/rootCategories/{+category}/infoTypes",
// "response": {
// "$ref": "GooglePrivacyDlpV2beta1ListInfoTypesResponse"
// },
// "scopes": [
// "https://www.googleapis.com/auth/cloud-platform"
// ]
// }
}