Types

t()

@type t() ::
%[Link]{

dataset: String.t() | nil,

provider: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Proto
Our TYPE_INTERSECTION features model the point where one or
more segments terminate. This is topological definition: it may not
match what a typical user would think of as an "intersection". Consider
the intersections where Hayes, Market, Larkin, and 9th Street meet near
(37.77765, -122.41638) in San Francisco. Most people would probably
consider this a single feature, even though we model it as four separate
TYPE_INTERSECTION features. The
TYPE_INTERSECTION_GROUP is used to model the user's concept of
a real-world intersection, which also includes turn lanes or a whole
roundabout (a logical intersection). For the purposes of modeling turn
restrictions and lane connections, a smaller grouping is needed to model
the "core" part of the intersection where there are no lane markings. This
is called a core or artifact group. An intersection group must contain at
least two intersections or add some information (e.g. a name or a
polygon) compared to the intersection itself, or else must not exist. The
standard feature properties are interpreted as follows: name - Can be
used to specify any "special" names associated with this intersection
(e.g. Reads Corner intersection, PEI, Canada). Intersections that are
named according to their cross streets do not need to specify this field,
since this can be determined by looking at the routes associated with
each segment. address - This should always be empty. point - Specifies
the center of the intersection. This is basically the point where the
intersection name should be rendered. Can be omitted in favor of a
polygon. polyline - This should always be empty. polygon - Specifies the
two-dimensional extent of the intersection. This may substitute to the
point field, though having a center set is desirable in this case. child -
This should always be empty.
 Attributes

childGroup (type:
list([Link]
IdProto.t), default: nil) - All artifact intersection groups that are
in this logical group.
groupType (type: String.t, default: nil) -
intersection (type:
list([Link]
default: nil) - The list of TYPE_INTERSECTION
IdProto.t),
features that form this intersection group, but are NOT in any of
this group's child groups. This could be an empty list, though that is
sub-optimal. Even an empty list would allow the paint team to draw
a label for a named intersection, but a non-empty list would, for
example, enable PathFinder to generate better directions. Each of
the TYPE_INTERSECTION feature referred here must refer back
to this feature in its IntersectionProto.
parentGroup (type:
[Link]
default: nil) - Parent logical intersection group. An artifact
to.t,
group that does not have an associated parent logical group is
assumed to be both an artifact and logical group.

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

childGroup:

[[Link].t()] | nil,

groupType: String.t() | nil,

intersection:

[[Link].t()] | nil,
parentGroup:
[Link].t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A TYPE_INTERSECTION feature represents a common endpoint of
one or more segments in a transportation network at which the segments
are connected. An intersection in the real world may be more
complicated than that (e.g., comprise multiple segment endpoints or have
extra attributes), which can be modeled with an additional
TYPE_INTERSECTION_GROUP feature, if needed (see
[Link]). The standard feature properties are interpreted
as follows: name - This should always be empty. Intersections that have
a "special" name (e.g. Reads Corner intersection, PEI, Canada) should
point to a separate TYPE_INTERSECTION_GROUP feature that
captures it. Intersections which are named according to their cross streets
do not need this requirement, since their name can be determined by
looking at the routes associated with each segment. address - This should
always be empty. point - Specifies the center of the intersection. This
should be the last vertex of all the segments which terminate at this
intersection. polyline - This should always be empty. polygon - This
should always be empty. child - This should always be empty.

Attributes

intersectionGroup (type:
[Link]
to.t,default: nil) - The artifact or logical intersection group to
which this intersection belongs. If present, the intersection group
must also refer back to the intersection. If an intersection is within
both the artifact and logical group, then this reference should be to
the artifact group.
outSegment (type:
list([Link]
 IdProto.t),default: nil) - RESERVED
segment (type:
list([Link]
IdProto.t), default: nil) - The list of segments that terminate at
this intersection, in any order. Note that all segments are directed
towards the intersection, i.e. their endpoints indicate what sort of
intersection this is. This should not be empty because an
intersection with no associated segment is meaningless.
tollCluster (type:
[Link]
default: nil) - The toll cluster to which this intersection
to.t,
belongs. If present, the toll cluster must also refer back to the
intersection. To set this field, the intersection must be a
gcid:toll_intersection feature.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

intersectionGroup:

[Link].t() | nil,
outSegment:

[[Link].t()] | nil,
segment:

[[Link].t()] | nil,
tollCluster:
[Link].t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

duration (type: String.t, default: nil) - Describes how much

time the service is going to take, e.g. how long it takes to do a
haircut. Value of seconds must be from +60 (1 min) to +31,536,000
(365 days) inclusive. Value of nanos must be zero.
jobRelatedCategories (type:
list([Link]
tedCategory.t),default: nil) - Represents the name of a
potential grouping of items. For TYPE_JOB, this is the category
names of the categories that a user picked this job type from at the
time of input.
jobTypeId (type: String.t, default: nil) - Unique identifier for
a job. This is required for standard jobs and blank for free-form
jobs. Job type ids are prefixed with "job_type_id:". Notice this is a
unique string representation of a job across languages. E.g.,
“job_type_id:air_duct_repair”. The existence of a job_type_id
means the job type is a standard one, and has a corresponding entry
in the Standard Jobs Taxonomy.
jobTypeMid (type: String.t, default: nil) - Represents the MID
corresponding to the job_category entity in the Knowledge Graph.
For example, job_type_id="job_type_id:install_faucet",
job_type_mid="/g/11hzzxjv3f".

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

duration: String.t() | nil,

jobRelatedCategories:
[[Link].t()] | nil,

jobTypeId: String.t() | nil,

jobTypeMid: String.t() | nil

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
y
This is the category that a user picked this job type from at the time of
input. The field serves two purposes: 1) The name is used in consumer
surface similar to the heading name today (i.e., grouping jobs under the
category. 2) The gcid is needed mainly for free-formed entries, for which
GMB needs to map them to corresponding categories in the frontend, if
applicable. Notice that the name and the id are both not expected to be in
sync with gcid deprecation or location category change per product
decision. In other words, they are not guaranteed to stay in sync, only
guaranteed true at time of creation.

Attributes

gcid (type: String.t, default: nil) -

language (type: String.t, default: nil) -
name (type: String.t, default: nil) - Category name in the
primary language of the feature. Generally intended to be used as a
fallback when we are unable to fetch the name in the user's
language.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

gcid: String.t() | nil,

language: String.t() | nil,

name: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
eferenceProto
The reference to an entity in the KnowledgeGraph. For details on the
KnowledgeGraph see [Link]

Attributes

(type: String.t, default: nil) - KG Identifier (MID). For

id
details, see [Link]

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link]{
id: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
eProto
This protocol buffer represents the association between a segment and a
landmark feature. Notes: - References to TYPE_SEGMENT features
should always point to the even sibling. - Self-references are allowed but
the referencing segment's sibling is required to have a self-reference as
well (the above requirement to always reference the even sibling still
applies).

Attributes

featureType (type: integer(), default: nil) - The type of the

landmark feature. Allowed types: - TYPE_CARTOGRAPHIC e.g. a
putting green or water hazard - TYPE_COMPOUND e.g. - the
Empire state building (TYPE_COMPOUND_BUILDING) - a park
(TYPE_COMPOUND_GROUNDS) - a section of a retail store
(TYPE_COMPOUND_SECTION) - TYPE_ESTABLISHMENT
e.g. - the Eiffel Tower (TYPE_ESTABLISHMENT_BUILDING) -
a sports field (TYPE_ESTABLISHMENT_GROUNDS) - Starbucks
(TYPE_ESTABLISHMENT_POI) -
TYPE_INTERSECTION_GROUP e.g. a major intersection -
TYPE_NATURAL_FEATURE e.g. a river - TYPE_SEGMENT e.g.
a bike trail or train tracks
landmark (type:
[Link]
to.t,default: nil) - The feature ID of the landmark feature.
travelMode (type: list(String.t), default: nil) - The mode(s)
of travel for which this landmark is useful.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

featureType: integer() | nil,
landmark:

[Link].t() | nil,

travelMode: [String.t()] | nil

}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This proto contains attributes relevant to physical lane markers.

Attributes

barrierMaterials (type:
[Link]
alMaterialProto.t,default: nil) - If this is a physical barrier
marker, represent materials found on the marker.
crossingPattern (type:
[Link]
pePatternProto.t,default: nil) - Pattern border and color for
crossing markers. These include crosswalks, stop, and yield lines.
linearPattern (type:
[Link]
default: nil) - Stripe pattern, spacing, and color
PatternProto.t,
for longitudinal markers.

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

barrierMaterials:

[Link].t()
| nil,

crossingPattern:
[Link].t()

| nil,
linearPattern:

[Link].t()
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Describes an individual road lane. Not only driving lanes, but also
parking and biking lanes are covered by this. Note that we may
eventually add curbs and walking to this schema.
MOTIVATION/DESIGN DISCUSSION The intent of this schema is to
model a schematic representation of the road for a bunch of use cases
within GMM, navigation, map tiles. For rendering, we do not want to
represent the geometry of each lane exactly, but do want to model
types/width/gaps/lane markings so that a schematic rendering can be
made. For navigation, we model lane connectivity and restrictions per
lane, so that Pathfinder can potentially pick routes based on lanes, and
definitely use the lanes to better describe the path to the driver. This
schema is driven by the GT team, which is likely to be the only provider
of this data. It is based on compromises that we are working out with
other teams, based on what our operators can reasonably collect and
what is useful. See docs here:
[Link]
WXzzc3tnsk49VhrR3BYFjiRMAzYm0/edit?hl=en_US
[Link]
8JcfvQbU-KWtCJ6IwHiTaCxuq40EM/edit?hl=en_US Note: Some lane
information (width, surface type, etc) may duplicate or contradict
information stored at the segment level.

Attributes

boundingMarker (type:
list([Link]
default: nil) - References to any
gMarkerProto.t),
gcid:physical_lane_marker features that bound this lane.
conjoinedCategory (type: String.t, default: nil) - If the
current lane is part of a merge/split area, indicates the type (split or
merge) and whether the current lane is on the left or right or in the
middle of the merge/split area, as seen in the direction of traffic.
See go/lane-split-merge-schema
distanceToNextLane (type: number(), default: nil) - Gap
between this lane and the next in meters. This is relevant when the
divider is physical, or a wide painted area. For regular painted
single or double lines, there is no gap. This distance is duplicated
between the innermost lanes for each side. Note that this is not used
to describe smallish islands - this is only for long-running gaps. In
particular, this models the median width, the gap between HOV
lanes/regular lanes on freeways, and the road verge between a curb
and sidewalk. Note on split roads: We can model any split road with
a median as a single sibling pair with this distance set to the width
of the median, or as two one-way sibling pairs.
flow (type:
[Link]
o.t,default: nil) - The most logical path for the center of an
object to travel along within the lane. Typically, this is the lane's
center line, but doesn't have to be.
laneConnection (type:
list([Link]
toLaneConnection.t),default: nil) - Connections to lanes of
other segments at the end of this segment. These connections model
the connectivity where you don't have to do a lane change
maneuver. If any lane connection is present, assume that all others
are forbidden. Also note that segment level restrictions do apply if
present, and can disallow some turn even if the lanes are connected.
For instance, this can happen with timed or vehicle type based
restrictions on the segment. If lane connectivity implies a segment-
level restriction (can't transition to some target segment), that
restriction will also exist as a segment level restriction. In effect -
PathFinder does not have to look at lane connectivity to figure out
segment connectivity. Example: Typically, lanes are just connected
to one other lane. Example: A splitting lane is connected to the two
resulting lanes. Example: At an intersection, a lane is connected to
crossing lanes according to how lanes are painted across the
intersection. In the common case, the target segment will be
connected to the same intersection as this segment. That will
however NOT be true for complex intersections where there is an
intersection group. The connections will be across the whole group,
connecting to one of the outgoing segments from the group. This is
analogous to how we do turn restrictions around intersection
groups.
laneDividerCrossing (type: String.t, default: nil) - clang-
format on Whether the divider to the inside of this lane can be
crossed. Note that we assume this is symmetric, and that this also
describes whether someone in the next inside lane can cross to this
one. The "inside" lane is the one with a lower lane_number. Note on
lane markers: We do not model the painting, but only the resulting
legality. There are many painted marker styles and colors that lead
to the same legality. We expect Paint or Driveabout to render lanes
stylized, with solid meaning "can't cross", and dashed meaning "can
cross". Note on varying legality along segment: ALLOWED takes
precedence - even if some small portion has a restriction (such as
right before an intersection) , the lane change will be ALLOWED.
laneFollowsSegmentBeginFraction (type: number(), default:
nil) - These indicate for what portion of the segment the lane's
flowline exactly follows the segment, and the lane is of constant
width. This will be set to not include the whole segment where
there is a split/turn/merge at either end of the lane. The painting of
the lane should completely synthesize the lane geometry outside of
this portion, connecting it to neighboring lanes to make graphical
nice.
laneFollowsSegmentEndFraction (type: number(), default: nil)
-
laneNumber (type: integer(), default: nil) - Lanes are
numbered from inside of the road outward, i.e. the lane next to the
center line is lane 0. The lanes then stack outwards, towards the side
that one drives on this segment (right or left). NOTE: do NOT use
the lane_number as index for lookup. Lane_number is not
guaranteed to match the [Link] repeated field index.
laneToken (type: String.t, default: nil) - A token that can be
used to identify the version of the data about this lane.
metadata (type:
[Link]
aProto.t, default: nil) - Field-level metadata for this lane.
restriction (type:
list([Link]
tionProto.t),default: nil) - Restrictions that apply to this lane
only. Examples include HOV lanes. If a lane restriction implies a
segment-level restriction (can't route on the segment at all), that
restriction will also exist as a segment level restriction. In effect -
PathFinder does not have to look at lane restrictions to figure out
segment restrictions.
shared (type: boolean(), default: nil) - True if this lane is
usable in both directions (left-turn lane, reversing lane, one-lane
road, etc). To get the total number of lanes for a road, add up the
lanes in each direction counting 0.5 for each shared lane.
stopLine (type:
list([Link]
IdProto.t), default: nil) - References to any
gcid:physical_lane_marker features that intersect this lane, with the
implication that a moving vehicle should stop there.
surface (type: String.t, default: nil) - clang-format on
[Link](//depot/google3/geostore/base/proto/[Link]
oto) Unlike the surface in SegmentProto, this field does not have a
default value. This is because the lane-level surface overrides the
segment-level surface. The lane's surface should be unset unless
explicitly overriding the segment's surface.
type (type: String.t, default: nil) - clang-format on
width (type: number(), default: nil) - Width of this lane in
meters. In many cases, we will collect this data by dividing the total
road width by the number of lanes. On accuracy: This is a rough
 average width along this segment. If and when we wanted to be
more accurate, we'd extend this schema to have full polygons for
segments/lanes rather than just this average width.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

boundingMarker:
[[Link].t()] | nil,

conjoinedCategory: String.t() | nil,

distanceToNextLane: number() | nil,

flow: [Link].t() | nil,

laneConnection:

[[Link].t()]
| nil,
 laneDividerCrossing: String.t() | nil,
laneFollowsSegmentBeginFraction: number() | nil,

laneFollowsSegmentEndFraction: number() | nil,

laneNumber: integer() | nil,

laneToken: String.t() | nil,

metadata:

[Link].t() | nil,
restriction:
[[Link].t()] | nil,
shared: boolean() | nil,

stopLine:
[[Link].t()] | nil,
surface: String.t() | nil,

type: String.t() | nil,

width: number() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
nection
Attributes

boundingMarker (type:
list([Link]
default: nil) - References to any
gMarkerProto.t),
gcid:physical_lane_marker features that bound this lane connection.
connectionToken (type: String.t, default: nil) - A token that
can be used to identify the version of the data about this lane
connection.
curve (type:
[Link]
default: nil) - Specifies how the flowline should be
ionProto.t,
synthesized in this connection region. If unspecified, heuristics may
be used to pick a sweep shape based on retraction values or
neighboring curves.
flow (type:
[Link]
o.t, default: nil) - The most logical path for the center of an
object to travel along within the lane connection. Typically, this is
the lane connection's center line, but doesn't have to be.
laneNumber (type: integer(), default: nil) - This is the lane
number on the target segment. This field is not set if the target
segment doesn't have lanes, or we don't know the exact
connectivity.
primaryConnection (type: boolean(), default: nil) - True if this
connects to the unique, natural continuation of the current lane. At
most one LaneConnection per lane can have this field set true. This
 attribute is of interest to ADAS providers as a hint to which lane a
vehicle is likely to follow, in the absence of other information about
the vehicle's planned path.
segment (type:
[Link]
to.t,default: nil) - This reference to the other segment is weak,
since strong would blow up bounds of all segments.
yieldToOtherConnections (type: boolean(), default: nil) - The
inverse of the primary connection bit that provides a hint that this
connection is part of a merge and a vehicle following this
connection should yield to vehicles following other incoming
connections.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link]{
boundingMarker:

[[Link].t()] | nil,
connectionToken: String.t() | nil,
curve:

[Link].t() | nil,
flow: [Link].t() | nil,

laneNumber: integer() | nil,

primaryConnection: boolean() | nil,

segment: [Link].t() | nil,

yieldToOtherConnections: boolean() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
xtProto
Represents a piece of text with an associated language.

Attributes

language (type: String.t, default: nil) - The external form of a

Google International Identifiers Initiative (III) LanguageCode
object. See google3/i18n/identifiers/languagecode.h for details. We
place extra restrictions on languages in addition to what the III
library requires. See [Link]
properties/[Link]
text (type: String.t, default: nil) - The text (UTF-8 encoding).

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link]{

language: String.t() | nil,

text: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A feature used to represent a logical level, e.g. floor. A feature belonging
to a given level should point to the level feature using relation
RELATION_ON_LEVEL. The standard feature properties are
interpreted as follows: name - Levels should have names according to
the following: Short, elevator-style names, such as "L" for "Lobby" and
"2" for "Second floor", must be included and must be tagged with
FLAG_ABBREVIATED. There must be an unambiguous "best"
abbreviated name. Longer names such as "Ticketing" or "Upper Level"
may be present when the level has a specific name. * Non-abbreviated
names should only be added if they are known to meaningfully expand
upon the abbreviated name. For example, the long name "Observation
Deck 2" for the abbreviated name "OD2" is a good additional name. In
contrast, the name "Level 2" for the abbreviated name "2" is not desired.
address - This should always be empty. point, polyline, polygon, center -
These should never be set (since we are representing a logical entity).
preferred_viewport - This should be the approximate extent of the level.
child - This should always be empty.

Attributes

building (type:
list([Link]
default: nil) - The building(s) to which this level
IdProto.t),
belongs. A level will typically belong to a single building, but it is
valid for a single level to be shared by multiple buildings (for
example, a large underground parking lot). These buildings refer
back to the level via another strong reference (the
[Link] field).
 number (type: number(), default: nil) - The elevation of this
level relative to the ground level, in levels. 0 = ground floor (even
in locales that call the ground floor "1st floor"); 0.5 = between
ground and first floor, eg mezzanine; 1 = first floor (one level above
ground floor); -3 = three levels below ground floor.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

building:
[[Link].t()] | nil,

number: number() | nil

}
Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
nProto
Attributes

line (type:
list([Link]
default: nil) - A linear marker may consist of one
lLineProto.t),
or more parallel physical lines. These are ordered left to right along
the direction of the marker core polyline.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link]{

line:
[[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
oto
This message describes the details of a single language within a locale.

Attributes

language (type: String.t, default: nil) - The language

associated with this preference. The external form of a Google
International Identifiers Initiative (III) LanguageCode object. See
google3/i18n/identifiers/languagecode.h for details. We place extra
restrictions on languages in addition to what the III library requires.
See [Link]
properties/[Link]
official (type: boolean(), default: nil) - Flag to indicate if the
associated language is "official" within a locale.
preference (type: number(), default: nil) - This value
represents the preference of the associated language within a locale.
It must be between 0.0 and 1.0.
speakingPercent (type: number(), default: nil) - Percentage of
population that can speak the associated language within a locale. It
must be between 0 and 100.
writingPercent (type: number(), default: nil) - Percentage of
population that can write the associated language within a locale. It
must be between 0 and 100.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

language: String.t() | nil,

official: boolean() | nil,

preference: number() | nil,

speakingPercent: number() | nil,

writingPercent: number() | nil

}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A locale is a meta-feature that describes the geographic extent of
localization preferences such as the local language, and formatting
conventions for numbers, dates and monetary values. Multilingual areas
may be contained by multiple locales. We try to model locales fine-
grained enough for deciding which languages are typically used within a
city. For example, while French is an official language for all of
Switzerland, we would prefer to have Zurich contained by a separate
(more fine-grained) Swiss-German locale indicating that German, not
French, is the predominantly spoken language in this city. Note that
language borders are frequently considered a political question and often
don't have clearly defined extents. For example, California has a
significant Spanish-speaking population, but Spanish is not an official
language of California.

Attributes

language (type:
list([Link]
anguageProto.t), default: nil) - This holds the list of languages
spoken within a locale.
localizationPolicyId (type: String.t, default: nil) - The ID
of the localization policy (from
googledata/geostore/localization/localization_policies.textpb) to
apply to features that have this locale as their best match locale.
Localization policy IDs are arbitrary identifiers that uniquely
distinguish a set of language-selection rules.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

language:

[[Link].t()] | nil,
localizationPolicyId: String.t() | nil

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
o
A logical border is a grouping of border features, which together model a
divide between two regions. The borders within this grouping share
common attributes, such as the regions they divide, and may represent a
conceptual group of borders, of which may be wholly disputed, wholly
undisputed, or a mixture of disputed and undisputed. Note that any
borders within this group may be part of multiple logical borders. A
logical border is required to have a name describing what the grouping
represents (e.g. "US - Mexico Border", "Kosovo - Serbia Border
(Disputed)").

Attributes

borderSegment (type:
list([Link]
IdProto.t), default: nil) - All the border segments which make
up this logical border. Border segments must be TYPE_BORDER
features which have the same left/right features. This is a many-to-
many bidirectional relationship, so any border segment within this
list might be part of another logical border.
status (type: String.t, default: nil) - The logical border status
identifies its legal status. This is similar to the BorderStatus present
within border segments, but applies to the group as a whole.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

borderSegment:
[[Link].t()] | nil,

status: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.
[Link].V1.
[Link]
Media item attached to an element of price list.

Attributes

googleUrl (type: String.t, default: nil) - The FIFE url

associated with the media. NOTE: This FIFE URL must be PII-free,
see go/product-catalogue-photo-storage
mediaFormat (type: String.t, default: nil) -
mediaKey (type: String.t, default: nil) - The mediaKey
associated with the media. NOTE: This media key must be PII-free,
see go/product-catalogue-photo-storage
mediaSize (type:
[Link]
toMediaSize.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

googleUrl: String.t() | nil,

mediaFormat: String.t() | nil,

mediaKey: String.t() | nil,

mediaSize:
[Link].t()

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
diaSize
Width and height of the original photo in pixels.

Attributes

originalHeightPx (type: integer(), default: nil) -

originalWidthPx (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link]{
originalHeightPx: integer() | nil,
originalWidthPx: integer() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A name for a Feature (street name, point of interest, city, building, etc).
We currently use NameProto for two essentially disjoint purposes: 1.
Common names, which can be language-specific, or have other kinds of
variations. 2. Opaque IDs, such as postal codes, which only have the
text field set, and potentially some flags. This includes internal-only
features like template ids. Each NameProto representing a common
name corresponds to an assertion that a fluent speaker or writer of a
language would recognize [Link] to name the given feature in
that language. As such, NameProtos are stored in a repeated field, often
having: 1. multiple names with the same text and varying languages, and
2. multiple names with the same language and varying texts.

Attributes

flag (type: list(String.t), default: nil) - clang-format on The

set of flags that apply to this name.
language (type: String.t, default: nil) - The external form of a
Google International Identifiers Initiative (III) LanguageCode
object. See google3/i18n/identifiers/languagecode.h for details.
These strings should be treated as opaque blobs. You can use
LanguageCodeConverter::FromOther to convert the string to a
LanguageCode reference. You can then call methods on the
LanguageCode class to extract language/script/region subtags (if
any). See also [Link] We
place extra restrictions on languages in addition to what the III
library requires. See go/geo-schema-reference/feature-
properties/languages. This field may be missing if the name does
not have a concept of language but should be set if the language is
unknown.
metadata (type:
[Link]
aProto.t,default: nil) - Field-level metadata for this name.
NOTE: there are multiple NameProto fields in the Geo Schema.
Metadata here is only expected to be present on
[Link][].
rawText (type: String.t, default: nil) - DEPRECATED The
name text provided in the original source data (UTF-8 encoding).
This is the text provided in the source data unmodified with the
exception of being converted to UTF-8 and stripping extra leading,
trailing and duplicate whitespaces (if necessary).
shortText (type: String.t, default: nil) - The short name text
(UTF-8 encoding). Acronyms/abbreviations should be consistently
used, for example "NE 57th St" rather than "Northeast 57th Street",
"N.E 57th St." or some other variant. This field should be populated
with the chosen canonical version of the shortened name, based on
per-term transformations. For feature specific abbreviations (such
as 'CA' for 'California'), one should define a separate name with
FLAG_ABBREVIATED set. For other variants of the shortened
name that are not the canonical one, devise client based logic (ex:
query rewriting rules).
temporaryData (type:
[Link].Proto2BridgeMessageS
et.t,default: nil) - A place for clients to attach arbitrary data to a
name. Never set in MapFacts.
text (type: String.t, default: nil) - The name text (UTF-8
encoding). Acronyms/abbreviations should be fully expanded, for
example "Northeast 57th Street" rather than "NE 57th St". They can
be shortened at display or geocode time. This decision prevents
ambiguity over such issues as whether "St" represents "Street" or
"Saint". However, it pushes language-specific knowledge into code.
We will have libraries and data files to contract
acronyms/abbreviations at run-time.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

flag: [String.t()] | nil,

language: String.t() | nil,

metadata:

[Link].t() | nil,
rawText: String.t() | nil,

shortText: String.t() | nil,

temporaryData:

[Link].Proto2BridgeMessageSet.t() | nil,
text: String.t() | nil

}
Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
ceptInstanceContainerProto
The container for all GConceptInstances associated with a feature.

Attributes

instance (type:
list([Link]
yRawGConceptInstanceProto.t), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link]
Proto{
instance:

[Link].t()

]
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
ceptInstanceProto
A RawGConceptInstanceProto contains all data required by both internal
and external clients. We store the 'public' data in a
GConceptInstanceProto and the 'private' data inside of
RawGConceptInstanceProto. NOTE: this doesn't really match the design
we want anymore. Please talk to the Geo Schema team if you are
planning to make use of the "private" fields below.

Attributes

instance (type:
[Link]
anceProto.t, default: nil) - This is the 'public' section of the
GConceptInstance.
isAddedByEdit (type: boolean(), default: nil) -
DEPRECATED Was this GConcept explicitly added by an edit?
Examples of gconcepts not added by edits include those inferred
through geo ontology and those mapped from legacy category
forms by the feature updater. Note that it is possible for both
is_added_by_edit and is_inferred to be true - it means this gconcept
is added by an edit and there is also another more fine-grained
gconcept added by an edit.
isInferred (type: boolean(), default: nil) - RESERVED
provider (type: String.t, default: nil) - DEPRECATED
These two fields combined describe the source of a
GConceptInstance. They are based on
geostore/base/proto/[Link]. Their use has been
deprecated. Use the FieldMetadataProto inside instance instead.
 sourceDataset (type: String.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link]{

instance:
[Link].t()

| nil,
isAddedByEdit: boolean() | nil,
isInferred: boolean() | nil,

provider: String.t() | nil,

sourceDataset: String.t() | nil

}
Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
o
Message to represent opening hours including regular weekly hours and
a set of exceptions.

Attributes

exception (type:
list([Link]
onalHoursProto.t),default: nil) - Date delimited exceptions to
the typical recurring opening hours. May only be present if regular
weekly hours are also specified.
regularHours (type:
[Link]
sProto.t, default: nil) - Typical recurring opening hours,
expressed as a weekly schedule. NOTE: this field was introduced to
have a more client-friendly format for representing weekly hours
but, as of November 2018, it's not used for the main opening hours
of TYPE_ESTABLISHMENT features (instead, the data is stored in
the [Link] field, see b/23105782 tracking the
possible schema migration). It is however used in other contexts
where OpeningHoursProto appears in the Geo Schema. In
openinghours.h there is a utility function
GetOpeningHoursFromFeature that merges
[Link] into this proto.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

exception:

[[Link].t()]
| nil,

regularHours:

[Link].t() | nil
}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Information about a feature's operations, e.g. when the feature is
temporarily closed.

Attributes

temporaryClosure (type:
list([Link]
default: nil) - Records temporary status
ryClosureProto.t),
changes of the feature, such as remodel, vacation, etc.: the feature is
temporarily (but not permanently) unavailable. See go/geo-schema-
reference:operational-lifecycle#temporary-closure for guidance on
interpreting this data and constraints on writing it. NOTE: Order of
the TemporaryClosureProtos is not guaranteed to be chronological.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

temporaryClosure:

[[Link].t()]
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
tusProto
This message captures a border status override. For instance, if the
TYPE_BORDER feature between China and Hong Kong must be hidden
on [Link] (the Chinese domain for Google Maps) but may be
displayed on other domains, we will have a country override border
status for "CN" set to STATUS_NEVER_DISPLAY. At least one
override restriction must be defined. Currently the only supported
restriction is by country code.

Attributes

countryCode (type: String.t, default: nil) - The two-letter ISO

3166-1 country code corresponding to the domain this status
override applies to, when rendering the border polyline.
status (type: String.t, default: nil) - The override status, from
the BorderStatus enumeration. The value here must be different
from the main status (otherwise there's no point in providing the
override).

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link]{

countryCode: String.t() | nil,

status: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
gicalColorProto
Painted element logical color. Most legal definitions only specify a color
category (like "yellow") and don't specify an exact hue, rather stating
that the colors must be distinguishable from each other. We refer to this
as the "logical" color.

Attributes

color (type: String.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link]{

color: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Proto
Describes the parking allowances for a feature, or the situations and
requirements under which one may be permitted to park, such as certain
vehicle types, valet parking, and permit parking. Also describes the cost
of parking, which may vary based on the time and duration parked.
Includes vehicle type, any other conditions for eligibility, and the cost of
parking, which may vary based on the time and duration parked. If
is_discount is set to true on a given allowance, that allowance represents
a discount that can be applied to lower the cost of non-discount
allowances specified on feature via parking_provider_feature. In this
way, allowances can be 'layered,' i.e. appended, onto each other when
denormalizing references via parking_provider_feature.

Attributes

allowanceType (type: String.t, default: nil) - The type of

parking for this allowance. Allowance details only apply to the type
of parking specified.
isDiscount (type: boolean(), default: nil) - If true, this
allowance represents a discount rather than an individual rate; any
rate values specified in this allowance describe a discount to be
applied to the non-discount allowances in the ParkingProto.
minPurchaseForValidation (type:
list([Link].t
),default: nil) - If this rate requires validation, this expresses the
minimum purchase required for validation in each applicable
currency. Should have an ID of /measurement_unit/money_value
and consist of two properties: one with an ID of
 /measurement_unit/money_value/amount and a float value with the
amount, and another with the ID
/measurement_unit/money_value/currency and an ID value with the
MID of the proper currency (from the /finance/currency type). A
value of 0 suggests that no purchase is required. If empty, this
suggests that no validation is required for this rate.
permitType (type:
list([Link]
default: nil) - Any additional details
eTaggedTextProto.t),
about the permit type; e.g. “Zone A”. In any local languages.
Should only be set if allowance_type is PERMIT.
serviceType (type: list(String.t), default: nil) - The types of
services that this parking allowance applies to. For instance, some
cities have streets that only allow traditional taxis to pick up
passengers.
timeBasedRate (type:
list([Link]
default: nil) - Describes the rate structures.
edRateProto.t),
Each TimeBasedRateProto defines a rate which may apply based on
a particular arrival, departure or utilization time; for example, one
rate might apply if arriving before 9am, and another might apply
regardless of arrival or departure time.
vehicleType (type: String.t, default: nil) - Restrictions on
which vehicle type(s) the allowance applies to. By default, the
allowance applies to any vehicle types.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

allowanceType: String.t() | nil,

isDiscount: boolean() | nil,

minPurchaseForValidation:
[[Link].t()] | nil,
permitType:
[[Link].t()]
| nil,

serviceType: [String.t()] | nil,

timeBasedRate:

[[Link].t()] | nil,
vehicleType: String.t() | nil

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Used to describe the parking facilities provided by or available to a
feature. Features of TYPE_ROAD or TYPE_COMPOUND can have a
ParkingProto (with parking_provider_feature unset) that describes the
parking facilities provided by that feature. Features of
TYPE_COMPOUND or TYPE_ESTABLISHMENT_POI can have a
ParkingProto (with parking_provider_feature set) to indicate that the
feature has dedicated parking and provide details about it, and defer
some details of the parking facilities to the referent feature(s).
ParkingProto is maintained by the Harbor Pilot team (go/harbor-pilot).
Detailed modeling information is described at go/parking-schema.

Attributes

allowance (type:
list([Link]
default: nil) - Describes the parking
AllowanceProto.t),
allowances for the feature, which are the situations and
requirements under which one is permitted to park at the feature’s
parking facilities, or discounts that a user may be eligible for.
openingHours (type:
[Link]
Proto.t,default: nil) - Hours in which the parking facility is
open; that is, permits both arrivals and departures of the facility.
Should only be set on compounds (i.e. parking lots or garages);
roads are considered to always be “open,” though parking at certain
times may be prohibited via restrictions. If unset on a compound,
this suggests we don’t know the opening hours, or they are the same
as the hours of the entity for which this feature offers parking
facilities.
parkingAvailable (type: boolean(), default: nil) - Indicates
whether long-term parking is available at the feature; if true, long-
term parking is available at the feature and parking allowances may
be present on this feature, or parking_provider_feature may indicate
deferred parking feature(s). If false, this is an explicit statement that
there is no long-term parking associated with this feature. If unset,
we don't know whether there is long-term parking associated with
this feature. If false or unset, only additional restrictions or short-
term allowances will be populated.
parkingProviderFeature (type:
list([Link]
IdProto.t), default: nil) - If empty, indicates that the feature
containing this ParkingProto provides parking facilities, which are
described by this proto. If nonempty, indicates that the feature with
this ParkingProto does not contain parking facilities itself, but
visitors of this feature may use the parking available to the referent
feature(s). The referent feature(s) may themselves contain parking
facilities or defer to other features. A ParkingProto may defer
parking details to another feature, but still include its own data. This
suggests that a visitor of the referrer feature is eligible for different
rates or discounts. The data in these fields applies transitively, and
any fields in a referrer may be applied to the referent (for a visitor
of the referrer).
restriction (type:
list([Link]
default: nil) - Describes any parking
RestrictionProto.t),
restrictions that apply to this feature. Should only be set on road
segments for which parking is explicitly prohibited for some or all
times; for roads which do not prohibit parking and for all other
facilities, the ability to park should be expressed using allowances.
In the instance that both a restriction and an allowance applies at a
given time, restrictions always have precedence over the same
parking allowances. However, explicit short-term allowances
(PICKUP_GOODS, PICKUP_PASSENGERS) take precedence
 over general NO_PARKING, NO_STANDING, or NO_STOPPING
restrictions.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

allowance:

[[Link].t()]
| nil,

openingHours:
[Link].t() | nil,

parkingAvailable: boolean() | nil,

parkingProviderFeature:

[[Link].t()] | nil,
restriction:
 [[Link].t()]
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Proto
Expresses a parking restriction on a road; i.e. times at which parking on
the road is prohibited.

Attributes

restrictedHours (type:
[Link]
Proto.t, default: nil) - Times at which parking is prohibited.
restrictionType (type: String.t, default: nil) - clang-format
on The type of restriction that applies at this time.
serviceType (type: list(String.t), default: nil) - The types of
services that this parking restriction applies to. We expect most
parking restrictions to apply to all services, but some airports have
specific rideshare parking or taxi parking zones.
vehicleType (type: list(String.t), default: nil) - The types of
vehicles that this parking restriction applies to. For instance, some
streets may allow motorcycles to park but not automobiles or
trucks.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link]{
restrictedHours:

[Link].t() | nil,
restrictionType: String.t() | nil,
serviceType: [String.t()] | nil,
vehicleType: [String.t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This protocol buffer holds related data for features of type TYPE_PEAK
and TYPE_VOLCANO.

Attributes

(type: float(), default: nil) - Topographic

prominenceMeters
prominence in meters: the height of the peak’s summit above the
lowest contour line encircling it and no higher summit.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

prominenceMeters: float() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Proto
A crossing describes a path from the end point of a segment to the start
point of its sibling. Each individual crossing should uniquely represent a
physically distinct crossing in the real world. Pedestrian crossings are
bidirectional. This proto represents "simple" crossings. More
complicated crossings (such as the diagonal crosswalk at Shibuya
Station in Tokyo) will be represented using a separate pedestrian
network. Example 1: Standard four way crossing. Assume each road
(A/B/C) has a crosswalk (denoted by a '-') right before intersection X.
Assume crossing at D is prohibited (denoted by a '%'). Assume "prime"
roads (A',B',...) are OUT segments relative to X. A\A' B//B' \ // \ // - - X -
% // \ // \ C'//C D'\D A CROSSABLE PedestrianCrossing should be
added to A, B and C. An UNCROSSABLE PedestrianCrossing should
be added to D. Example 2: Simple intersection with one crossing.
Assume intersection X was added to accommodate the crosswalk
(through X, denoted by '-'). Assume "prime" roads (A',B',...) are OUT
segments relative to X. A\A' \ \ -X- \ \ B'\B * A CROSSABLE
PedestrianCrossing must be added to either A or B, but not both because
each real-world crossing should be represented exactly once. Duplicative
crossings may be arbitrarily removed.

Attributes

angleDegrees(type: float(), default: nil) - This value specifies

the angle of the crosswalk. Zero degrees represents a crosswalk
perpendicular to the direction of travel, towards the right side of the
segment. The crosswalk angle, winds clockwise. Range [-90, 90].
 The following crosswalk would have a 15 degree angle: / / <--/------
-------------------------- / /
crossAnywhere (type: boolean(), default: nil) - This value
enables crossing anywhere (not just at the segment’s endpoint),
typically used on long, low-traffic residential streets. This attribute
is only respected for trivial segment -> sibling routes. All other
routes can cross at a MapFacts intersection.
crossingType (type: String.t, default: nil) - Crossing type is
used as a restriction and can also be used for rendering.
offset (type: number(), default: nil) - The crossing offset
defines a fraction between the distance from the segment endpoint
to the centerline of the crosswalk and the length of the segment. For
example, the segment length is 20 meters and the distance from
segment end to center of crosswalk is 2 meters, the value of offset
will be 0.1.
restriction (type:
list([Link]
default: nil) - Restrictions for this crossing (such
tionProto.t),
as constructions on the crosswalk). They must not have subpath or
travel_mode.
width (type: number(), default: nil) - This value defines the full
width of the crossing in the direction perpendicular to the direction
which pedestrians walk on the crossing (in meters). The crossing is
allowed to "spill" into the next segment (0.5 * width can be greater
than the offset). Cannot be a negative value.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link]{
angleDegrees: float() | nil,

crossAnywhere: boolean() | nil,

crossingType: String.t() | nil,
offset: number() | nil,
restriction:
[[Link].t()] | nil,

width: number() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.
[Link].V1.
[Link]
Describes a single physical marker line. NOTE: PhysicalLineProto could
be compared against one another by canonicalizing them via
GetCanonicalPhysicalLine() in
google3/geostore/base/internal/lane_marker.cc. Any fields that don't
contribute to the definition of a physical line in the real world should be
bundled with the annotative fields near the bottom and excluded in
GetCanonicalPhysicalLine(). [Link]

Attributes

dashLengthMeters(type: number(), default: nil) - Applicable

for DASHED and DOTTED_DASHED lines.
gapColor (type:
[Link]
ntLogicalColorProto.t,default: nil) - This should be rarely
needed, but can represent patterns of alternating colors.
gapLengthMeters (type: number(), default: nil) - Applicable for
DASHED, DOTTED, and DOTTED_DASHED lines.
material (type: list(String.t), default: nil) -
paintColor (type:
[Link]
ntLogicalColorProto.t, default: nil) - Color for the painted
elements. Applicable to all types.
pattern (type: String.t, default: nil) -
physicalLineToken (type: String.t, default: nil) - A token that
can be used to identify the version of the data about this marker
line.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

dashLengthMeters: number() | nil,

gapColor:

[Link].t()
| nil,

gapLengthMeters: number() | nil,

material: [String.t()] | nil,

paintColor:

[Link].t()
| nil,

pattern: String.t() | nil,

 physicalLineToken: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
to
Attributes

curvatureStatus (type: String.t, default: nil) -

radiansPerMeter (type: number(), default: nil) - Curvature in
radians per meter. Negative is a curve to the left and positive is a
curve to the right.
startPointFraction (type: number(), default: nil) - How far
along the line this curvature value starts to apply, in the format of
decimal between 0 and 1.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

curvatureStatus: String.t() | nil,
radiansPerMeter: number() | nil,
startPointFraction: number() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

latE7(type: integer(), default: nil) -

lngE7 (type: integer(), default: nil) -
metadata (type:
[Link]
aProto.t,default: nil) - NOTE: If removing metadata, remove
'option objc_class_prefix = "GS";' together. See cl/189921100.
Field-level metadata for this point. NOTE: there are multiple
PointProto fields in the Geo Schema. Metadata here is only
expected to be present on [Link][] and
[Link].
temporaryData (type:
[Link].Proto2BridgeMessageS
default: nil) - A place for clients to attach arbitrary data to a
et.t,
point. Never set in MapFacts.

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

latE7: integer() | nil,

lngE7: integer() | nil,

metadata:
[Link].t() | nil,

temporaryData:
[Link].Proto2BridgeMessageSet.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
oto
PointWithHeightProto encodes lat/lng through PointProto and contains
altitude information.

Attributes

(type: number(), default: nil) - Altitude of this

altitudeMeters
point is assumed to be relative to the ground level.
point (type:
[Link].t
, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

altitudeMeters: number() | nil,

point: [Link].t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This protocol buffer is included from [Link] as an optional
message. Political features represent the different ways that people are
divided into geographical regions. This protocol buffer is applicable only
to TYPE_POLITICAL features and is used to store political information
from the feature's point of view.

Attributes

capital (type:
[Link]
to.t,default: nil) - Many political regions have a conceptual
center (capitals of a country or a top-level division are examples). If
set, the target feature must be a TYPE_LOCALITY feature.
claim (type:
list([Link]
IdProto.t), default: nil) - Feature IDs of the features claimed by
this feature's government that are not necessarily included in the
feature's geometry.
grossDomesticProductUsdMillions (type: float(), default:
nil) - The Gross Domestic Product of the political region
measured in millions of current United States dollars. It must not be
negative.
literacyPercent (type: number(), default: nil) - Percentage of
population that are literate within a political region. It must be
between 0 and 100.
population (type: String.t, default: nil) - The number of
people in this political region. This field is intended to store
accurate population, not an estimation such as representative value
for population range. It must not be negative.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

capital: [Link].t() | nil,

claim: [[Link].t()] | nil,
grossDomesticProductUsdMillions: float() | nil,
literacyPercent: number() | nil,
population: String.t() | nil
}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

metadata (type:
[Link]
default: nil) - Field-level metadata for this polyline.
aProto.t,
NOTE: there are multiple PolyLineProto fields in the Geo Schema.
Metadata here is only expected to be present on
[Link][].
temporaryData (type:
[Link].Proto2BridgeMessageS
default: nil) - A place for clients to attach arbitrary data to a
et.t,
polyline. Never set in MapFacts.
vertex (type:
list([Link]
default: nil) - A sequence of vertices connected by
oto.t),
geodesics (the equivalent of straight lines on the sphere). Adjacent
vertices are connected by the shorter of the two geodesics that
connect them, i.e. all edges are 180 degrees or less. Note that the
edge definition becomes numerically unstable as the arc length
approaches 180 degrees. Polylines are generally expected to be non-
self-intersecting, but any such restriction is imposed by the user of
the polyline rather than the polyline itself.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

metadata:
[Link].t() | nil,

temporaryData:
[Link].Proto2BridgeMessageSet.t() | nil,
vertex: [[Link].t()] | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A general non-self-intersecting spherical polygon, consisting of one or
more loops defining multiple disconnected regions possibly with holes.
All loops should be oriented CCW around the region they define. This
applies to the exterior loop(s) as well as any holes. Within MapFacts
(and underlying infrastructure) the data fields may be replaced by a
single shape_id stored in internal_feature. Any such PolygonProtos
shouldn't be expected to work with public functions in
//geostore/base/public/polygon.h.

Attributes

baseMeters (type: number(), default: nil) - The polygon loops

above are basically flat: each point has a latitude and a longitude
but no altitude. We don't want to build real 3D models here, but we
do want to be able to generate 2.5D models. A 2.5D model is built
by translating the flat polygon upward some distance (base) then
extruding it upward some additional distance (height). The
elevation of the bottom of the extruded polygon (above ground
level).
cellId (type: String.t, default: nil) - DEPRECATED This is
part of a splitting strategy for large polygons, which was never fully
launched and we decided not to pursue. For features with very
complex polygonal geometry, we break up the polygon into pieces
that align with S2 cells at various levels. We do this for
performance reasons as some geometry operations have quadratic
complexity with regards to the total number of vertices. In these
cases, we store the S2 cell ID corresponding to the piece of the
overall polygon that is described by this specific PolygonProto
message. Each polygon piece is expected to be fully contained by
the S2 cell corresponding to this cell ID. However, note that the S2
cell ID is not required to correspond to the smallest S2 cell that
fully contains the polygon (and often won't be). In addition,
polygon pieces are required to not have any overlap (which
translates to having entirely disjoint S2 cell IDs, i.e. one can not be
parent (or grand parent, etc.) of another).
encoded (type: String.t, default: nil) - Encoding of the
polygon using S2Polygon::Encode()'s compressed representation.
heightMeters (type: number(), default: nil) - The distance from
the bottom of the extruded polygon to the top.
loop (type:
list([Link]
default: nil) - DEPRECATED We have switched to
eProto.t),
using exclusively the encoded form in the wire format to and from
MapFacts, so this field should never be populated there. See
go/encoded-polygons for more info. "Classic" polygon
representation, defined by one or more loops. The last vertex of
each polyline is implicitly connected to the first vertex. All loops
should be specified in CCW order.
metadata (type:
[Link]
default: nil) - Field-level metadata for this polygon.
aProto.t,
temporaryData (type:
[Link].Proto2BridgeMessageS
et.t,default: nil) - A place for clients to attach arbitrary data to a
polygon. Never set in MapFacts.
unsuitableForDisplay (type: boolean(), default: nil) - Some
polygons are known to be rough proxies for a feature's "real"
polygonal representation. Such polygons are generally unsuitable
for display. Rendering clients should not show these in most cases.
Polygons unsuitable for display do have other uses, such as user
location or containment analysis, or as an input to learning
algorithms. This is an orthogonal concept to
FeatureProto.synthetic_geometry, which only pertains to the
method by which a polygon was created, rather than its fidelity to
 ground truth. For features that have multiple polygons, this bit
should be consistently set to the same value on all polygons.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

baseMeters: number() | nil,

cellId: String.t() | nil,
encoded: String.t() | nil,
heightMeters: number() | nil,
loop: [[Link].t()] | nil,
metadata:
[Link].t() | nil,

temporaryData:
[Link].Proto2BridgeMessageSet.t() | nil,
 unsuitableForDisplay: boolean() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A pose is an object's position in space, as well as its orientation. All
fields except lat and lng are optional. All fields are in the WGS-84
ellipsoid, and rotations are right-hand rule (i.e. if the right hand thumb
points along a vector, curled fingers indicate positive rotation direction).
An un-rotated pose would be pointing due North, along the surface of
the ellipsoid. Rotations are applied in the order: yaw, pitch, roll. Note
that the rotation axes are rotated along with the model for each rotation
step. WARNING: This proto is not meant to be used directly. Please use
the provided libraries: //geostore/base/public/pose.h
//java/com/google/geostore/base/[Link]

Attributes

altitude (type: float(), default: nil) - The height of the pose.

A positive height is above the WGS-84 ellipsoid in meters; negative
is below.
index (type: integer(), default: nil) - The index of the
PoseProto in a list of PoseProtos.
lat (type: float(), default: nil) - The latitude of the pose in
degrees [-90, 90].
lng (type: float(), default: nil) - The longitude of the pose in
degrees (-180,180].
pitch (type: float(), default: nil) - The rotation around the
longitude line East tangent in degrees [-90, 90].
roll (type: float(), default: nil) - The rotation around the
latitude line North tangent in degrees (-180, 180].
yaw (type: float(), default: nil) - The rotation around the Up
vector, from North, in degrees (-180, 180].
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

altitude: float() | nil,

index: integer() | nil,

lat: float() | nil,

lng: float() | nil,
pitch: float() | nil,
roll: float() | nil,

yaw: float() | nil

}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
itionFacts
This message represents nutrition facts for a food dish.

Attributes

calories (type:
[Link]
dNutritionFactsCaloriesFact.t, default: nil) -
cholesterol (type:
[Link]
default: nil) - Cholesterol
dNutritionFactsNutritionFact.t,
information for a given food dish.
protein (type:
[Link]
default: nil) - Protein
dNutritionFactsNutritionFact.t,
information for a given food dish.
sodium (type:
[Link]
default: nil) - Sodium
dNutritionFactsNutritionFact.t,
information for a given food dish.
totalCarbohydrate (type:
[Link]
default: nil) - Carbohydrate
dNutritionFactsNutritionFact.t,
information for a given food dish.
totalFat (type:
[Link]
default: nil) - Fat
dNutritionFactsNutritionFact.t,
information for a given food dish.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link]{

calories:

[Link]
ct.t()

| nil,
cholesterol:

[Link]

act.t()
| nil,

protein:
 [Link]

act.t()
| nil,

sodium:

[Link]

act.t()
| nil,

totalCarbohydrate:

[Link]
act.t()

| nil,
totalFat:

[Link]

act.t()
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
itionFactsCaloriesFact
This message denotes calories information with an upper bound and
lower bound range.

Attributes

lowerAmount (type: integer(), default: nil) -

unit (type: String.t, default: nil) - Unit of the given calories
information.
upperAmount (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link]
act{
lowerAmount: integer() | nil,

unit: String.t() | nil,

upperAmount: integer() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
itionFactsNutritionFact
This message denotes nutrition information with an upper bound and
lower bound range and can be represented by mass unit.

Attributes

lowerAmount (type: float(), default: nil) -

unit (type: String.t, default: nil) - Unit of the given nutrition
information.
upperAmount (type: float(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link]
Fact{

lowerAmount: float() | nil,

unit: String.t() | nil,

upperAmount: float() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

priceList (type:
list([Link]
default: nil) - The actual food menus. This is a
stProto.t),
repeated field because a restaurant may offer multiple menus, e.g.
for different language or for different available time, such as
holidays vs non-holidays.
priceListUrl (type:
list([Link]
Proto.t),default: nil) - All URLs that give price list information
for this establishment. For food menus, this would represent
menu_urls. Note that this field is a repeated list of UrlListProtos.
Each UrlListProto instance in the list is intended to hold lists of
URLs that are translations of the same URL.
status (type:
[Link]
default: nil) - Message containing metadata about the
tus.t,
verified status of the PriceInfo. Only verified listings should be
displayed.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

priceList:
[[Link].t()] | nil,

priceListUrl:
[[Link].t()] | nil,

status: [Link].t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Providers of PriceInfo (e.g. SinglePlatform, YEXT) send verified and
unverified listings. PriceInfoStatus is used to encapsulate this
information.

Attributes

isVerified (type: boolean(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{
isVerified: boolean() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Proto
A PriceListNameInfoProto is used by PriceListProto and fields and
messages contained in it for storing names, descriptions, languages, and
IDs. The name field and the description field must be in the same
language, as specified by the language field. None of the fields in this
proto is required, although it is not expected to have the language field
set unless there is a name or description. When the language field is not
set, it is understood to be the preferred language of the locale where the
establishment is located. An empty string for any of the fields is not
allowed (as enforced by lints).

Attributes

description (type: String.t, default: nil) -

id (type: String.t, default: nil) - IDs are intended to be unique
identifiers of PriceInfoLists, Sections, and Menu items. This is
enforced by the ID_DUPLICATE_PRICE_LIST_ID lint.
language (type: String.t, default: nil) - The external form of a
Google International Identifiers Initiative (III) LanguageCode
object. See google3/i18n/identifiers/languagecode.h for details. We
place extra restrictions on languages in addition to what the III
library requires. See go/geo-schema-reference/feature-
properties/languages.
name (type: String.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

description: String.t() | nil,

id: String.t() | nil,

language: String.t() | nil,

name: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.
[Link].V1.
[Link]
A PriceListProto can be used to represent any type of price lists, one of
which is a menu of food and drinks. It contains names and descriptions,
together with its source URL list if it is extracted or attributed to that
URL. The names and descriptions are represented using repeated
PriceListNameInfo fields to allow versions in different languages. A
PriceListProto may contain multiple sections; in the context of a food
menu, this would be multiple menu sections, e.g. for breakfast, lunch,
dinner, prix fixe, or dinner for two, etc. At least one menu section must
be present. Each section contains a number of items; for food menus, it
may be FoodMenuItems defined below. At least one item must be
present in each section.

Attributes

aggregatorId (type: String.t, default: nil) - For third party

lists, represents the ID of the aggregator which provided this data.
Optional.
availableTime (type:
[Link]
Proto.t, default: nil) - The time period when this price list is
available. Establishments are not required to give available_time for
any given price list, however, when this field is not set, the price list
is understood as available any time the establishment is open.
cuisines (type: list(String.t), default: nil) - Cuisine
information if the location the price lists attached to is an eligible
feature for a food menu price list. Cuisine information should also
only show up in a food price list.
nameInfo (type:
list([Link]
 stNameInfoProto.t),default: nil) - The repeated name_info
field is for price lists listed in multiple languages. When a price list
has no names or descriptions, the size of the repeated field
name_info may be 0. There should be at most one name_info for
any given language.
section (type:
list([Link]
default: nil) - Each price list may have
stSectionProto.t),
multiple sections. Note that these sections within the same price list
should most times contain only the same type of items for sale, e.g.
all sections should usually contain only food items if the enclosing
price list is representing food menu. However, sometimes such a
requirement may be wrong, for example, McDonald's may sell
burgers as well as toys, and the toys may be in its own section. Thus
we don't enforce any requirement that all sections contain only the
same type of items.
sourceUrl (type:
[Link]
.t,default: nil) - Where this price list comes from. If set, this
must also be a member of the price_list_url field, and represents
translations of a single URL.

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

aggregatorId: String.t() | nil,

availableTime:
[Link].t() | nil,

cuisines: [String.t()] | nil,

nameInfo:
[[Link].t()]

| nil,
section:
[[Link].t()]
| nil,
sourceUrl: [Link].t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
oto
A PriceListSectionProto is used to store a section of a PriceListProto.
For example, for a PriceListProto representing a food menu, a
PriceListSectionProto represents a menu section. Each
PriceListSectionProto contains a repeated list of items for sale; these
items can be products or services. Right now every section should
contain items of one type.

Attributes

callToAction (type:
[Link]
default: nil) - Call to action for the section.
Proto.t,
foodItem (type:
list([Link]
default: nil) - To store food and drink items
uItemProto.t),
when the containing PriceListSectionProto is a food menu section.
item (type:
list([Link]
default: nil) - To store any items when the
bleItemProto.t),
containing PriceListSectionProto is not food / legacy services.
itemType (type: list(String.t), default: nil) - This has to
have at most one value.
language (type: String.t, default: nil) - The external form of a
Google International Identifiers Initiative (III) LanguageCode
object. See google3/i18n/identifiers/languagecode.h for details. We
place extra restrictions on languages in addition to what the III
library requires. See go/geo-schema-reference/feature-
 properties/languages. When set, represents the language of the
section and its items. Any section and item level name infos must
match this language. Optional.
media (type:
list([Link]
default: nil) - One or more media items (photos,
emProto.t),
videos, etc.) describing this section / category.
nameInfo (type:
list([Link]
stNameInfoProto.t),default: nil) - The repeated name_info
field is for price list sections listed in multiple languages. When a
price list section has no names or descriptions, the size of the
repeated field name_info may be 0. There should be at most one
name_info for any given language.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

callToAction:

[Link].t() | nil,
foodItem:

[[Link].t()] | nil,
item:

[[Link].t()] | nil,
itemType: [String.t()] | nil,

language: String.t() | nil,

media: [[Link].t()] | nil,
nameInfo:
[[Link].t()]
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This message represents a price range of an attribute. The meaning of the
price bounds is domain specific. But mainly they are soft bounds for a
normal usage. E.g. "restaurant prices" are subject to an higher level of
"soft" bounds than "museum admission price"

Attributes

currency (type: String.t, default: nil) - Currency code for the

price range: a valid currency code from
i18n/identifiers/currencycode.h. Lower and upper price are both
assumed to use the same currency.
lowerPrice (type: float(), default: nil) - This message allows
unbounded price ranges. e.g. Lower_price is undefined. At least one
of the two prices must be set for the price range to be meaningful.
units (type: String.t, default: nil) - clang-format on
upperPrice (type: float(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

currency: String.t() | nil,

lowerPrice: float() | nil,

units: String.t() | nil,

upperPrice: float() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
usProto
PropertyValueStatusProto specifies what we know about a field
corresponding to FeaturePropertyId's value in the absence of any specific
value. For now, it just indicates when we know that there is no value.
Eventually it might also indicate that we know it has value, just not what
it is, etc.

Attributes

propertyId (type:
[Link]
rtyIdProto.t,default: nil) - The property ID whose value status
is defined by this proto.
valueStatus (type: String.t, default: nil) - value_status
specifies whether the feature has a value for the property. This
should always be set to something other than the default value
( PROPERTY_VALUE_STATUS_UNSPECIFIED).

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link]{

propertyId:
[Link].t() | nil,

valueStatus: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This is a minimal version of SourceInfoProto.

Attributes

dataset(type: String.t, default: nil) - The dataset from which

this the referenced data was created. The content of this string will
be determined by the data provider, and may encode extra
information, such as data confidence.
provider (type: String.t, default: nil) - The data provider from
which the referenced data was generated.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

dataset: String.t() | nil,

provider: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This message is embedded within a FeatureProto. It has rank calculation
details such as available rank signals and rank signal mixer used to
compute final rank. For more details, see the Oyster Rank wiki page:
[Link]

Attributes

signal (type:
list([Link]
default: nil) - A list of signals. Each one is
nalProto.t),
extracted separately by a SignalExtractor.
signalMixerType (type: String.t, default: nil) - The signal
mixer that was used to calculate the rank.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

signal:
[[Link].t()] | nil,
signalMixerType: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This message is embedded in the RankDetailsProto (below). It represents
one rank signal, which is a floating point value estimating the Oyster
Rank of the feature.

Attributes

metadata (type:
[Link]
aProto.t,default: nil) - Field-level metadata for this signal.
rank (type: number(), default: nil) - A value in the range [0, 1]
estimating Oyster Rank according to this signal. Non-provider
specific signals (e.g. SIGNAL_POPULATION) are interpreted by
some common code in the ranking pipeline. Because of that, data
providers should leave this field empty when setting such signals
(so that the rank assignment can be uniform across all features
regardless of contributing data providers). On the other hand,
provider-specific signals (e.g.
SIGNAL_ZENRIN_CITY_CATEGORY) are required to specify
the rank field (it is not optional for them). That is because no code
other than that of the provider itself will be able to fill in a
meaningful value later on. We don't want clients to be reading from
the raw_scalar / raw_string fields to interpret the data.
rawScalar (type: number(), default: nil) - The raw scalar value
that was used to compute 'rank' above. The meaning of this attribute
changes depending on the signal type.
rawString (type: String.t, default: nil) - The raw string value
that was used to compute 'rank' above. The meaning of this attribute
changes depending on the signal type.
type (type: String.t, default: nil) -
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

metadata:

[Link].t() | nil,
rank: number() | nil,

rawScalar: number() | nil,

rawString: String.t() | nil,

type: String.t() | nil

}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A RawDataProto is a key-value pair that represents arbitrary source data
from a particular provider. Raw data can be attached to features using
their source_info field.

Attributes

key (type: String.t, default: nil) - The key associated with this
data item. For source data in shape file format, this will typically be
a column name. Keys need to be unique with respect to a particular
data source (see DataSourceProto), but they do not need to be
globally unique. You can look up the documentation for a key (e.g.
a longer label and description) by following the source_id link of
the parent SourceInfoProto, which takes you to a
TYPE_DATA_SOURCE feature, and then looking up the
corresponding RawMetadataProto object for this key in that
feature's optional data_source field.
valueString (type: String.t, default: nil) - All data items are
represented as strings, the logic being that it is easy to convert other
data types to strings, and there is no need to access this data
efficiently.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

key: String.t() | nil,
valueString: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

conflationMethod (type: String.t, default: nil) - Method to

use when conflating together RawDataProto values at the same key
NB: If you add a new ConflationMethod, then you must add the
corresponding logic to MergeRawData to conflate the
RawDataProto values using this method.
description (type: String.t, default: nil) - Self-contained
documentation about what this field represents and how its values
are encoded.
key (type: String.t, default: nil) - The key being described.
label (type: String.t, default: nil) - A longer, human-readable
name associated with this key. The label might be used in a data
explorer tool, for example.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

conflationMethod: String.t() | nil,

description: String.t() | nil,

key: String.t() | nil,
label: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A latitude-longitude rectangle, represented as two diagonally opposite
points "lo" and "hi". The rectangle is considered to be a closed region,
i.e. it includes its boundary. The latitude bounds must be in the range -90
to 90 degrees inclusive, and the longitude bounds must be in the range
-180 to 180 degrees inclusive. Various cases include: - If lo == hi, the
rectangle consists of a single point. - If [Link] > [Link], the
longitude range is "inverted" (the rectangle crosses the 180 degree
longitude line). - If [Link] == -180 degrees and [Link] = 180
degrees, the rectangle includes all longitudes. - If [Link] = 180
degrees and [Link] = -180 degrees, the longitude range is empty. -
If [Link] > [Link], the latitude range is empty.

Attributes

hi (type:
[Link].t
, default: nil) -
lo (type:
[Link].t
, default: nil) -

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

hi: [Link].t() | nil,

lo: [Link].t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
eProto
This protocol buffer supports a name per region per language, allowing it
to represent the name of a given feature in different regions and
languages. For example, the Persian Gulf has different English names in
UAE versus Lebanon; each would need to be represented as distinct
RegionSpecificNameProtos.

Attributes

displayableAsAlternativeName (type: boolean(), default: nil)

- If true, this region specific name should be appended, in
parentheses, to the appropriate name from [Link], for
the default rest of world behavior.
name (type:
[Link].t,
default: nil) - Name to be used for this feature in a specific region
and language.
regionCode (type: String.t, default: nil) - Region code (or
other identifier) for the region.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link]{
displayableAsAlternativeName: boolean() | nil,
name: [Link].t() | nil,

regionCode: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
o
A collection of information that applies to a polygonal area.

Attributes

restriction (type:
list([Link]
default: nil) - The set of restrictions that apply to
tionProto.t),
a zone. These restrictions may limit the routability of every segment
contained within the defined [Link]. Repeated restrictions
are treated collectively as an OR meaning that segments in the zone
are only routable if none of the restrictions apply. If any segments
within the defined polygon should not have these restrictions
applied, they must list this regulated area's feature id in their
feature.exempt_regulated_area field.

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

restriction:
[[Link].t()] | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This message is embedded within a FeatureProto, and represents a
geographic or logical relationship of that feature to some other feature.
Note that some relation types are there purely for the purpose of
grouping together other relation types. They are noted as ABSTRACT in
comments. Other relation types are no longer supported / in use. They
are noted as DEPRECATED in comments (and marked with the standard
deprecated option, too). Other relation types are reserved for future use
or just not intended for use at all, for various internal reasons. They are
noted as RESERVED in comments. WARNING: Updates to this proto
within a FeatureProto's related_feature field handled by standalone
pipelines and are NOT atomic with regard to updates to the features
being referenced; we do not guarantee that a given MapFacts snapshot
will be consistent between this field and the related features.

Attributes

metadata (type:
[Link]
default: nil) - Field-level metadata for this relation.
aProto.t,
otherFeatureCountryCode (type: String.t, default: nil) - If
and only if the other feature is of TYPE_COUNTRY, the 2-letter
country code. This is the FLAG_COUNTRY_CODE_2 name of the
country component.
otherFeatureId (type:
[Link]
default: nil) - The feature ID of the feature to which we're
to.t,
relating. WARNING: the related feature does not necessarily have a
bound that encloses this feature, so in a bucketing MapReduce, you
may not be able to follow all relationships. Relations that use strong
references are annotated above but you can also refer to
IsRelationStrong() in geostore/base/public/relation.h.
otherFeatureName (type:
list([Link]
to.t), default: nil) - RESERVED
otherFeatureTerritorialAdministrator (type: String.t,
default: nil) - If and only if the other feature is of
TYPE_DISPUTED_AREA, the territorial administrator found in its
GeopoliticalAttachmentProto.administered_by field, if any. Since
this string is copied exactly, it may be a 2-letter country code or
another type of descriptive string.
otherFeatureType (type: integer(), default: nil) - The type of
the feature to which we're relating.
overlapFraction (type: number(), default: nil) -
DEPRECATED If relation is exactly RELATION_OVERLAPS
but not any of its subcategories, overlap_fraction contains an
estimate of the fraction of the geometry of this feature that
intersects with the other feature, ranging from 0.0 to 1.0. Note that
this is a rough estimate based on cell coverings, and may not be
very accurate. In particular, values of 0.0 and 1.0 are possible, even
though in principle they should not be.
relation (type: String.t, default: nil) - The relationship of the
feature that contains this RelationProto to the feature
other_feature_id. Note the relation_is_reversed field below. Some
relations imply weak references, other strong ones. Strong
references are annotated above but you can also refer to
IsRelationStrong() in geostore/base/public/relation.h.
relationIsReversed (type: boolean(), default: nil) -
RESERVED
temporaryData (type:
[Link].Proto2BridgeMessageS
default: nil) - A place for clients to attach arbitrary data to a
et.t,
relation. Never set in MapFacts.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

metadata:
[Link].t() | nil,
otherFeatureCountryCode: String.t() | nil,
otherFeatureId:
[Link].t() | nil,
otherFeatureName:

[[Link].t()] | nil,
otherFeatureTerritorialAdministrator: String.t() | nil,

otherFeatureType: integer() | nil,

overlapFraction: number() | nil,

relation: String.t() | nil,

relationIsReversed: boolean() | nil,

temporaryData:
 [Link].Proto2BridgeMessageSet.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
roto
A restriction group represents common properties of a set of restrictions
on segments that are associated with the same underlying cause across a
geographic region. Every segment referenced by this restriction group
should have at least one restriction that refers backs to this restriction
group. The standard feature properties have the following
interpretations: name - A name that represents the name for this
restriction group. kg_property - A reference back to a KG event in case
this restriction group belongs to an event in KG.
/geo/type/restriction_group/associated_event contains a mid to the
associated event.

Attributes

metadata (type:
[Link]
aProto.t, default: nil) - Field-level metadata for this restriction
group.
segment (type:
list([Link]
default: nil) - FeatureId of all segments that have a
IdProto.t),
RestrictionProto referring back to this RestrictionGroup.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

metadata:
[Link].t() | nil,

segment:
[[Link].t()] | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.
[Link].V1.
[Link]
A restriction is an expression that limits when an action can be taken.
Each restriction has a set of conditions. If all of the conditions are true,
then the restriction applies and the action cannot be taken. For example,
the restriction "no turns 3-5pm except buses" would have two
conditions: "time is 3-5pm" and "vehicle is not a bus". If both of these
conditions apply, the restriction is true, and the turn is prohibited.
Multiple restrictions may apply to the same action. Clients handle this by
always declaring RestrictionProto as a "repeated" element. The
semantics of having multiple restrictions are that if any restriction
applies, then the action cannot be taken. In other words, restrictions are
OR-ed together. Putting all of this together, a set of RestrictionProtos can
be interpreted as a bool expression in disjunctive normal form: (A and B)
or (D and E and F) or (G and H) The action is prohibited if this
expression is true. Note that a restriction with no conditions is always
true, i.e. its action is always prohibited. NOTE: RestrictionProtos are
often compared against one another (e.g. to check for
duplicate/redundant restrictions) by canonicalizing them via
GetCanonicalRestriction() in
google3/geostore/base/internal/[Link]. Any fields that don't
contribute to the definition of a restriction in the real world should be
bundled with the annotative fields near the bottom and excluded in
GetCanonicalRestriction(). [Link]

Attributes

autonomousDrivingProducts (type: list(String.t), default:

nil) - The restriction only applies in these specific autonomous
driving product scenarios. NOTE: This should only be set on
restrictions with TRAVEL_AUTONOMOUS_VEHICLE travel
mode.
intersectionGroup (type:
[Link]
to.t,default: nil) - Actually required if style=STYLE_IN_OUT,
otherwise forbidden. Typically the intersection group type is
artifact, but either artifact or logical groups can be used for
STYLE_IN_OUT restrictions.
metadata (type:
[Link]
aProto.t, default: nil) - Field-level metadata for this restriction.
restrictionGroup (type:
[Link]
to.t,default: nil) - Restriction group this restriction belongs to.
restrictionToken (type: String.t, default: nil) - A token that
can be used to identify the version of the data about this restriction.
schedule (type:
[Link]
Proto.t,default: nil) - When specified, restriction applies only at
particular times (operating hours or times of the year: reversing
lanes, seasonal roads, no left turns from 3-5pm Mon-Fri except
holidays). Otherwise, restriction is in effect at all times.
scope (type: String.t, default: nil) - The scope that the
restriction applies to. - SCOPE_DIRECTION means the
segment/sibling pair is restricted in the direction of the segment that
contains this RestrictionProto. For segment/sibling pairs with
pedestrian facilities (and thus side-of-road routing) the
RestrictionProto restricts both facilities in the direction of the
segment (assuming that the restriction applies to travel mode
TRAVEL_PEDESTRIAN). - SCOPE_SIDE means the
RestrictionProto applies only to the side of road that the containing
segment represents. That sibling's pedestrian facility is restricted in
both directions. Schema constraints: - SCOPE_SIDE must be set if
and only if travel_mode == [TRAVEL_PEDESTRIAN] and the
segment containing the restriction has the pedestrian_facility field
set and is not set to PEDESTRIAN_FACILITY_UNKNOWN. Such
restrictions must have no subpath. - All other restrictions must have
this field set to SCOPE_DIRECTION (whether explicitly or
implicitly). This distinction is necessary for cases such as pedestrian
facility on one-way segment/sibling roads. NOTE: This field only
makes sense in the context of segment restrictions, not lane
restrictions.
style (type: String.t, default: nil) - Restriction Style defines
the semantics of the subpath field, as defined above in the
documentation of subpath.
subpath (type:
list([Link]
default: nil) - "subpath" specifies the GeoStore
IdProto.t),
segments that this restriction applies to, according to the
restriction_style field below. Segments that are referenced by this
subpath field also refer to this feature back via the same subpath
field. For all styles of restriction, all segments in the subpath must
have identical copies of the restriction. In other words, restrictions
are duplicated along every segment in the subpath. Note that
subpaths of length 1 do not have any purpose and are disallowed.
Note that it is possible to represent restrictions either using
STYLE_CONTIGUOUS, or depending on the length of the
subpath, one of the more specific STYLE_SINGLE,
STYLE_TURN, or STYLE_IN_OUT. New code should use the
more specific alternatives if possible, as they support instant
updates. For restriction_style == STYLE_CONTIGUOUS (the
default): "subpath" can either be empty, for a single-segment
restriction, or it specifies exactly the sequence of segments which
this restriction applies to. The subpath may be used to specify a turn
restriction (a subpath of length 2) or to prohibit more complex
maneuvers. For example, when merging onto a road from the right-
hand side it may not be possible to make an immediate left turn due
to insufficient time to cross the intervening lanes or the presence of
a physical barrier. This would be indicated by a subpath restriction
of length 3 or more. For restriction_style == STYLE_SINGLE: The
subpath field of the Restriction must be empty. The restriction
applies only to the segment it is attached to. There must not be an
intersection group specified. For restriction_style ==
STYLE_TURN: The subpath field of the Restriction must contain
exactly two segments. The first is called the "in_segment", the
second is the "out_segment". They must be contiguous, i.e. the end
intersection of the in_segment is the start intersection of the
out_segment. The restriction applies only to a direct maneuver from
the in_segment to the out_segment. Other paths from the
in_segment to the out_segment are not restricted. There must not be
an intersection group specified. For restriction_style ==
STYLE_IN_OUT: The subpath field of the Restriction must contain
exactly two segments. The first is called the "in_segment", the
second is the "out_segment". Note that the two segments define
paths, but may not actually be one. The end intersection of the
in_segment must be in an intersection group which also contains the
start intersection of the out_segment. The in- and out-segments are
not required to be adjacent, but may be. Either way, the restriction
applies to any path from the in_segment to the out_segment through
the intersection group, not just direct turns. The intersection_group
must be specified. Note that clients which read restrictions and need
to know which paths are restricted by a given IN_OUT restriction
must expand the IN_OUT restriction by finding all paths through
the intersection group from the in_segment to the out_segment.
temporaryData (type:
[Link].Proto2BridgeMessageS
et.t,default: nil) - A place for clients to attach arbitrary data to a
restriction. Never set in MapFacts.
travelMode (type: list(String.t), default: nil) - Restriction
applies only to the given travel modes. This field should always be
set, but may be missing in old data. WARNING: Restrictions with
no travel modes are DEPRECATED. Historically, no travel modes
has meant "all travel modes", except they didn't really even mean
that, because Pathfinder would use a complex set of heuristics to
interpret the "correct" travel modes. Pathfinder currently (last
 updated August 2013) has heuristics to cope with incomplete data
that reduce or extend application of the specified restrictions to
pedestrians or bicycles. We are actively working to remove these
heuristics and replace them with explicit, correct travel modes in
the data. See b/8746491.
type (type: String.t, default: nil) -
[Link](//depot/google3/google/geo/entities/v1/fields/se
[Link]) clang-format on The type of restriction. This is not a
condition, but rather tells you what kind of restriction it is. This
field should always be set.
vehicleAttributeFilter (type:
[Link]
default: nil) - The restriction only applies to
buteFilterProto.t,
vehicles that meet all of the attributes defined here. If this is empty,
it does not affect the scope of the restriction.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

autonomousDrivingProducts: [String.t()] | nil,

intersectionGroup:
[Link].t() | nil,
metadata:

[Link].t() | nil,
restrictionGroup:

[Link].t() | nil,
restrictionToken: String.t() | nil,

schedule:
[Link].t() | nil,

scope: String.t() | nil,

style: String.t() | nil,

subpath:
[[Link].t()] | nil,

temporaryData:
[Link].Proto2BridgeMessageSet.t() | nil,

travelMode: [String.t()] | nil,

type: String.t() | nil,

vehicleAttributeFilter:
[Link].t()
| nil

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Proto used to represent rights for FeatureProto. See go/geo-rights for
more details. NOTE: Use google3/geostore/provenance/public/rights.h
or google3/java/com/google/geostore/provenance/rights/[Link]
instead of accessing this proto directly.

Attributes

fieldWithRights (type:
list([Link]
thRightsProto.t), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

fieldWithRights:

[[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
oto
A RoadConditionalProto defines conditions that affect when the road
traversal information is applicable.

Attributes

timeSchedule (type:
[Link]
Proto.t,default: nil) - Specifies what times the information is
applicable. This can be specific times (3-5 PM) or days of the week
(Mon - Fri), as well as more general times like school hours, dusk
to dawn, etc. If no value is set, the restriction is applicable at all
times.
vehicleAttribute (type:
[Link]
default: nil) - Additional attributes that
buteFilterProto.t,
apply to the applied vehicle types.
vehicleType (type: list(String.t), default: nil) - Restrictions
applying to specific types of vehicles.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

timeSchedule:
[Link].t() | nil,

vehicleAttribute:
[Link].t()

| nil,
vehicleType: [String.t()] | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A road monitor is a device that observes traffic for road violations like
speeding or running a red light. These are modeled within MapFacts so
that navigation services can warn users when they drive along road
segments that are monitored.

Attributes

monitoredRoad (type:
list([Link]
default: nil) - The TYPE_ROAD segment features
IdProto.t),
that this road monitor may observe.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

monitoredRoad:
[[Link].t()] | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
ntProto
Below is some horrible ASCII art and a description of the components of
a road sign. +-------------------+ | A11 E50 Paris | | Chartres | +--------------
-----+ This sign would be composed of four components (all of them text
components, the only option we support for now). The three in the first
row would all have a "major_position" of zero. Their "minor_position"
values would be zero for "A11", one for "E50", and two for "Paris". The
component in the second row would have "major_position" value of one.
This message provides the details of a single component of a road sign.
A component defines its position within a sign, its type, and its content.

Attributes

featureId (type:
[Link]
to.t,default: nil) - The id of the feature referred to by this
component, typically the route or locality feature this sign points
towards. In the ASCII art example above, this field would contain
the id for the routes A11 and E50 and the localities Chartres and
Paris in the corresponding component.
featureType (type: integer(), default: nil) - The type of the
feature referred to by this component. If feature_id is specified type
of that feature should be the same as this field.
majorPosition (type: integer(), default: nil) - This is the
"major" position of this component within the set of components
that make up a sign. This number can be thought of as the "row" of
the sign on which the component appears, but no guarantees are
made that there is a one-to-one mapping between "major_position"
 and the rows of information on the actual sign being modeled. A
"major_position" value of zero would indicate that the component
is near the top of the sign.
minorPosition (type: integer(), default: nil) - This is the
position of a component within the components of a sign that share
a common "major_position". It can be though of as the "column" of
the component, but like "major_position", no guarantees are made
regarding its mapping to reality. For data sources that don't provide
enough information to determine a component's major and minor
positions, major position should be populated and minor position
should not be present. A "minor_position" value of zero would
indicate that the component is near the "beginning" of the sign. In
countries where signs are read from left to right, "minor_position"
zero would be near the left side of the sign.
routeDirection (type: String.t, default: nil) - The direction of
traffic for the referenced TYPE_ROUTE feature.
semanticType (type: String.t, default: nil) - The semantic type
of sign.
text (type:
[Link].t,
default: nil) - If this sign component is of type "TYPE_TEXT",
this field contains the text of the component. A NameProto is used
to allow language and flags to be associated with the text.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

featureId:

[Link].t() | nil,
featureType: integer() | nil,

majorPosition: integer() | nil,

minorPosition: integer() | nil,
routeDirection: String.t() | nil,

semanticType: String.t() | nil,

text: [Link].t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A RoadSignProto holds the details of a road sign. Currently this is
simply a list of the items that appear on the sign and their relative
position.

Attributes

component (type:
list([Link]
default: nil) - The list of components for a
nComponentProto.t),
single road sign. A sign may be composed of multiple components,
each with its own position and content.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

component:
[[Link].t()]

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
oto
This protocol buffer holds metadata about the association between a
segment and a route.

Attributes

displayPreference (type: String.t, default: nil) - clang-

format on
metadata (type:
[Link]
aProto.t,default: nil) - Field-level metadata for the route
association.
route (type:
[Link]
to.t,default: nil) - Identifies the route feature to which this
metadata applies. This is one of the routes the segment refers to via
the [Link] field.
routeDirection (type: String.t, default: nil) - The direction of
the TYPE_ROUTE feature in this route association. A small
number of countries (mostly just the United States, Mexico, and
Canada) use directional routes. For example, in the United States
highway US-1 is referred to as US-1 North or US-1 South on the
sides where flow of traffic moves in those directions.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

displayPreference: String.t() | nil,

metadata:

[Link].t() | nil,
route: [Link].t() | nil,

routeDirection: String.t() | nil

}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A route is a collection of segments that forms a logical group - usually a
named road or highway. Segments can belong to more than one route,
and the segments of one route may be a subset of the segments of
another route (e.g. I-5 N is a subset of I-5). Segments in the collection
that define the route do not need to constitute a single uninterrupted line,
there can be disconnects. The standard feature properties are interpreted
as follows: name - Routes should have one or more names. (While
unnamed roads certainly exist in the real world, we choose not to create
route features for such roads. Instead, the unnamed segments are merely
not part of any route.) address - This should always be empty. type -
Specifies a particular route subtype, see [Link]. point - This
should always be empty. polyline - This should always be empty.
polygon - This should always be empty. child - The pairs of segments
that belong to this route (a given route should always reference segments
in both travel directions).

Attributes

childType(type: integer(), default: nil) - The feature type of

the route children. Should be set if and only if all children are of the
same feature type.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

childType: integer() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This protocol buffer holds school district specific attributes for features
of TYPE_SCHOOL_DISTRICT.

Attributes

type (type: String.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{

type: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A segment path describes a path through a short set of segments. The
segment path can be used for any purpose. At the moment, only
TYPE_ROAD_SIGN features can have associated segment paths: The
segment path lists the segments that refer to the sign. These are the
segments for which the sign is applicable. The sign's physical location is
independent of the segments in the path.

Attributes

subpath (type:
list([Link]
default: nil) - Specifies a sequence of feature ids of
IdProto.t),
GeoStore segments. The feature ids are ordered. The path "AB" is
not the same as the path "BA". The segments along the path are
assumed to be connected via the appropriate intersections. The
segment features that are referenced by this subpath refer to this
feature back via the road_sign field in segment proto extension.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

subpath:

[[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
---------------------------------------------------------------------------
WARNING - if you add new fields to SegmentProto (or to other protos
used by SegmentProto), you need to: - ensure that the
ShortSegmentsMerger class (in geostore/tools/internal/mr-
[Link]) is aware of them, otherwise the new fields will be
discarded randomly. - consider whether they should be cleared in the
ClearFeature() function (in maps/render/[Link])
if they are irrelevant for rendering high priority roads at far-out zoom
levels. - update the test cases that ensure these two packages know all the
SegmentProto fields in both mr-mergesegments_test.cc and
maps/render/process-high-priority-roads_test.cc or you will break the
VersaTile build. --------------------------------------------------------------------
-------

Attributes

surface(type: String.t, default: nil) - clang-format on

[Link](//depot/google3/geostore/base/proto/[Link])
Specific lanes may override this segment-level surface type.
visibleLandmark (type:
list([Link]
default: nil) - A collection of landmarks
kReferenceProto.t),
that are visible when traveling along this segment and useful for
wayfinding to users following routes using this segment. The
landmark need not be on the segment. Each segment in a pair of
siblings specifies its landmarks independently. A landmark
applicable to both appears in both.
advisoryMaximumSpeed (type:
list([Link]
SpeedLimitProto.t), default: nil) -
constructionStatus (type: String.t, default: nil) -
bicycleFacility (type: String.t, default: nil) - clang-format
on
barrier (type: String.t, default: nil) - clang-format on
covered (type: boolean(), default: nil) - Whether the segment
is covered by a roof etc. If this field is missing, the status is
unknown.
endpointMetadata (type:
[Link]
aProto.t,default: nil) - Field-level metadata for the endpoint.
distanceToEdgeMetadata (type:
[Link]
aProto.t,default: nil) - Field-level metadata for
distance_to_edge.
pedestrianFacility (type: String.t, default: nil) - clang-
format on
constructionBeginDate (type:
[Link]
default: nil) - If known, the date that construction is
o.t,
scheduled to begin.
constructionStatusMetadata (type:
[Link]
aProto.t, default: nil) - Field-level metadata for the construction
status.
(type: String.t, default: nil) -
bicycleSafety
usage (type: String.t, default: nil) - clang-format on
[Link](//depot/google3/maps/pathfinder/pgraph/pgraph
-[Link])
avgSpeedKphMetadata (type:
[Link]
aProto.t, default: nil) - Field-level metadata for the average
speed.
barrierMetadata (type:
[Link]
default: nil) - Field-level metadata for the barrier.
aProto.t,
roadMonitor (type:
list([Link]
IdProto.t),default: nil) - The road monitors that monitor this
segment for traffic violations.
altitude (type: list(number()), default: nil) - RESERVED
sweep (type:
list([Link]
oto.t),default: nil) - The geometric sweeps between this
segment and nearby segments, used for real road width rendering. A
sweep describes the surface that connects to segments.
maxPermittedSpeedKph (type: number(), default: nil) -
[Link](speed_limits) The maximum speed that is permitted
on this segment, in kilometers per hour. This should be the
segment's legal speed limit; however, note that it may contain
estimated values based on country-wide defaults and other
heuristics (see 'is_max_permitted_speed_derived' below). Before
exposing this field to users as the legal speed limit please consult
with Google lawyers.
pedestrianGrade (type: String.t, default: nil) -
distanceToEdge (type: number(), default: nil) - Average
distance between the segment's polyline and edge of the road on
this side in meters. It need not be equal to the sum of width of all
lanes in this direction. This width includes on-street bicycle lanes
but excludes off-street lanes such as sidewalks. The edge of the
road is the rightmost edge for segments in right side driving
countries and leftmost edge for left side driving countries. Width of
the road is sum of this and sibling's distance_to_edge.
pedestrianCrossing (type:
[Link]
default: nil) - Defines the pedestrian crossing(s)
ossingProto.t,
between the end point of this segment and the start point of this
segment's sibling.
tollRoad (type: boolean(), default: nil) - If this segment is part
of a toll road. It would be nice to have data about the toll cost,
locations of toll booths, and so forth. Sadly, we don't have this data
at this time.
constructionEndDate (type:
[Link]
default: nil) - If known, the date that construction is
o.t,
scheduled to end.
conditionMetadata (type:
[Link]
aProto.t,default: nil) - Field-level metadata for the condition.
route (type:
list([Link]
IdProto.t), default: nil) - The route(s) to which this segment
belongs.
roadSign (type:
list([Link]
IdProto.t),default: nil) - The road sign(s) which this segment
refers to. These are features of TYPE_ROAD_SIGN that are
applicable to this segment. For example, a sign that says "TO
KIRKLAND" might apply to several segments on a freeway off-
ramp (until the end of the ramp). Note that this field makes it easy
to find the signs for a given road segment. The feature for the sign
lists the segments that refer to it.
onRight (type: boolean(), default: nil) - Specifies whether this
segment carries right-hand traffic (cars keep to the right side of the
road) instead of left-hand traffic (cars keep to the left side). This is
true for US roads and false for UK roads, for example. See
go/wikip/Left-_and_right-hand_traffic.
ramp (type:
[Link]
RampProto.t,default: nil) - May only be set when the segment's
usage is USAGE_RAMP.
surfaceMetadata (type:
[Link]
aProto.t,default: nil) - Field-level metadata for the surface.
condition (type: String.t, default: nil) -
edgeFollowsSegmentEndFraction (type: number(), default: nil)
-
routeAssociation (type:
list([Link]
default: nil) - Holds metadata about the
sociationProto.t),
associations between this segment and the route features listed in
the route field. This metadata need not be present; the only
consistency requirement is that every feature ID that appears inside
'route_association' must also appear in the repeated 'route' field. If a
route does not appear in route_association, consumers should
assume that it has a default initialized RouteAssociationProto.
internal (type:
[Link]
default: nil) - Internal-only data.
entProto.t,
endpoint (type: String.t, default: nil) - clang-format on
elevationMetadata (type:
[Link]
default: nil) - Field-level metadata for the elevation.
aProto.t,
gradeLevel (type:
list([Link]
velProto.t), default: nil) - Detailed information about grade
levels along the segment. If a GradeLevelProto is not present for
any point (index) along the segment, the default grade level is zero.
In between two points (indexes), the grade level of the segment is
taken to be the max of the grade levels on either side of it. See
[Link] for semantics of repeated indexes.
priority (type: String.t, default: nil) -
[Link](//depot/google3/maps/pathfinder/pgraph/pgraph
-[Link])
interpolationOffsetMeters (type: number(), default: nil) - If
specified, the perpendicular offset in meters from a road segment to
an interpolated address along that road segment. See go/synthetic-
address-positions.
slope (type:
list([Link]
oto.t),default: nil) - Each slope instance is tied to a point along
the segment polyline (unrelated to the vertices in the segment's
polyline) and represents the slope of the segment between that point
and the point tied to the next slope istance, or the end of the
segment if it's the last slope instance. A segment should have at
least one slope.
legalMinimumSpeed (type:
list([Link]
SpeedLimitProto.t), default: nil) -
[Link](//depot/google3/geostore/base/internal/segment.
cc:has_speed_limit)
intersection (type:
[Link]
to.t, default: nil) - The intersection feature corresponding to the
destination of this segment. Intersections are used to represent the
connectivity between segments. Each intersection stores the
segment ids of all the incoming and outgoing segments that meet at
that intersection. Turns can be made from this segment to any of the
outgoing segments of its intersection, unless there is a restriction
that explicitly disallows the turn (see below). Every segment has an
intersection object, even if there are no other segments to connect to
(i.e., a cul-de-sac or dead end).
sibling (type:
[Link]
default: nil) - The other segment of this segment pair (see
to.t,
above). The segment that is referenced by the sibling field refers to
this feature back via the same sibling field. Both segment and
sibling should have the same properties such as geometry, country
code, elevation, level relation, priority etc. Since routes are required
to have segment and sibling at the same time, the set of routes on a
segment is same to that of the sibling.
isMaxPermittedSpeedDerived (type: boolean(), default: nil) -
Specifies whether the max_permitted_speed_kph was derived from
a heuristic as opposed to coming from an authoritative source.
lane (type:
list([Link]
default: nil) - Detailed information about each lane in this
to.t),
direction, if available. Lanes are numbered from inside of the road
outward, i.e. the lane next to the center line has lane_number 0.
Note that lanes that are valid for travel in both directions appear in
both segments of a segment pair (left turn lanes, one-lane roads,
some passing lanes, reversing lanes). Some lanes may not be usable
by cars, such as bike lanes. Also, some lanes may not exist along
the entire segment, e.g. left- or right-turn lanes that appear just
before the intersection.
maxPermittedSpeedKphMetadata (type:
[Link]
aProto.t, default: nil) - Field-level metadata for the maximum
permitted speed.
avgSpeedKph (type: number(), default: nil) - The average speed
that should be expected along this route under normal conditions, in
kilometers per hour. (Hopefully we'll replace this with something a
lot more sophisticated.)
separatedRoadways (type: boolean(), default: nil) - Indicates
whether the segment's opposing lanes of traffic are separated from
this segment, and hence have been represented in a separate feature.
This means that there are two pairs of siblings instead of one.
edgeFollowsSegmentBeginFraction (type: number(), default:
nil) - These indicate for what portion of the segment does the
outer curb of the segment follow the segment polyline - i.e., where
do the sweep curves connect along the outer curb. If unspecified,
may be assumed to be equal to lane retraction, preferring outermost
lane.
priorityMetadata (type:
[Link]
default: nil) - Field-level metadata for the priority.
aProto.t,
legalMaximumSpeed (type:
list([Link]
 SpeedLimitProto.t),default: nil) - The legal maximum, legal
minimum, and advisory (recommended but non-legally binding)
maximum speed limits that are permitted on this segment. These
should be the segment's legal limits; however, note that it may
contain estimated values based on country-wide defaults and other
heuristics (see 'AppliedSpeedLimitProto.trust_level'). Before
exposing these fields to users as the legal speed limit please consult
with Google lawyers.
restriction (type:
list([Link]
tionProto.t),default: nil) - The set of restrictions that apply to
this segment. Restrictions may make a single segment, turn, or
more complex maneuver along a set of segments unroutable for the
specified travel modes, or may only add penalties or warnings,
depending on the restriction type. Turn restrictions are one example
of a restriction. By default, turns are allowed onto all outgoing
segments from this segment's intersection (including the sibling of
this segment, i.e. U-turns are allowed by default). If any of these
turns are disallowed they will be listed as "subpath restrictions". A
subpath restriction disallows travel on given sequence of segments.
In the case of a disallowed turn, the subpath simply consists of the
source and destination feature ids. There may also be restrictions
that apply to all travel on this segment (e.g. chains required, or
closed in winter), or restrictions that just apply to certain lanes (e.g.
high occupancy vehicle lanes).
elevation (type: String.t, default: nil) - clang-format on

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

advisoryMaximumSpeed:

[[Link].t()]
| nil,
altitude: [number()] | nil,
avgSpeedKph: number() | nil,
avgSpeedKphMetadata:
[Link].t() | nil,

barrier: String.t() | nil,

barrierMetadata:

[Link].t() | nil,

bicycleFacility: String.t() | nil,

bicycleSafety: String.t() | nil,

condition: String.t() | nil,

conditionMetadata:

[Link].t() | nil,
constructionBeginDate:
[Link].t() | nil,
constructionEndDate:
[Link].t() | nil,
constructionStatus: String.t() | nil,
constructionStatusMetadata:
 [Link].t() | nil,

covered: boolean() | nil,

distanceToEdge: number() | nil,

distanceToEdgeMetadata:
[Link].t() | nil,
edgeFollowsSegmentBeginFraction: number() | nil,
edgeFollowsSegmentEndFraction: number() | nil,
elevation: String.t() | nil,
elevationMetadata:

[Link].t() | nil,

endpoint: String.t() | nil,

endpointMetadata:

[Link].t() | nil,
gradeLevel:

[[Link].t()] | nil,
internal:

[Link].t() | nil,
interpolationOffsetMeters: number() | nil,

intersection:
[Link].t() | nil,

isMaxPermittedSpeedDerived: boolean() | nil,

lane: [[Link].t()] | nil,
legalMaximumSpeed:

[[Link].t()]
| nil,
legalMinimumSpeed:
[[Link].t()]

| nil,
maxPermittedSpeedKph: number() | nil,

maxPermittedSpeedKphMetadata:
[Link].t() | nil,

onRight: boolean() | nil,

pedestrianCrossing:

[Link].t()
| nil,

pedestrianFacility: String.t() | nil,

 pedestrianGrade: String.t() | nil,

priority: String.t() | nil,

priorityMetadata:

[Link].t() | nil,
ramp:
[Link].t() | nil,

restriction:
[[Link].t()] | nil,

roadMonitor:
[[Link].t()] | nil,

roadSign:
[[Link].t()] | nil,

route: [[Link].t()] | nil,

routeAssociation:

[[Link].t()]
| nil,

separatedRoadways: boolean() | nil,

sibling: [Link].t() | nil,

slope: [[Link].t()] | nil,

surface: String.t() | nil,

surfaceMetadata:
[Link].t() | nil,
sweep: [[Link].t()] | nil,

tollRoad: boolean() | nil,

usage: String.t() | nil,

visibleLandmark:
[[Link].t()]

| nil
}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
pProto
Encapsulates ramp-specific properties.

Attributes

maxConnectedPriority (type: String.t, default: nil) - The

highest priority of any TYPE_ROAD endpoint segment which is
transitively connected to this ramp via other ramp segments. For
instance, if we have two roads connected through a series of ramps
(omitting intersections): Road(P=96)-> Ramp 1 -> Ramp 2 ->
Ramp 3 -> Road(P=122) -> Road(P=144) The
max_connected_priority of all three intermediary ramps is 122.
It's not 144, since Road(P=144) is connected through another road,
not a ramp. This differs from the usual [Link]
field, which contains the lowest priority across any connected road
segment.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

maxConnectedPriority: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This proto represents the geographic area served by an establishment.
WARNING: This proto is not meant to be used directly. Please use the
provided libraries. [Link]
[Link]

Attributes

servedFeature (type:
list([Link]
default: nil) - The features that make up the service
IdProto.t),
area for this establishment. These features are subject to the
following constraints applied by editing middleware (notably, not
strictly enforced by lints in storage): 1. The following feature types
(and their subtypes) may be used: + TYPE_ISLAND +
TYPE_POLITICAL, except the following prohibited subtypes: -
TYPE_CONSTITUENCY - TYPE_LAND_PARCEL +
TYPE_POSTAL 2. There is a maximum limit (currently 20) to the
number of areas which may be provided. This is due to serving
efficiency limitations. 3. There are no additional geometry
requirements for these features beyond the requirements based on
the feature types above. In practice this means that these features
will either have polygonal or point-based geometries. 4. These
referenced features are generally required to have names, though
this is not strictly enforced.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

servedFeature:
[[Link].t()] | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Defines an ordered reference to a line variant’s stop.

Attributes

id (type:
[Link]
to.t,default: nil) - Reference to a Transit POI feature
(gcid:transit_station) or platform compound section
(gcid:railway_platform) serviced by the line variant.
index (type: integer(), default: nil) - An index representing
the order in which the above station is serviced by the line variant.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

id: [Link].t() | nil,

index: integer() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This protocol buffer holds attributes for features of
TYPE_SKI_BOUNDARY.

Attributes

type (type: String.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{

type: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This protocol buffer holds attributes for features of TYPE_SKI_LIFT.

Attributes

type (type: String.t, default: nil) - clang-format on

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{

type: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This protocol buffer holds attributes for features of TYPE_SKI_TRAIL.

Attributes

(type: String.t, default: nil) -

difficulty
type (type: String.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{
difficulty: String.t() | nil,

type: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

slopeValue (type: number(), default: nil) - Slope value as

elevation change divided by horizontal distance, in the format of
decimal, e.g., ‘0.1234’ means a 12.34% slope. If a slope_value is
unset, it indicates we don’t have enough information to compute
slope at this location.
startPointFraction (type: number(), default: nil) - Indicates
how far along the segment this slope value starts to apply, in the
format of decimal between 0 and 1.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

slopeValue: number() | nil,

startPointFraction: number() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
to
MapFacts GAIA ID assigned to this feature. These values are virtual
GAIA IDs from MapFacts, and as such are not stored in Focus.

Attributes

baseGaiaId(type: String.t, default: nil) - WARNING: Please

do NOT introduce new uses; treat this field as if it were deprecated.
claimedGaiaId (type: String.t, default: nil) - GAIA ID used
when a business has been claimed. This value is a robot GAIA ID.
Robots are a special type of GAIA account used to denote identity
for a user or a group of users, but are not logged-in directly by a
user.
gaiaIdForDisplay (type: String.t, default: nil) - WARNING:
Please do NOT introduce new uses; treat this field as if it were
deprecated.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

baseGaiaId: String.t() | nil,

claimedGaiaId: String.t() | nil,

gaiaIdForDisplay: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Source infos are the canonical way to establish data provenance. They
can currently be set on features, edits, and issues. Every feature has a
repeated list of SourceInfoProto messages to describe the source data
that was used in building this feature. The data includes a feature id that
points to additional data about the data source (version, copyright notice,
etc), and optional "raw data" that is taken directly from the provider's
format and has not been converted to a canonical form.

Attributes

attributionUrl (type:
list([Link]
o.t),default: nil) - This is the URL of a page representing all the
data from this source in this feature. It may have be the ultimate
source of the data (in case of scraping) or merely the same data
styled according the provider's taste. There is a similar field in
DataSourceProto which is NOT cached in this field, since it has a
different meaning.
collectionDate (type:
[Link]
o.t,default: nil) - The time that this particular piece of data was
collected. If different attributes were collected on different dates,
this is the date of the most recent edit.
cookie (type: String.t, default: nil) - A source info may have a
magic cookie whose content and semantics are defined by the
specific import process or third-party feed. For feeds that are
processed by Distillery, the cookie, when set, should contain the
unique identifier for the feature as provided by the feed.
dataset (type: String.t, default: nil) - The dataset from which
this SourceInfoProto was created. The content of this string will be
determined by the data provider (e.g. for MultiNet data, "fra" would
indicate the dataset for France). This field is unnecessary for
providers that deliver a single dataset per release (e.g. Basarsoft).
gaiaId (type: String.t, default: nil) - The Gaia ID of the user
who provided us with this data. This field should never be set on
source infos present on features, but may be set on source infos
present on edits. DEPRECATED: Most clients should use the "user"
field instead where Gaia IDs are encrypted.
impersonationUser (type:
[Link].t,
default: nil) - Information about an internal user or system that is
operating on behalf of user by way of impersonation.
layer (type: String.t, default: nil) - The name of the layer
from which this SourceInfoProto was created.
ogrFid (type: String.t, default: nil) - The OGR feature
identifier from which this SourceInfoProto was created. This is an
internal OGR record identifier and has nothing to do with any of the
feature's fields or the FeatureIdProto for the FeatureProto
containing this SourceInfoProto. This field is present only for
debugging purposes and possible use in the match pattern of a
FeatureChangeProto designed to fix bad source data very early in
the importing process.
provider (type: integer(), default: nil) - The data provider
from which this source info was generated. The value must be equal
to the one on the TYPE_DATA_SOURCE feature referenced by
this source info via the source_id reference (see above).
rawData (type:
list([Link]
default: nil) - A source info may optionally have a set
Proto.t),
of key-value pairs that provide "raw data" specific to that source.
The types of raw data available will vary from one provider to
another and should not be used in production code. Instead, new
fields and/or protocol buffers should be defined to represent this
 information in a canonical form, and the relevant importers should
be modified to populate these new fields.
release (type: String.t, default: nil) - The data release from
which this SourceInfoProto was created. The format for this string
is provider-dependent (e.g. a MultiNet release would look like
"2008.01").
sourceId (type:
[Link]
default: nil) - A source info may have a corresponding
to.t,
TYPE_DATA_SOURCE feature that describes it (provider,
copyright information, date of release, etc). In the context of edits
and issues, this field should not be set.
temporaryData (type:
[Link].Proto2BridgeMessageS
default: nil) - A place for clients to attach arbitrary data to a
et.t,
source info. Never set in MapFacts.
user (type:
[Link].t,
default: nil) - RESERVED

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

attributionUrl:
[[Link].t()] | nil,
collectionDate:
[Link].t() | nil,
cookie: String.t() | nil,

dataset: String.t() | nil,

gaiaId: String.t() | nil,

impersonationUser:
[Link].t() | nil,

layer: String.t() | nil,

ogrFid: String.t() | nil,

provider: integer() | nil,

rawData: [[Link].t()] | nil,

release: String.t() | nil,

sourceId:
[Link].t() | nil,
temporaryData:
[Link].Proto2BridgeMessageSet.t() | nil,
user: [Link].t() | nil
}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Trust related information about the input source (feed or user) to help
feature summarization. Typically, the values in this proto are either based
on source's previous observations (e.g., a blocked LBC user or a trusted
feed) or their status (Google hired operator or admin user). The proto can
later contain a more granular trust score or correctness probabilities. A
higher enum value indicates a more trusted source. Leaving room in the
value space for adding more granular enums, if they become necessary
later.

Attributes

level(type: String.t, default: nil) - The level of trust for the

source of the observation.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

level: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A speed limit, containing both the limit and the conditions in which it
applies.

Attributes

category (type: String.t, default: nil) - The type of speed

limit.
condition (type:
list([Link]
default: nil) - The conditions under which
ditionalProto.t),
this speed limit is applicable. If multiple conditions are set, at least
one of them must be true.
sourceType (type: String.t, default: nil) - The source of the
speed limit.
speedWithUnit (type:
[Link].t
, default: nil) - A constant speed limit.
unlimitedSpeed (type:
[Link]
edProto.t,default: nil) - A speed limit with no limit value.
When there is no speed limit in place.
variableSpeed (type:
[Link]
default: nil) - A dynamic speed limit that can vary
dProto.t,
within a range of values based on road conditions.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

category: String.t() | nil,
condition:
[[Link].t()] | nil,

sourceType: String.t() | nil,

speedWithUnit:
[Link].t() | nil,

unlimitedSpeed:

[Link].t() | nil,
variableSpeed:

[Link].t() | nil
}
Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A speed value and unit.

Attributes

speed (type: number(), default: nil) - All speed values are stored
in kilometers per hour.
unit (type: String.t, default: nil) - Mapfacts only allows unit
to be KILOMETERS_PER_HOUR.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

speed: number() | nil,

unit: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
to
Represents a way to traverse nested fields by referencing their token
fields. Everything starts relative to a known root message, specified
externally. E.g., suppose we have a feature proto that has a lane with
token 0x123 which in turn has a lane connection with token 0x456 for
which we want to assert something about flowline altitudes. The field
path in that case will look like: field_path: { field_num: 31 # segment }
field_path: { field_num: 6 # lane version_token: "0x123" } field_path: {
field_num: 8 # lane_connection version_token: "0x456" } field_path: {
field_num: 3 # flow } field_path: { field_num: 1 # track } field_path: { #
Note: pose is repeated. By not specifying a token we refer to all poses #
in a track. field_num: 2 # pose } field_path: { field_num: 4 # altitude }
This path could also be represented succinctly in a more human-friendly
form as something like:
[Link][@0x123].lane_connection[@0x456].[Link][*].alti
tude

Attributes

fieldPath (type:
list([Link]
default: nil) - A
ieldPathProtoStableFieldSelector.t),
sequence of field selectors to be traversed starting from the root
message.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

fieldPath:

[Link]

or.t()
]
| nil

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
toStableFieldSelector
Attributes

fieldNum (type: integer(), default: nil) - Field number to

select.
versionToken (type: String.t, default: nil) - Select repeated
field entry by its version token. If this is used, then the message
referenced by field_num must have a token field annotated with the
(version_token) field option. Must be omitted for leaf non-repeated
fields. If unset for a repeated field, we consider this selector to
apply equally to all descendants.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link]
tor{

fieldNum: integer() | nil,

versionToken: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This protocol buffer represents the 2D polygon connecting two segments
at an intersection. Collectively, sweep polygons represent intersections
for real road width rendering. Notes: - Sweeps represent geometry
between the end of one segment and the end of the other segment
(modulo retraction values). - Sweeps are strongly referenced, meaning
geometry is stored on both segments involved in the sweep. For
example, in the diagram below, the sweep between A and B would be
stored on both segment A and segment B. | B | v --A--> - Sweeps are not
strictly stored on adjacent segments. Disconnected segments (e.g.,
segments separated by an intersection group) may also contain sweeps.

Attributes

otherSegmentFeatureId (type:
[Link]
default: nil) - The segment feature connected to this
to.t,
segment via the sweep geometry.
polygon (type:
[Link]
default: nil) - Polygonal geometry representing the area
.t,
between this segment and the other segment.
sweepCurve (type:
[Link]
default: nil) - Describes parameters for generating
ionProto.t,
the edge of this sweep that starts at
edge_follows_segment_end_fraction. The other side of the sweep
should be described on the sweep present on the sibling pair.
sweepToken (type: String.t, default: nil) - A token that can be
used to identify the version of the data about this sweep.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

otherSegmentFeatureId:
[Link].t() | nil,

polygon: [Link].t() | nil,

sweepCurve:
[Link].t() | nil,
sweepToken: String.t() | nil

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This protocol buffer is used to represent telephone numbers and related
information.

Attributes

callRate (type:
list([Link]
default: nil) - RESERVED
ngeProto.t),
contactCategory (type: String.t, default: nil) - Disambiguates
between the types of information or service a caller might seek
when contacting this phone number.
flag (type: list(String.t), default: nil) -
isSharedNumber (type: boolean(), default: nil) - True if this
phone number is not unique to this establishment and might be
shared with other features. In case an establishment shares a phone
number with a business chain of which it is a member, and the
number canonically belongs to that chain, it should be marked as
shared for the establishment but not shared for the chain.
label (type:
list([Link]
to.t),default: nil) - RESERVED
language (type: list(String.t), default: nil) - RESERVED
metadata (type:
[Link]
default: nil) - Field-level metadata for this telephone
aProto.t,
number.
number (type:
[Link].t,
default: nil) - DEPRECATED This is deprecated in favor of
 phone_number below. An internationalized representation of a
phone number. See //location/country/[Link]
phoneNumber (type:
[Link].I18nPhonenumbersPhon
eNumber.t, default: nil) - An internationalized representation of a
phone number. See
//java/com/google/i18n/phonenumbers/[Link]
serviceLocationFeature (type:
list([Link]
default: nil) - The features from which this phone
IdProto.t),
number can be called from. For instance, if a phone number can
only be called from Europe, this field will contain a reference to the
TYPE_CONTINENT feature of Europe. This field is analogous to
[Link] The
only valid destination feature types are TYPE_CONTINENT and
TYPE_POLITICAL. If empty, this phone number can be called
from anywhere in Earth (this is the case for the majority of phones).
type (type: String.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

callRate:

[[Link].t()] | nil,
contactCategory: String.t() | nil,

flag: [String.t()] | nil,

isSharedNumber: boolean() | nil,
label: [[Link].t()] | nil,

language: [String.t()] | nil,

metadata:

[Link].t() | nil,
number: [Link].t() | nil,

phoneNumber:
[Link].I18nPhonenumbersPhoneNumber.t() | nil,

serviceLocationFeature:
[[Link].t()] | nil,

type: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.
[Link].V1.
[Link]
Proto
This protocol buffer stores information related to temporary closure of a
feature. The only allowed precisions for a date is PRECISION_DAY.
[Link] should have the lowest legal value for the
desired date/time and precision. E.g. for PRECISION_MONTH, 2019-
02-15 21:10:30 is not valid, it should be 2019-02-01 00:00:00 instead.
NOTE: Each date is stored in UTC but should be interpreted as being in
the local timezone. So clients should convert the DateTimeProto to local
(civil) time using UTC+0, and then treat the result as local to the feature.

Attributes

endAsOfDate (type:
[Link]
o.t,default: nil) - The latest when this closure may end, if the
exact date is unknown. If set, the feature is operational again no
later than this date.
endDate (type:
[Link]
o.t,default: nil) - RESERVED
startAsOfDate (type:
[Link]
o.t,default: nil) - The latest when this closure may start, if the
exact date is unknown. If set, the feature is temporarily closed
starting no later than this date.
startDate (type:
[Link]
o.t, default: nil) - RESERVED
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

endAsOfDate:
[Link].t() | nil,
endDate: [Link].t() | nil,
startAsOfDate:

[Link].t() | nil,

startDate: [Link].t() | nil

}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Represents text (with an associated language) that is affixed to the
beginning and/or end of a primary text.

Attributes

language (type: String.t, default: nil) - The external form of a

Google International Identifiers Initiative (III) LanguageCode
object. See google3/i18n/identifiers/languagecode.h for details.
These strings should be treated as opaque blobs. You can use
LanguageCodeConverter::FromOther to convert the string to a
LanguageCode reference. You can then call methods on the
LanguageCode class to extract language/script/region subtags (if
any). See also [Link] We
place extra restrictions on languages in addition to what the III
library requires. See [Link]
properties/[Link]
prefix (type: String.t, default: nil) - Text to prepend to the
primary text, including any necessary trailing whitespace. At least
one of prefix or suffix is required.
suffix (type: String.t, default: nil) - Text to append to the end
of the primary text, including any necessary leading whitespace. At
least one of prefix or suffix is required.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

language: String.t() | nil,

prefix: String.t() | nil,

suffix: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
ModelProto
Attributes

pointIndices(type: list(integer()), default: nil) - Triangle

vertex indices, each triple defines a triangle.
points (type:
list([Link]
default: nil) - We store a triangular mesh in
thHeightProto.t),
indexed format. Points array.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link]{
pointIndices: [integer()] | nil,
points:
[[Link].t()] | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
to
A rate which applies based on the precise times of utilization. Defines a
rate, as well as restrictions on the start and end times which must be
satisfied in order to be eligible for the rate. See go/rate-schema for more
details.

Attributes

durationBasedRate (type:
list([Link]
nBasedRateProto.t), default: nil) - The rates for this rule. Each
duration_based_rate defines the costs associated with a particular
duration of a stay. There must be at least one rate with
range_start_seconds set to 0 and there cannot be gaps between
durations (i.e. there should be no interval uncovered between 0 and
the largest range_end_seconds of any duration-based rate).
taxIncluded (type: boolean(), default: nil) - If true, tax is
included in the prices in this rate. If false, additional taxes may
apply.
validEndWithin (type:
[Link]
Proto.t,default: nil) -
validStartWithin (type:
[Link]
Proto.t,default: nil) - Time period during which utilization of
this rate must start in order to be eligible for the rate. If not set,
there is no restriction on the time when the utilization starts.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

durationBasedRate:

[[Link].t()]
| nil,

taxIncluded: boolean() | nil,

validEndWithin:

[Link].t() | nil,
validStartWithin:

[Link].t() | nil
}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
oto
Attributes

componentType (type: String.t, default: nil) -

interval (type:
list([Link]
default: nil) - The time component is the
ervalProto.t),
intersection of these intervals

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

componentType: String.t() | nil,
interval:
[[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
o
Not all combinations of optional fields in TimeEndpointProto are
allowed. The granularity of time is a path along the directed graph with
these edges: second -> minute minute -> hour hour -> day of week hour
-> day of month hour -> day of year day of week -> week of month day
of week -> week of year day of month -> month day of year -> year
week of month -> month week of year -> year month -> year A
TimeEndpointProto may not specify two fields that are unordered with
respect to each other ("day of year" and "day of week", for instance).
The absence of fields larger than any specified field indicates repetition
(e.g. no year indicates that the interval occurs every year). The absence
of units that are "smaller" than the largest specified unit indicates a
default lowest value (no hour means midnight (0)). When intersecting
time intervals, "smaller" units repeat within the "larger" unit as many
times as necessary. For example, the intersection of the interval from
hour 0 to hour 24 with the interval from second 0 to second 1 is
equivalent to the union of the set of intervals which represents the first
second of every minute of every hour of every day. --------------------------
--------------------------------------------------- WARNING - if you add new
fields to TimeEndpointProto you need to: - ensure
AreTimeEndpointsEquivalent considers the new fields (and update the
corresponding tests) ---------------------------------------------------------------
--------------

Attributes

(type: integer(), default: nil) - Valid ranges are 0-7, 1-31,

day
and 1-366 (see day_type below)
 dayType (type: String.t, default: nil) -
hour (type: integer(), default: nil) - Valid range is 0-24.
Because it could be unclear what wrapping hours mean in relation
to days, 24 is used to denote midnight at the end of a day.
minute (type: integer(), default: nil) - Valid range is 0-59,
except when a repetitive minute interval ends at the end of an hour,
in which case 60 is a legal end value.
month (type: String.t, default: nil) -
second (type: integer(), default: nil) - Valid range is 0-59,
except when a repetitive second interval ends at the end of a
minute, in which case 60 is a legal end value.
week (type: integer(), default: nil) - Valid ranges are 0-5 and 1-
53 (depending on the value of week_type, see below).
weekType (type: String.t, default: nil) -
year (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

day: integer() | nil,

dayType: String.t() | nil,

hour: integer() | nil,

minute: integer() | nil,

month: String.t() | nil,

second: integer() | nil,

week: integer() | nil,
weekType: String.t() | nil,
year: integer() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

begin (type:
[Link]
Proto.t,default: nil) - Begin and end are used to specify a range
of times: [begin, end). If one is present, the other must be present as
well. Additionally, both must have matching time granularities - all
fields specified in the begin TimeEndpointProto must be present in
the end TimeEndpointProto and vice-versa. Hours are not allowed
to wrap ([Link]() <= [Link]()).
end (type:
[Link]
Proto.t, default: nil) -
inverted (type: boolean(), default: nil) - If true, then this
interval actually encodes the complement of the specified occasion
or range. For example, the following TimeIntervalProto encodes all
times other than the month of May. TimeIntervalProto[ type =
TYPE_RANGE inverted = true begin = TimeEndpointProto[ month
= MAY ] end = TimeEndpointProto[ month = JUNE ] ]
occasion (type: String.t, default: nil) - clang-format on
type (type: String.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

begin:
[Link].t() | nil,
end: [Link].t() | nil,

inverted: boolean() | nil,

occasion: String.t() | nil,

type: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.
[Link].V1.
[Link]
Attributes

component (type:
list([Link]
ponentProto.t), default: nil) - The schedule is the union of these
components.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{

component:
[[Link].t()] | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A TimezoneProto holds information about a feature's related time zone.

Attributes

id(type: String.t, default: nil) - i18n recognized time zone

identifier. For the full list of identifiers, see
google3/i18n/identifiers/data/[Link].
metadata (type:
[Link]
aProto.t, default: nil) - Field-level metadata for this relation.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

id: String.t() | nil,
metadata:
[Link].t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A collection of information that applies to a toll cluster.

Attributes

intersection (type:
list([Link]
IdProto.t),default: nil) - The list of gcid:toll_intersection
features that this toll cluster. A toll cluster can consist of either a
single or a group of intersection points called toll intersections at
the end of various road segments in MapFacts that represent one or
more lanes passing through a toll fixture that all go to the same
routing destination. This relationship is reciprocal, as a toll
intersection also stores a reference to the toll cluster it belongs to. A
toll cluster must have a reference to one or more toll interections
(i.e. toll_cluster.intersection should always be populated).

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

intersection:
[[Link].t()] | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A TollPathProto describes the sequential travel across one or more
/geo/type/toll_cluster features. Traveling across a toll path may entail
paying a fee, buying a toll pass, etc (although we don't model this in
FeatureProto). To travel across a toll path, one must travel between toll
clusters in the exact order specified. See go/geo-schema:toll-paths for
more information.

Attributes

tollClusterSequence (type:
[Link]
default: nil) - Details the
oTollClusterSequence.t,
/geo/type/toll_cluster features which constitute this toll path.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

tollClusterSequence:

[Link].t()

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
edTollCluster
A /geo/type/toll_cluster and its position along a toll path.

Attributes

cluster (type:
[Link]
default: nil) - The /geo/type/toll_cluster feature at this
to.t,
position.
index (type: integer(), default: nil) - The position along the
path where this cluster appears.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link]{
cluster:

[Link].t() | nil,
index: integer() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
lusterSequence
The set of toll clusters in a toll path, along with their position in the path.

Attributes

indexedTollClusters (type:
list([Link]
hProtoIndexedTollCluster.t),default: nil) - There must be at
least one toll cluster in a toll path, and there may not be duplicates.
For ordering, one should rely on
[Link], rather than the repeated field
ordering (elements may be shuffled). This is a unidirectional
reference - toll clusters do not reference the toll paths they're a part
of. The toll clusters themselves may be part of multiple toll paths.

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link]{
indexedTollClusters:

[Link].t()
]
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

index (type: integer(), default: nil) - The index of this

TrackProto in a list of TrackProtos.
pose (type:
list([Link]
default: nil) - The instantaneous pose of points along this
to.t),
track. The fields set inside each pose must be set consistently along
the track.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

index: integer() | nil,

pose: [[Link].t()] | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A transit line is a named set of transit trips that are advertised to
passengers under a common name, and a number of attributes that are
true for all those trips. There is no requirement for each trip to travel
through the same list of stops or use the same legs, so a line can contain
trips in opposite directions or with variations in the sequence of stops.
See go/oysterpedia for an overview of the transit feature types. The
standard feature properties are interpreted as follows: name - The names
of this line, including both long and short names, if available. Short
names like "10" or "Blue" should carry the FLAG_ABBREVIATED,
long names like "Dublin/Pleasanton line" should not. The preferred
name (one per language) for displaying the line on its own (e.g., as a
search result for the line) should carry the FLAG_PREFERRED. website
- The official web page describing this line. Repeated if multilingual.
Line features have no geometry (neither points nor polylines nor
polygons). Within Transit Oyster, geometry can be found in legs.
Additional data only in Transit Oyster: child - The legs of this line, in no
particular order. source_info - Specifies the GTFS routes that match this
feature. Each is given as a PROVIDER_GOOGLE_TRANSIT
source_info where dataset is the feed name and cookie is the route_id.

Attributes

agency (type:
list([Link]
default: nil) - The transit agencies responsible for
IdProto.t),
operating this line. All lines should have at least one agency, and
most will have exactly one. The following cases are reasons for
multiple agencies: - Code share: Two or more agencies share trips -
Alternations: Each trip is run by one of multiple agencies -
 Additional: All trips run by one agency, but a second one sells
tickets In all cases the order has no meaning. Clarification comes
from the trips.
labelBackgroundColor (type: integer(), default: nil) - The
background color of labels for that transit line. The encoding is like
in HTML or CSS, eg. 0x11ff00 means a bit of red, full green, no
blue, in sRGB color space. The most significant byte must be zero,
i.e. no transparency.
labelTextColor (type: integer(), default: nil) - The text color
of labels for that transit line. Encoding like label_background_color.
stations (type:
list([Link]
IdProto.t),default: nil) - The transit stations (establishment
POIs with gcid:transit_station) which this transit line can go
through, in no particular order. Usage note: The source of truth are
the transit leg features in Transit Oyster. In MapFacts, that
information is cached in two locations: in this field, and in transit
station attachments on POIs. Do not assume these locations are
always up to date and/or synchronized with each other.
vehicleType (type: String.t, default: nil) - The type of vehicle
that applies to all trips that use this line.

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

agency:
[[Link].t()] | nil,

labelBackgroundColor: integer() | nil,

labelTextColor: integer() | nil,
stations:
[[Link].t()] | nil,
vehicleType: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Proto
A line variant is a specific instantiation of a line concept, denoted by the
ordered set of stops and collection of segments that it traverses. Line
variants are modeled as TYPE_ROUTE features with
gcid:transit_line_variant. This proto stores line-variant-specific
information that is not generally applicable to all routes. Schema Design
Doc: go/transit-line-concepts-and-variants

Attributes

lineConcept (type:
[Link]
default: nil) - Reference to the line variant’s line concept.
to.t,
stops (type:
list([Link]
default: nil) - Ordered list of stations or
dStopProto.t),
platforms serviced by this line variant. The order is captured by the
[Link] field.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link]{
lineConcept:

[Link].t() | nil,
stops:
[[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
o
Encapsulates information related to an individual transit station.

Attributes

agencyAssociations (type:
list([Link]
default: nil)
StationProtoTransitAgencyAssociationProto.t),
- All the transit agencies which service this station. A station can be
serviced by multiple stations. There may only be one agency
association per transit agency. See go/transit-agency-relation-
migration for more details.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

agencyAssociations:
[

[Link]
iationProto.t()
]

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
oTransitAgencyAssociationProto
The association between this station and the agency which services this
station.

Attributes

agency (type:
[Link]
to.t,default: nil) - The transit agency which services this station.
stationCode (type: String.t, default: nil) - A station code
uniquely identifies a transit station within the transit agency's
network.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link]
ciationProto{

agency:
[Link].t() | nil,
stationCode: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

sourceTrust (type:
[Link]
default: nil) - Trust signals for the source of a given
roto.t,
observation, typically based on historical evidences or status (like
internal Google operator).

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{
sourceTrust:
[Link].t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
to
A speed limit without a limit value. Used to indicate the absence of a
speed limit.

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Hold a list of URLs, usually to contain translations of a single URL.

Attributes

url (type:
list([Link]
o.t), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{
url: [[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A web location for a Feature. URLs should always be stored in repeated
fields because some objects (eg. transit schedules in Brussels) have
different URLs for different languages.

Attributes

language (type: String.t, default: nil) - The external form of a

Google International Identifiers Initiative (III) LanguageCode
object. See google3/i18n/identifiers/languagecode.h for details. We
place extra restrictions on languages in addition to what the III
library requires. See [Link]
properties/[Link] This field represents the language of the
content of the web site. It may be missing if the web site is
language-independent or if the language is unknown.
metadata (type:
[Link]
default: nil) - Field-level metadata for this URL.
aProto.t,
NOTE: there are multiple UrlProto fields in the Geo Schema.
Metadata here is only expected to be present on
[Link][].
pagerank (type: integer(), default: nil) - DEPRECATED The
pagerank of this URL. Valid values [0, 65535] See
[Link] for more information.
url (type: String.t, default: nil) - The URL.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

language: String.t() | nil,

metadata:
[Link].t() | nil,

pagerank: integer() | nil,

url: String.t() | nil
}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
UserProto identifies a (human) user of Geo Data. Its primary use is in
describing the source of pieces of data (e.g. edits). It could be a simple
identifier, but isn't so that we can store it in the clear while still
preventing correlation between a user's contribution.

Attributes

encryptedGaiaId (type: String.t, default: nil) - The user Gaia

ID in encrypted form. Wipeout ids take value of "" in bytes.
encryptionKeyName (type: String.t, default: nil) - Required.
The name of the key used to encrypt the Gaia ID.
keystoreConfigId (type: integer(), default: nil) - Required
(valid default provided). The config ID of the owner of the above
encryption_key_name. This field must be set if the encryption key
name is not "mapfacts_gaia_id_encryption_key".
username (type: String.t, default: nil) - If possible, writers
should set this to a full user email, including the domain. Readers
should not assume that this is a well-formed email address. This
field may only be set by Atlas, Pushpin and OneRing because they
are internal tools which have a PWG exception to store textual
usernames in the clear.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

encryptedGaiaId: String.t() | nil,
encryptionKeyName: String.t() | nil,
keystoreConfigId: integer() | nil,
username: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
o
A speed limit whose value can change based on road, traffic, and
weather conditions.

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
terProto
A set of vehicle attribute conditionals (ex: weight >= 20T &&
num_trailers = 2) used to define a slice of all possible vehicles. This can
be useful for filtering one or more vehicles by a predicate.

Attributes

axleCount (type:
list([Link]
mparisonProto.t), default: nil) - A repeated value here is treated
as an AND operation. This allows for ranges to be represented by
two values (ex: "count < 4" AND "count >= 2" means "2 <= count
< 4").
hasTrailer (type: boolean(), default: nil) - Whether the
applied vehicle types have a trailer attached to them.
hazardousGoods (type: list(String.t), default: nil) - List of
prohibited hazardous goods for a vehicle to carry. A repeated value
here is treated as an OR operation, meaning that they may not carry
ANY of the goods listed.
numTrailers (type:
list([Link]
mparisonProto.t), default: nil) - A repeated value here is treated
as an AND operation. This allows for ranges to be represented by
two values (ex: "count <= 4" AND "count > 2" means "2 < count
<= 4").
trailerLength (type:
list([Link]
onComparisonProto.t), default: nil) - A repeated value here is
 treated as an AND operation. This allows for ranges to be
represented by two values (ex: "length <= 53ft" AND "length >
48ft" means "48ft < length <= 53ft").
vehicleHeight (type:
list([Link]
onComparisonProto.t), default: nil) - A repeated value here is
treated as an AND operation. This allows for ranges to be
represented by two values (ex: "height > 3m" AND "height <= 5m"
means "3m < height <= 5m").
vehicleLength (type:
list([Link]
onComparisonProto.t), default: nil) - A repeated value here is
treated as an AND operation. This allows for ranges to be
represented by two values (ex: "length <= 40m" AND "length >
35m" means "35m < length <= 40m").
vehicleWeight (type:
list([Link]
omparisonProto.t),default: nil) - A repeated value here is
treated as an AND operation. This allows for ranges to be
represented by two values (ex: "weight < 8T" AND "weight >= 3T"
means "3T <= weight < 8T").
vehicleWidth (type:
list([Link]
default: nil) - A repeated value here is
onComparisonProto.t),
treated as an AND operation. This allows for ranges to be
represented by two values (ex: "width < 4m" AND "width >= 2m"
means "2m <= width < 4m").

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link]{
axleCount:
[[Link].t()] | nil,
hasTrailer: boolean() | nil,
hazardousGoods: [String.t()] | nil,

numTrailers:
[[Link].t()] | nil,
trailerLength:
[[Link].t()]
| nil,
vehicleHeight:
[[Link].t()]

| nil,
vehicleLength:
[[Link].t()]
| nil,
vehicleWeight:
[[Link].t()]
| nil,
 vehicleWidth:

[[Link].t()]
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
oto
A proto representing a vertical ordering of a feature. NOTE: This
shouldn’t be used if a more specific field can be used instead. E.g., for
TYPE_SEGMENT features grade_level field should be preferred. For
indoor features RELATION_ON_LEVEL should be preferred. See
go/aboutgrades for comparison of various types of levels available.

Attributes

level (type: number(), default: nil) - The level represents the

relative vertical ordering of a feature among all overlapping
features. For example, we may have features along freeway surface
have level = 0, and features on an overpass have level = 1. NOTE:
It’s assumed that all features have level 0 by default, so that it’s not
necessary for all overlapping features to have this set.

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

level: number() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Proto
A weight value tagged with a comparison operator.

Attributes

comparison(type: String.t, default: nil) -

comparisonOperator (type: String.t, default: nil) -
weightWithUnit (type:
[Link].
t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

comparison: String.t() | nil,
comparisonOperator: String.t() | nil,
weightWithUnit:
[Link].t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A weight with a numerical value and unit.

Attributes

unit(type: String.t, default: nil) -

weight (type: number(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{
unit: String.t() | nil,
weight: number() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
An anchor label can be attached to any element to give it a reference
address. LogicalEntity links (see [Link]) may use
anchor labels to point to goodoc elements (they may also use indices to
locate the element, but the indices could become invalid if the goodocs
are allowed to mutate). Multiple elements may have the same anchor.

Attributes

Anchor(type: String.t, default: nil) - There is a generic

method for composing such strings. Please take a look at
GoodocUtils::GenerateUniqueAnchorName(...) in
ocr/goodoc/goodoc-utils.h.
anchorScope (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

Anchor: String.t() | nil,

anchorScope: integer() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Bounding box for page structural elements: pictures, paragraphs,
characters, etc.

Attributes

Height(type: integer(), default: nil) -

Label (type: integer(), default: nil) - Optional magic label, so
objects can be sorted on bounding box dimensions easily
Left (type: integer(), default: nil) - BoundingBox coordinates
and sizes are expressed in pixels
Top (type: integer(), default: nil) -
Width (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

Height: integer() | nil,
Label: integer() | nil,
Left: integer() | nil,

Top: integer() | nil,

Width: integer() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A way to specify a simple partitioning of a BoundingBox into a
sequence of sub-boxes. +----------------------------------------------------+ | |
| | | | | span(0) | (1) | (2) | (3) | (4) | | | | | | | +--------------------------------------
--------------+ This representation can, for example, be used to store
coarse Symbol boundaries within a Word (see
[Link] below) instead of per-Symbol
BoundingBoxes, for saving space.

Attributes

direction (type: integer(), default: nil) -

span (type: list(integer()), default: nil) - "span" is width or
height, determined by "direction". If there are k partitions, then
there are k - 1 "span" values, one for each except the last symbol
(which is redundant).

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

direction: integer() | nil,

span: [integer()] | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Break label

Attributes

BreakLabelType (type: integer(), default: nil) -

isPrefix (type: boolean(), default: nil) - True if break
prepends the element

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{
BreakLabelType: integer() | nil,

isPrefix: boolean() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Font label

Attributes

BaseLine (type: integer(), default: nil) - The shift of a

character from the base line of the string in pixels
CharacterHeight (type: integer(), default: nil) - Height of
small characters in pixels on the source image
Color (type: integer(), default: nil) - The foreground color of
the symbol; the default color is 0 (black)
Confidence (type: integer(), default: nil) - Symbol recognition
confidence from OCR. Range depends upon OCR Engine.
FontId (type: integer(), default: nil) - The font ID refers to the
fonts table in the document header
FontSize (type: integer(), default: nil) - Size in points (JFYI:
point is 1/72"). This is rounded to the nearest whole number.
FontSizeFloat (type: number(), default: nil) - Size in points
represented as float.
FontType (type: integer(), default: nil) -
HasUncertainHeight (type: boolean(), default: nil) - If
CharacterHeight is defined uncertainly
HorizontalScale (type: integer(), default: nil) - The
horizontal scaling for a character, in percents. The default value for
this property is 100, which corresponds to no scaling.
IsBold (type: boolean(), default: nil) -
IsItalic (type: boolean(), default: nil) -
IsSmallCaps (type: boolean(), default: nil) -
IsStrikeout (type: boolean(), default: nil) -
IsSubscript (type: boolean(), default: nil) -
 IsSuperscript (type: boolean(), default: nil) -
IsSuspicious (type: boolean(), default: nil) - If OCR Engine
marked the character as "suspicious" (this character is likely to be
recognized incorrectly).
IsUnderlined (type: boolean(), default: nil) -
NotOcrablePerQA (type: boolean(), default: nil) - True if a QA
operator has marked this as not OCRable. This is used for complex
equations, scripts that the operator can't type, or handwriting.
Penalty (type: integer(), default: nil) - Symbol-level penalty
from the garbage text detector. Lower is better; range = [0,100].
SerifProbability (type: integer(), default: nil) - The
probability that a character is written with a Serif font

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{

BaseLine: integer() | nil,

CharacterHeight: integer() | nil,

Color: integer() | nil,

Confidence: integer() | nil,
FontId: integer() | nil,

FontSize: integer() | nil,

FontSizeFloat: number() | nil,

FontType: integer() | nil,

HasUncertainHeight: boolean() | nil,
HorizontalScale: integer() | nil,
IsBold: boolean() | nil,
IsItalic: boolean() | nil,
IsSmallCaps: boolean() | nil,
IsStrikeout: boolean() | nil,
IsSubscript: boolean() | nil,

IsSuperscript: boolean() | nil,

IsSuspicious: boolean() | nil,

IsUnderlined: boolean() | nil,

NotOcrablePerQA: boolean() | nil,

Penalty: integer() | nil,

SerifProbability: integer() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Top-level representation of OCRed document

Attributes

EditingHistory (type: list(String.t), default: nil) - Debug

info, recording the history of any editing done through the interface
in goodoc-editing.h. The strings look like
"MoveParagraph(page_index = 0, source_block_index = 3, ...);
LogicalEntity (type: list(String.t), default: nil) - Logical
entities are stored as blobs. Depending on the kind of thing this is a
goodoc of, a separate .proto file is expected to define the logical
entity structure. Hence we can still parse this as a goodoc for people
who dont care about this, and people who care about this can parse
it specifically. ocr/goodoc/logical-entity-utils.h has methods to read
and write these. See Goodoc++ doc
LogicalEntityMessageName (type: list(String.t), default:
nil) - The names of the proto messages serialized in LogicalEntity,
one for each LogicalEntity. The repetitions should number 0 to
leave this unspecified, or they should equal the number of
LogicalEntity strings.
SubDocuments (type:
list([Link].
default: nil) - For multi-goodoc documents
t),
header (type:
[Link]
default: nil) -
.t,
page (type:
list([Link]
age.t), default: nil) -
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

EditingHistory: [String.t()] | nil,

LogicalEntity: [String.t()] | nil,

LogicalEntityMessageName: [String.t()] | nil,
SubDocuments: [t()] | nil,
header: [Link].t() | nil,
page: [[Link].t()] | nil
}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

OcrEngineId (type: String.t, default: nil) -

OcrEngineVersion (type: String.t, default: nil) -
font (type:
list([Link]
eaderFont.t), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{
OcrEngineId: String.t() | nil,
OcrEngineVersion: String.t() | nil,
font: [[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
nt
Attributes

FontId(type: integer(), default: nil) -

FontName (type: String.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{
FontId: integer() | nil,
FontName: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

GarbageDetectorChangeList (type: integer(), default: nil) - If

the garbage text detector was run, the changelist that the binary was
sync'ed to (or -1 if unknown), and whether the settings had their
production values (or false if unknown).
GarbageDetectorWasProduction (type: boolean(), default: nil)
-
Height (type: integer(), default: nil) - Height in pixels
HorizontalDpi (type: integer(), default: nil) - Horizontal
resolution in DPI.
Label (type:
[Link].t,
default: nil) -
PornScore (type: float(), default: nil) - Score of porn classifier
from analyzing images on page. Note: This should be named
porn_score, but we use PornScore as the name in order to be
consistent with the rest of this proto.
TextConfidence (type: integer(), default: nil) - Page text
recognition confidence. Range depends on the algorithm but should
be consistent in a given volume. 0 is bad, 100 is good.
VerticalDpi (type: integer(), default: nil) - Vertical resolution
in DPI.
Width (type: integer(), default: nil) - Width in pixels
block (type:
list([Link]
default: nil) -
ageBlock.t),
mergedpageinfo (type:
list([Link]
 ageMergedPageInfo.t),default: nil) -
postOcrConfidence (type: boolean(), default: nil) - Whether
page-level text confidences and other summary data were computed
by PostOcrUtils instead of the now-obsolete GarbageTextDetector
stats (type:
[Link].t
, default: nil) - Page level stats (font size, line spacing, etc.)

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

GarbageDetectorChangeList: integer() | nil,
GarbageDetectorWasProduction: boolean() | nil,
Height: integer() | nil,
 HorizontalDpi: integer() | nil,

Label: [Link].t() | nil,

PornScore: float() | nil,

TextConfidence: integer() | nil,

VerticalDpi: integer() | nil,
Width: integer() | nil,
block:
[[Link].t()] | nil,

mergedpageinfo:
[[Link].t()]
| nil,
postOcrConfidence: boolean() | nil,
stats: [Link].t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

BlockType(type: integer(), default: nil) -

Box (type:
[Link].t,
default: nil) -
Label (type:
[Link].t,
default: nil) -
OrientationLabel (type:
[Link]
el.t,default: nil) - Which way is upright for this block, and what
is the reading order (applicable if there is text here).
Paragraph (type:
list([Link]
default: nil) -
.t),
RotatedBox (type:
[Link]
gBox.t,default: nil) - If RotatedBox is set, Box must be set as
well. See RotatedBoundingBox.
TextConfidence (type: integer(), default: nil) - Block text
recognition confidence. Range depends on the algorithm but should
be consistent in a given volume. 0 is bad, 100 is good.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

BlockType: integer() | nil,

Box: [Link].t() | nil,

Label: [Link].t() | nil,

OrientationLabel:
[Link].t() | nil,
Paragraph: [[Link].t()] | nil,
RotatedBox:

[Link].t() | nil,
TextConfidence: integer() | nil
}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
edPageInfo
If we have merged text from another goodoc into this one (for example,
from a PDF text layer goodoc into an OCR'd goodoc), we record some
source goodoc info here.

Attributes

OcrEngineId(type: String.t, default: nil) -

OcrEngineVersion (type: String.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link]{
OcrEngineId: String.t() | nil,
OcrEngineVersion: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Statistics about a particular font size (from [Link])
aggregated over a range of symbols

Attributes

fontId (type: integer(), default: nil) - [Link] and

FontSize
fontSize (type: integer(), default: nil) -
medianHeight (type: integer(), default: nil) - The
measurements are in pixels
medianLineHeight (type: integer(), default: nil) - top to
bottom
medianLineSpace (type: integer(), default: nil) - bottom to
next top in para
medianLineSpan (type: integer(), default: nil) - top to next top
in para
medianWidth (type: integer(), default: nil) -
numLineSpaces (type: integer(), default: nil) - Lines (out of
num_lines) that have a successor line within their para
numLines (type: integer(), default: nil) - Line stats for this
font. "top" corresponds to the highest ascender and "bottom" to the
lowest descender. num_lines = # lines with > 50% symbols having
this font
numSymbols (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

fontId: integer() | nil,

fontSize: integer() | nil,

medianHeight: integer() | nil,

medianLineHeight: integer() | nil,

medianLineSpace: integer() | nil,

medianLineSpan: integer() | nil,
medianWidth: integer() | nil,

numLineSpaces: integer() | nil,

numLines: integer() | nil,
numSymbols: integer() | nil
}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Label aggregates all kinds of optional characteristics of page elements.

Attributes

AnchorLabel (type:
list([Link]
default: nil) - AnchorLabel identifies a link target.
el.t),
BreakLabel (type:
[Link].t,
default: nil) -
CharLabel (type:
[Link].t,
default: nil) - CharLabel is specifically intended for symbols
LanguageLabel (type:
list([Link]
default: nil) - Languages used in the element (page,
abel.t),
block, paragraph or word). Ordered by dominant-language first.
Note: content scanjobs processed by the garbage_text_detector
before CL 9223538 (Dec. 2008) have LanguageLabels in arbitrary
order (within Page and Block elements) -- the confidence value
should be inspected to find the dominant language guess for these,
rather than just taking the first.
SemanticLabel (type:
[Link].
t,default: nil) - SemanticLabel is defined in goodoc-
[Link], it allows rich annotation of content, identifying the
nature of page elements.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

AnchorLabel:
[[Link].t()] | nil,
BreakLabel: [Link].t() | nil,
CharLabel: [Link].t() | nil,
LanguageLabel:
[[Link].t()] | nil,

SemanticLabel:
[Link].t() | nil

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
onLanguage
Weighted language

Attributes

bcp47Tag (type: String.t, default: nil) - Bcp47 language code.

Note, this is not the same as OceanCode used by
goodoc::Document.
weight (type: number(), default: nil) - Weight of language. This
specifies how likely it is to see the language in the input text. The
values don't have to add up to 1.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link]{
bcp47Tag: String.t() | nil,
weight: number() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Language label

Attributes

ClosestLanguageId (type: integer(), default: nil) - Closest id

from i18n/languages/proto/[Link]; caveat: may not
accurately capture the language.
GoodocLanguageCodeToLanguage() declared in
ocr/goodoc/goodoc-utils.h may be used to convert a Language
enum (i18n/languages/proto/[Link]) to a string suitable for
this field.
Confidence (type: integer(), default: nil) - Confidence level
on that language, between 0 and 100
LanguageCode (type: String.t, default: nil) - Old (Ocean)
Language Code Usage: The language code is inferred during the
running of the Garbage Text Detector and gets set at the paragraph,
block and page level. Language code is a string of 3 or more
characters. The first 3 letters specify the language, according to ISO
639. Optionally, the 3-letter code can be extended with an
underscore and a language variant specifier. Specifiers exist for
regional variants or for different forms of language spelling. The
regional variants are specified as 2-letter country code, according to
ISO 3166. Some examples: Standard "por" - Portuguese, standard
"rus" - Russian, standard Regional variants: "por_br" - Portuguese,
Brazilian "eng_us" - English, United States Variants of spelling:
"rus_old" - Russian, old spelling "chi_tra" - Chinese, traditional
"ger_new" - German, new spelling
LanguageToGoodocLanguageCode() declared in
ocr/goodoc/goodoc-utils.h may be used to convert a Language
 enum (i18n/languages/proto/[Link]) to a string suitable for
this field. New Language Code Usage: Most of the usages
described above were standardized in BCP 47, and these codes are
the new stanadard to be used in this field. To load either new or old
language codes to form LanguageCode objects, use the function
FromOceanCode() in ocr/quality/lang_util.h Note that the function
ocr::FromOceanCode is capable of transforming either version of
the LanguageCode to a C++ i18n_identifiers::LanguageCode.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

ClosestLanguageId: integer() | nil,
Confidence: integer() | nil,
 LanguageCode: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A logical entity in the abstract is just a group of links to the goodoc.
Depending on the kind of item, a separate proto file should extend this to
define the logical structure for that kind. For example. [Link]
defines the logical entity for newspapers. LogicalEntity is also used
within some SemanticLabels, for example, for a table-of-contents link.

Attributes

Metadata (type: String.t, default: nil) -

link (type:
list([Link]
tityLink.t), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

Metadata: String.t() | nil,
link: [[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
NOTE(gponcin) 2008/11 This is repeated for articles where we may
have multiple links in one entity. From Vivek (Atlantis): "The block
segmenter outputs a list of headlines on a page as a single logical entity
that we attach to the logicalentity(1) for the goodoc."

Attributes

Anchor (type: String.t, default: nil) - The preferred way to link

to an element is to create an AnchorLabel in the target element and
name it here. Multiple elements may contain the same Anchor
string.
BlockId (type: integer(), default: nil) -
DocId (type: integer(), default: nil) - Links may also
specifically locate the target element with the following indices.
Note that during the course of layout analysis, goodoc elements
may move around, so such hard links should be created only very
late (or not at all -- Anchors would be more reliable target
addresses).
PageId (type: integer(), default: nil) -
ParagraphId (type: integer(), default: nil) -
RouteId (type: integer(), default: nil) -
SymbolId (type: integer(), default: nil) -
Url (type: String.t, default: nil) - If not defined, link points to
the current doc
WordId (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

Anchor: String.t() | nil,
BlockId: integer() | nil,
DocId: integer() | nil,
PageId: integer() | nil,
ParagraphId: integer() | nil,

RouteId: integer() | nil,

SymbolId: integer() | nil,

Url: String.t() | nil,

WordId: integer() | nil

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
An Ordinal message represents a single ordinal component of a page
number. It encodes the printed or inferred numbering style (Roman,
ASCII, etc.) and the ordinal value of the component. An optional set of
variable is defined in order to express a sectioned ordinal. A sectioned
ordinal may appear in certain page numbering styles, for example "12-1"
where "12" identifies a chapter and "1" identifies the page within it. This
case will be encoded with value 1 and section_value 12 both of type
ASCII.

Attributes

implicit (type: String.t, default: nil) -

sectionStringValue (type: String.t, default: nil) -
sectionValue (type: integer(), default: nil) -
sectionValueType (type: String.t, default: nil) - The
following vars describe the section component of an ordinal (if
exists). They are used to express situation where a page number has
a section component, usually denoating the chapter number. For
example pages 5-14, 5-15 will both have the common section 5. (If
exists). The semantcis of the section variables correspond to that of
the primary part of the ordinal. (Described above).
stringValue (type: String.t, default: nil) - The string page
value.
value (type: integer(), default: nil) - The numeric page value.
valueDelta (type: String.t, default: nil) - The delta in which
the value increases between pages.
valueType (type: String.t, default: nil) - A value type from the
Type enum above.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

implicit: String.t() | nil,
sectionStringValue: String.t() | nil,
sectionValue: integer() | nil,
sectionValueType: String.t() | nil,
stringValue: String.t() | nil,

value: integer() | nil,

valueDelta: String.t() | nil,

valueType: String.t() | nil

}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
OrientationLabel groups the details about orientation and reading order.

Attributes

deskewAngle (type: number(), default: nil) - After rotating so

that the text orientation is upright, how many radians does one have
to rotate the block anti-clockwise for it to be level? We guarantee: -
Pi/4 <= deskew_angle <= Pi/4
mirrored (type: boolean(), default: nil) - Whether a text line is
mirrored (e.g. reflected in a shiny surface or seen through the
opposite side of a storefront window). The intent is that this is a
quality of the text line image. It needs to be reflected according to a
vertical axis along the direction of upright characters to make it
readable. This does not affect the shape of the bounding box. A
mirrored line with top to bottom writing remains top to bottom. A
mirrored horizontal line will flip left to right. However any child
entities (symbols) will remain in the same order, and the writing
direction imposed by the language (ltr or rtl) will remain the same.
orientation (type: String.t, default: nil) -
textlineOrder (type: String.t, default: nil) -
writingDirection (type: String.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

deskewAngle: number() | nil,
mirrored: boolean() | nil,
orientation: String.t() | nil,
textlineOrder: String.t() | nil,
writingDirection: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
This message specifies structure "overrides" to apply: it can be used to
force certain kinds of GoodocToHTML renderings of elements.

Attributes

blockImagination (type: String.t, default: nil) - For text

blocks only: do not allow this block to be turned into an image
when rendering, even if your algorithms want to do so:
doNotExpandGraphicBox (type: boolean(), default: nil) - For
graphic blocks, we often expand the block a bit for rendering, to
compensate for bad image segmentation.
do_not_expand_graphic_box forces this behavior to be turned off.
fullPageAsImage (type: String.t, default: nil) - For Pages
only: explicitly specify whether or not this page should be rendered
fully as an image
fullPageLineated (type: String.t, default: nil) - For Pages
only: explicitly specify whether or not all text on this page should
be treated as "LINEATED"
fullPageSkipped (type: String.t, default: nil) - For Pages
only: explicitly specify whether or not this page should be skipped.
needNotSuppressPhoto (type: boolean(), default: nil) - This
GRAPHIC block's image can be shown even when
GoodocToHTMLOptions.suppress_photos_with_this is specified.
pageBreakBefore (type: String.t, default: nil) - For blocks:
explicitly specify whether or not this block should get a page-break
before it.
style (type:
list([Link]
Style.t), default: nil) -
 wordHtml (type: String.t, default: nil) - For Words only:
replace the rendered HTML by this:

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

blockImagination: String.t() | nil,
doNotExpandGraphicBox: boolean() | nil,
fullPageAsImage: String.t() | nil,
fullPageLineated: String.t() | nil,
fullPageSkipped: String.t() | nil,
needNotSuppressPhoto: boolean() | nil,
pageBreakBefore: String.t() | nil,
style: [[Link].t()] | nil,
 wordHtml: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Extra css styles to apply

Attributes

name (type: String.t, default: nil) - css attribute name: "margin-

left", for eg.
value (type: String.t, default: nil) - css attribute vale: "1em",
for eg.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

name: String.t() | nil,
value: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Represents a paragraph of text in OCRed content.

Attributes

Box (type:
[Link].t,
default: nil) -
FirstLineIndent (type: integer(), default: nil) -
Label (type:
[Link].t,
default: nil) -
LeftIndent (type: integer(), default: nil) -
LineSpacing (type: integer(), default: nil) -
OrientationLabel (type:
[Link]
default: nil) - Which way is upright for this paragraph and
el.t,
what is the dominant reading order?
RightIndent (type: integer(), default: nil) -
RotatedBox (type:
[Link]
gBox.t,default: nil) - If RotatedBox is set, Box must be set as
well. See RotatedBoundingBox.
SpaceAfter (type: integer(), default: nil) -
SpaceBefore (type: integer(), default: nil) -
SubsumedParagraphProperties (type:
list([Link]
default: nil) - If we merge any paragraphs into this one
.t),
(through the MergeParagraphWithNext() interface in goodoc-
editing.h), then we append the properties of the merged paragraph
 here, for debugging and to avoid losing any info. Note that the
SubsumedParagraphProperties Paragraphs do not contain Routes.
TextConfidence (type: integer(), default: nil) - Paragraph text
recognition confidence. Range depends on the algorithm but should
be consistent in a given volume. 0 is bad, 100 is good.
Width (type: integer(), default: nil) -
alignment (type: integer(), default: nil) -
droppedcap (type:
[Link]
edCap.t, default: nil) -
route (type:
list([Link]
Route.t), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{

Box: [Link].t() | nil,

FirstLineIndent: integer() | nil,

Label: [Link].t() | nil,

LeftIndent: integer() | nil,

LineSpacing: integer() | nil,

OrientationLabel:
[Link].t() | nil,
RightIndent: integer() | nil,
RotatedBox:
[Link].t() | nil,
SpaceAfter: integer() | nil,

SpaceBefore: integer() | nil,

SubsumedParagraphProperties: [t()] | nil,

TextConfidence: integer() | nil,

Width: integer() | nil,

alignment: integer() | nil,

droppedcap:

[Link].t() | nil,
route: [[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Cap
Information about the paragraph's dropped capital letter

Attributes

Box (type:
[Link].t,
default: nil) -
LettersCount (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

Box: [Link].t() | nil,

LettersCount: integer() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

EndPoint (type:
[Link].t,
default: nil) - Route end point
StartPoint (type:
[Link].t,
default: nil) - Route start point
Weight (type: integer(), default: nil) - Route weight, i.e. route
Word (type:
list([Link].t),
default: nil) - The array of words on this route

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

EndPoint: [Link].t() | nil,

StartPoint: [Link].t() | nil,

Weight: integer() | nil,
Word: [[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
x
Similar to [Link], but containing an angle of rotation,
thus able to represent non-axis-aligned boxes. RotatedBoundingBox can
be used in combination with BoundingBox to better represent non-axis-
aligned page structural elements. In such case, two bounding boxes can
be used per element. A RotatedBoundingBox that is rotated to tightly
encompass the element; embedded (as tightly as possible) inside an axis-
aligned BoundingBox. Note that there is some amount of ambiguity
regarding what angle and vertex to use. Consider a square with axis-
aligned diagonals: B / \ A C \ / D This can either be represented as a -45
degree rotation around A, a 45 degree rotation around B, a 135 degree
rotation around C, or a -135 degree rotation around D. Which one you
use depends on your use case, but one recommendation is to use the
vertex that would be top left if the reader was reading it in the 'natural'
orientation.

Attributes

Angle (type: number(), default: nil) - Angle of rotation of the

original non-rotated box around the top left corner of the original
non-rotated box, in clockwise degrees from the horizontal.
Height (type: integer(), default: nil) -
Left (type: integer(), default: nil) - Coordinates and sizes are
expressed in pixels, where the top-left pixel is (0, 0). The
coordinates refer to the corner of the top-left vertex of the unrotated
version of the box.
Top (type: integer(), default: nil) -
Width (type: integer(), default: nil) -
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

Angle: number() | nil,

Height: integer() | nil,

Left: integer() | nil,

Top: integer() | nil,

Width: integer() | nil

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Attributes

RouteIndex(type: integer(), default: nil) - The sequential

route number, starts at 0
WordIndex (type: integer(), default: nil) - The sequential word
number, starts at 0

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{
RouteIndex: integer() | nil,
WordIndex: integer() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Label identifying a logical part of the page content. This applies mostly
at Block level or Paragraph level (but can apply to Words or to arbitrary
spans if needed).

Attributes

AlternateText (type: String.t, default: nil) - Alternate text for

a sequence of the Goodoc, just for the element containing this label,
or for a sequence starting from this element to the
EndOfSpanningLabel. Typically this is inserted by automatic or
manual OCR correction. We use text instead of editing the Goodoc
directly since we dont usually have accurate symbol level bboxes
for the alternate text. Also the original values from OCR are
preserved. It is upto the application to do anything more intelligent
like mapping words and finding potential symbol/word bboxes.
Attribute (type: list(String.t), default: nil) - Page elements
can be given Attributes refining meaning/role. We keep this flexible
by using strings instead of pre-determined enum values. But it is
useful to list all such Attributes in use in ocr/goodoc/goodoc-
semantics-attributes.h
ChapterStart (type: boolean(), default: nil) - Blocks that are at
the beginning of chapters have this set:
CleanupAnnotation (type: list(integer()), default: nil) -
ContinuesFromPreviousPage (type: boolean(), default: nil) -
ContinuesFromPreviousPageHyphenated (type: boolean(),
default: nil) - When ContinuesFromPreviousPage=true, this bit
can be set to note that the word fragment on the previous page ends
in a hyphen.
ContinuesOnNextPage (type: boolean(), default: nil) -
Paragraphs that span across pages can be identified with the
following flags. Note that flows just connect Blocks across pages.
These continuation flags imply something more specific -- the case
of a single logical paragraph split over pages. Only the last
Paragraph in the last Block within a given FlowThread() on a page
can have ContinuesOnNextPage set. Similarly, only the first
Paragraph in the first Block with a given FlowThread() on a page
may have ContinuesFromPreviousPage set.
EndOfSpanningLabel (type:
[Link].
t, default: nil) - Normally, a SemanticLabel applies exactly to the
goodoc element that it is contained in (usually Block or Paragraph,
sometimes Word). Occasionally, we need a SemanticLabel to span
across the boundary or end before the boundary. For example, a
URL may just be a few words within a Paragraph. In such cases, the
SemanticLabel is added to the first element of the span and contains
this LogicalEntity pointing to the last element of the span:
ExperimentalData (type:
[Link].Proto2BridgeMessageS
default: nil) - Message set for experimental algorithm data.
et.t,
Use case: We keep a set of features that was computed for the
unsupervised caption extraction and store it here. Agora question
producer will consume this message set to be embedded in a
question. The experimental feature set can then be used later to pair
up with ground truth labels for designing a supervised algorithm.
Currently holding: o ocean/analysis/content/caption_data.proto's
TextualElement
Flow (type: String.t, default: nil) - Flow identifies a single
sequential unit of text (or other content). It is only set on Blocks -- a
flow identifies a sequence of Blocks. The default, main flow is just
the empty string. The "FlowThread" of a block is the flow (if non-
empty), suffixed with the block appearance. This is computed by
GoodocUtils::FlowThread(). Paragraphs may be split over blocks in
the same FlowThread, across pages. The following table shows how
FlowThread gets computed: ## Flow Appearance FlowThread
(empty) UNSPECIFIED "UNSPECIFIED" foo BODY
"foo:BODY" Please use lower-case strings for flows (such as
article-33-box). One useful way to think of flows is this: A logical
unit of interest in a a Document (for example, an article) would be
identified by a starting block, an ending block, and a list of flows of
interest within the [start, end) span. message Article { (page#,
block#): article_start; (page#, block#): article_end; repeated string
flows; } The reading order of blocks, paragraphs/etc within this
article would be the same order as present in the goodoc itself.
Some applications (such as rendering) may want to process the
article by running over all the flows together, others (such as
indexing) may want to deal with the FlowThreads one after the
other.
ModificationRecord (type: String.t, default: nil) - This field
can be used to record the steps by which AlternateText for a
sequence of the Goodoc is generated.
PageNumberOrdinal (type:
[Link].t,
default: nil) - If Appearence is PAGE_NUMBER:
appearance (type: integer(), default: nil) -
columndetails (type:
[Link]
olumnDetails.t,default: nil) -
contentlink (type:
[Link]
ontentLink.t, default: nil) -
editcorrectioncandidate (type:
list([Link]
abelEditCorrectionCandidate.t), default: nil) -
overrides (type:
[Link].t,
default: nil) - Structure overrides: typically manual corrections to
goodoc renderings.
 snippetfilter (type:
list([Link]
abelSnippetFilter.t), default: nil) -
tablecelldetails (type:
[Link]
ableCellDetails.t,default: nil) -
tabledetails (type:
[Link]
ableDetails.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

AlternateText: String.t() | nil,
 Attribute: [String.t()] | nil,
ChapterStart: boolean() | nil,
CleanupAnnotation: [integer()] | nil,
ContinuesFromPreviousPage: boolean() | nil,

ContinuesFromPreviousPageHyphenated: boolean() | nil,

ContinuesOnNextPage: boolean() | nil,

EndOfSpanningLabel:
[Link].t() | nil,
ExperimentalData:
[Link].Proto2BridgeMessageSet.t() | nil,
Flow: String.t() | nil,
ModificationRecord: String.t() | nil,
PageNumberOrdinal:
[Link].t() | nil,
appearance: integer() | nil,
columndetails:
[Link].t()
| nil,
contentlink:

[Link].t() | nil,
editcorrectioncandidate:

[Link].t(
)
]
| nil,
overrides: [Link].t() | nil,
snippetfilter:
[[Link].t()]
| nil,
tablecelldetails:

[Link].t()
| nil,

tabledetails:
[Link].t()
 | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
mnDetails
If Appearance is COLUMN:

Attributes

Column (type: integer(), default: nil) -

Columns (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link]{

Column: integer() | nil,

Columns: integer() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
ntLink
If the label is for something that links to another piece of content (in this
volume, outside, a url, a citation, etc.).

Attributes

UrlTarget (type: String.t, default: nil) - For URL labels, we

note the url here directly (it's also available by grabbing all text
symbols within the labeled span). SCHOLARLY_CITATION labels
or even CAPTION labels may occasionally contain URLs.
citationtarget (type:
[Link]
ontentLinkCitationTarget.t, default: nil) -
involumetarget (type:
[Link]
ontentLinkInVolumeTarget.t, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

UrlTarget: String.t() | nil,
citationtarget:

[Link].

t()
| nil,

involumetarget:

[Link].
t()

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.
[Link].V1.
[Link]
ntLinkCitationTarget
For SCHOLARLY_CITATION labels:

Attributes

Authors (type: String.t, default: nil) - separated by semicolons

BibKey (type: String.t, default: nil) -
Confidence (type: float(), default: nil) -
Title (type: String.t, default: nil) -
Year (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link]
{

Authors: String.t() | nil,

BibKey: String.t() | nil,

Confidence: float() | nil,

Title: String.t() | nil,
Year: integer() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
ntLinkInVolumeTarget
For CAPTION or FOOTNOTE_POINTER or TOC_ENTRY or
INDEX_ENTRY or CONTINUATION labels:

Attributes

Confidence (type: float(), default: nil) -

LogicalEntity (type:
[Link].
t, default: nil) - The CAPTION label typically targets the
previous or the next Block. The FOOTNOTE_POINTER label
typically targets a paragraph in a FOOTNOTE Block.
TOC_ENTRY and INDEX_ENTRY labels are links that point to a
different page within the volume. CONTINUATION labels also are
links that point to a different page within the volume, or maybe
even a particular block or paragraph.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link]
{
Confidence: float() | nil,

LogicalEntity:
[Link].t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
orrectionCandidate
If there is more than one edit correction candidate, store all the
candidates here. This helps a manual correction utility fire the right kind
of question with the relevant options.

Attributes

EditedWord (type: String.t, default: nil) -

Probability (type: float(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link]{
EditedWord: String.t() | nil,
Probability: float() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
etFilter
Recording the output of the snippet filter. We run through a series of
snippet filters and store all the conditions that this article passed. A
condition is denoted by the "badword_fraction_allowed" in a running
window of size - "window_size". If
ARTICLE_SNIPPET_NOT_CLEAN annotation is set, this group has 0
items. It can be a part of article logicalentity, but keeping it here for
consistency and coherence as SemanticLabel holds all other article
metadata.

Attributes

badwordFraction(type: float(), default: nil) -

windowSize (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link]{
badwordFraction: float() | nil,

windowSize: integer() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
CellDetails
If Appearance is TABLE_CELL:

Attributes

Column (type: integer(), default: nil) -

ColumnSpan (type: integer(), default: nil) -
Row (type: integer(), default: nil) - Row and Column are 0-
based
RowSpan (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link]{
Column: integer() | nil,
ColumnSpan: integer() | nil,
Row: integer() | nil,

RowSpan: integer() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Details
If Appearance is TABLE:

Attributes

Columns (type: integer(), default: nil) -

Rows (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link]{
Columns: integer() | nil,
Rows: integer() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Goodoc stats for a range of elements, such as one page or a whole book.
These stats can be computed using the SummaryStatsCollector class.
Some range stats are pre-computed and stored in goodocs/volumes (eg.,
[Link] below, and Ocean's CA_VolumeResult.goodoc_stats).

Attributes

numParagraphs (type: integer(), default: nil) - ------ Paragraph

stats Median symbols and words omit junk, header and footer
blocks; they are intended to be a measure of the typical "content"
paragraph. There can still be substantial differences between means
and medians, particularly if a table is present (every cell is a
paragraph).
medianSymbolsPerParagraph (type: integer(), default: nil) -
estimatedFontSizes (type: boolean(), default: nil) - This flag
is set if the histogram above has been derived by estimating font
sizes from [Link]; that happens if the FontSize
field is constant, as has happened with Abbyy 9.
numLineSpaces (type: integer(), default: nil) - Lines (out of
num_lines) that have a successor line within their para
medianSymbolsPerBlock (type: integer(), default: nil) -
numWords (type: integer(), default: nil) - ------ Word stats
medianSymbolsPerWord (type: integer(), default: nil) -
meanSymbolsPerWord (type: integer(), default: nil) -
numNonGraphicBlocks (type: integer(), default: nil) -
medianFullOddPrintedBox (type:
[Link].t,
default: nil) -
medianWordsPerLine (type: integer(), default: nil) -
medianLineSpan (type: integer(), default: nil) - top to next top
in para
medianWidth (type: integer(), default: nil) -
medianWordsPerParagraph (type: integer(), default: nil) -
meanWordsPerBlock (type: integer(), default: nil) -
medianParagraphIndent (type: integer(), default: nil) -
leading space on first line
medianOddPrintedBox (type:
[Link].t,
default: nil) - 1,3,5..
medianSymbolsPerLine (type: integer(), default: nil) -
meanSymbolsPerLine (type: integer(), default: nil) -
numLines (type: integer(), default: nil) - ------ Line stats "top"
corresponds to the highest ascender and "bottom" to the lowest
descender.
medianParagraphSpace (type: integer(), default: nil) - bottom
to next top in block
numParagraphSpaces (type: integer(), default: nil) - paras that
have a successor para within their block
medianPrintedBox (type:
[Link].t,
default: nil) - Each median*_printed_box excludes page
header/footer and all graphic blocks
numPages (type: integer(), default: nil) - ------ Page stats.
medianHorizontalDpi (type: integer(), default: nil) -
meanSymbolsPerParagraph (type: integer(), default: nil) -
medianVerticalDpi (type: integer(), default: nil) -
medianFullPrintedBox (type:
[Link].t,
default: nil) - Each median_full*_printed_box includes page
header/footer but still excludes all graphic blocks
fontSizeHistogram (type:
list([Link]
tats.t), default: nil) - Symbol counts (and other attributes) for
 each distinct [Link] and FontSize; histogram is in
decreasing order of symbol count
medianBlockSpace (type: integer(), default: nil) - bottom to
next top in flow on page
medianLineHeight (type: integer(), default: nil) - top to
bottom
medianHeight (type: integer(), default: nil) -
medianFullEvenPrintedBox (type:
[Link].t,
default: nil) -
meanWordsPerParagraph (type: integer(), default: nil) -
meanWordsPerLine (type: integer(), default: nil) -
medianEvenPrintedBox (type:
[Link].t,
default: nil) - 0,2,4..
medianLineSpace (type: integer(), default: nil) - bottom to
next top in para
numSymbols (type: integer(), default: nil) - ------ Symbol stats
numBlocks (type: integer(), default: nil) - ------ Block stats
Median symbols and words omit junk, header and footer blocks;
they are intended to be a measure of the typical "content" block.
There can still be substantial differences between means and
medians; however, block values will generally exceed paragraph
values (not the case when headers and footers are included).
medianWordsPerBlock (type: integer(), default: nil) -
numBlockSpaces (type: integer(), default: nil) - blocks that
have a successor block within their flow on their page
meanSymbolsPerBlock (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

estimatedFontSizes: boolean() | nil,
fontSizeHistogram:
[[Link].t()] | nil,
meanSymbolsPerBlock: integer() | nil,
meanSymbolsPerLine: integer() | nil,
meanSymbolsPerParagraph: integer() | nil,
meanSymbolsPerWord: integer() | nil,

meanWordsPerBlock: integer() | nil,

meanWordsPerLine: integer() | nil,

meanWordsPerParagraph: integer() | nil,

medianBlockSpace: integer() | nil,

medianEvenPrintedBox:
[Link].t() | nil,

medianFullEvenPrintedBox:
[Link].t() | nil,
medianFullOddPrintedBox:
[Link].t() | nil,
medianFullPrintedBox:
[Link].t() | nil,
 medianHeight: integer() | nil,

medianHorizontalDpi: integer() | nil,

medianLineHeight: integer() | nil,

medianLineSpace: integer() | nil,

medianLineSpan: integer() | nil,
medianOddPrintedBox:
[Link].t() | nil,
medianParagraphIndent: integer() | nil,

medianParagraphSpace: integer() | nil,

medianPrintedBox:
[Link].t() | nil,
medianSymbolsPerBlock: integer() | nil,
medianSymbolsPerLine: integer() | nil,

medianSymbolsPerParagraph: integer() | nil,

medianSymbolsPerWord: integer() | nil,

medianVerticalDpi: integer() | nil,

medianWidth: integer() | nil,
medianWordsPerBlock: integer() | nil,

medianWordsPerLine: integer() | nil,

medianWordsPerParagraph: integer() | nil,

numBlockSpaces: integer() | nil,

numBlocks: integer() | nil,

numLineSpaces: integer() | nil,

numLines: integer() | nil,
numNonGraphicBlocks: integer() | nil,
numPages: integer() | nil,
numParagraphSpaces: integer() | nil,
numParagraphs: integer() | nil,
numSymbols: integer() | nil,
numWords: integer() | nil

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A single symbol representation

Attributes

Box (type:
[Link].t,
default: nil) -
Code (type: integer(), default: nil) - The unicode character
code in UTF-32
Label (type:
[Link].t,
default: nil) -
RotatedBox (type:
[Link]
gBox.t,default: nil) - If RotatedBox is set, Box must be set as
well. See RotatedBoundingBox.
symbolvariant (type:
list([Link]
bolVariant.t), default: nil) -

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

Box: [Link].t() | nil,

Code: integer() | nil,

Label: [Link].t() | nil,

RotatedBox:

[Link].t() | nil,
symbolvariant:
[[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
nt
Attributes

Code (type: integer(), default: nil) -

Confidence (type: integer(), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() :: %[Link]{
Code: integer() | nil,

Confidence: integer() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
A word representation

Attributes

Baseline(type: integer(), default: nil) - The baseline's y-axis

offset from the bottom of the word's bounding box, given in pixels.
(A value of 2, for instance, indicates the baseline is 2px above the
bottom of the box.)
Box (type:
[Link].t,
default: nil) -
Capline (type: integer(), default: nil) - The capline is the y-
axis offset from the top of the word bounding box. A positive value
n indicates that capline is n-pixels above the top of this word.
CompactSymbolBoxes (type:
[Link].
t, default: nil) - For space efficiency, we sometimes skip the
detailed per-symbol bounding boxes in [Link], and use this
coarser representation instead, where we just store Symbol
boundaries within the Word box. Most client code should not have
to worry directly about this, it should be handled in the deepest
layers of writing/reading goodocs (for example, see Compress() and
Uncompress() in ocean/goodoc/goovols-bigtable-volume.h).
Note(viresh): I experimented with this compression, and here are
some numbers for reference. If the zlib-compressed page goodoc
string size was 100 to start with, then this compaction makes it 65.
As a possible future relaxation to consider: if we add in, for each
symbol, a "top" and "bottom" box offset then the size would be 75
(that's with "repeated int32 top/bottom_offset" fields inside
BoxPartitions, instead of inside each symbol).
Confidence (type: integer(), default: nil) - Word recognition
confidence. Range depends upon OCR Engine.
IsFromDictionary (type: boolean(), default: nil) - word. The
meaning and range depends on the OCR engine or subsequent
processing. Specifies whether the word was found
IsIdentifier (type: boolean(), default: nil) - a number True if
word represents
IsLastInSentence (type: boolean(), default: nil) - True if the
word is the last word in any sub-paragraph unit that functions at the
same level of granularity as a sentence. Examples: "She hit the
ball." (regular sentence) "Dewey defeats Truman" (heading) "The
more, the merrier." (no verb) Note: not currently used. Code to set
this was introduced in CL 7038338 and removed in
OCL=10678722.
IsNumeric (type: boolean(), default: nil) - in the dictionary
True if the word represents
Label (type:
[Link].t,
default: nil) -
Penalty (type: integer(), default: nil) - Penalty for
discordance of characters in a
RotatedBox (type:
[Link]
gBox.t,default: nil) - If RotatedBox is set, Box must be set as
well. See RotatedBoundingBox.
Symbol (type:
list([Link].t)
, default: nil) - Word characters, the text may
alternates (type:
[Link]
default: nil) -
.t,
text (type: String.t, default: nil) - As a shortcut, the content
API provides the text of words instead of individual symbols
 (NOTE: this is experimental). This is UTF8. And the main font for
the word is stored in [Link].
writingDirection (type: String.t, default: nil) - Writing
direction for this word.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

Baseline: integer() | nil,

Box: [Link].t() | nil,
Capline: integer() | nil,

CompactSymbolBoxes:
[Link].t() | nil,

Confidence: integer() | nil,

IsFromDictionary: boolean() | nil,
 IsIdentifier: boolean() | nil,
IsLastInSentence: boolean() | nil,
IsNumeric: boolean() | nil,
Label: [Link].t() | nil,
Penalty: integer() | nil,
RotatedBox:
[Link].t() | nil,
Symbol: [[Link].t()] | nil,
alternates:
[Link].t() | nil,

text: String.t() | nil,

writingDirection: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
Alternate OCR words for Ptolemy OCR Correction. This is the output of
the Ptolemy error estimator. See [Link]

Attributes

ErrorProbability(type: integer(), default: nil) - The

probability that the main OCR engine (Abbyy) string is incorrect;
range is 0 (definitely correct) to 100 (definitely incorrect).
alternate (type:
list([Link]
natesAlternate.t), default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link]{

ErrorProbability: integer() | nil,
alternate:
[[Link].t()]
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
rnate
An alternate word provided by another OCR engine, used for OCR
Correction. This iteration only supports simple substitution errors
(exhanging one word for another), but with minor modifications (e.g.
adding a word count for each alternate), it could support repairing word
segmentation and text detection errors.

Attributes

OcrEngineId (type: String.t, default: nil) - See

[Link]
OcrEngineVersion (type: String.t, default: nil) - See
[Link]
Word (type:
[Link].t, default:
nil) - In order to compile, this recursive message needs to be
optional, even though it's within an optional group.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link]{

OcrEngineId: String.t() | nil,

OcrEngineVersion: String.t() | nil,

Word: [Link].t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
managementV1BillingConfig
Describes the billing configuration for a new tenant project.

Attributes

(type: String.t, default: nil) - Name of the

billingAccount
billing account. For example billingAccounts/012345-567890-
ABCDEF.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleApiServiceconsumermanagementV1BillingC
onfig{
billingAccount: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
managementV1PolicyBinding
Translates to IAM Policy bindings (without auditing at this level)

Attributes

members (type: list(String.t), default: nil) - Uses the same

format as in IAM policy. member must include both a prefix and
ID. For example, user:{emailId}, serviceAccount:{emailId},
group:{emailId}.
role (type: String.t, default: nil) - Role.
([Link] For
example, roles/viewer, roles/editor, or roles/owner.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleApiServiceconsumermanagementV1PolicyBi
nding{
members: [String.t()] | nil,
role: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1AudioOutConfig
Specifies the desired format for the server to use when it returns
audio_out messages.

Attributes

audioMode (type: String.t, default: nil) - Current audio mode

on the device while issuing the query.
audioRoutingMode (type: String.t, default: nil) - Current audio
routing on the device while issuing the query.
encoding (type: String.t, default: nil) - Required The encoding
of audio data to be returned in all audio_out messages.
preferredBitrateBps (type: integer(), default: nil) - Optional
Specifies preferred encoding bitrate (bits-per-second). Currently
this is only implemented for OGG_OPUS for bitrates of 12000,
16000, 24000, 32000. If not specified, OGG_OPUS defaults to
32000.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleAssistantAccessoryV1AudioOutConfig{

audioMode: String.t() | nil,

audioRoutingMode: String.t() | nil,

encoding: String.t() | nil,

preferredBitrateBps: integer() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1DeviceConfig
Required Fields that identify the device to the Assistant. See also:
Register a Device - REST API Device Model and Instance Schemas *
Device Proto

Attributes

deviceModelCapabilitiesOverride (type:
[Link]
dedV1DeviceModelCapabilitiesOverride.t,default: nil) -
Device model capabilities from client to override capabilities in the
primary device model.
heterodyneToken (type: String.t, default: nil) - Optional An
encrypted heterodyne_experiment_token containing the list of
experiment_ids (go/ph-server-tokens).
surfaceIdentity (type:
[Link]
default: nil) - Required Identifier for
dedV1SurfaceIdentity.t,
the device which sent the request.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleAssistantAccessoryV1DeviceConfig{
deviceModelCapabilitiesOverride:

[Link].GoogleAssistantEmbeddedV1DeviceModelCapabilit
iesOverride.t()
| nil,
heterodyneToken: String.t() | nil,

surfaceIdentity:

[Link].GoogleAssistantEmbeddedV1SurfaceIdentity.t()
| nil
}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1DeviceState
Information about the state of the device. This contains any state that
Assistant may need to know about in order to fulfill requests, for
example which timers and alarms are set. Next ID: 13

Attributes

alarmState (type:
[Link]
dedV1Alarms.t, default: nil) - Optional Information about on-
device alarms. For devices that support alarms, all on-device alarms
must be sent up with the DeviceState in order for Assistant Server
to be able to perform operations on them.
contextParams (type: String.t, default: nil) - Other context
params to be sent to Assistant. This is a
[Link] message in serialized binary
proto format.
deviceTime (type: DateTime.t, default: nil) - A timestamp of
the current device time when the request was made. This field is
required if your device supports alarms or timers. This ensures that
requests are fulfilled relative to the current device time and
regardless of any clock skew between the client and the server.
deviceTimeZone (type:
[Link].t
, default: nil) - The time zone where the device is currently
located. This helps the Assistant answer time-related queries
relative to the device's time zone. Generally speaking, mobile
devices that support alarms or timers should supply
device_time_zone. This field is required if your device supports
alarms or timers and the device's location cannot reliably be
determined. (See the comment above
[Link] for a description of
how the device's location is determined.) If the time zone cannot be
determined, some queries for creating or modifying timers or
alarms may fail with a generic error such as, "Sorry, I don't know
how to help with that."
doNotDisturb (type: boolean(), default: nil) - Indicate whether
do not disturb mode is turned on.
fitnessActivitiesState (type:
[Link]
default: nil) - Information about on-
dedV1FitnessActivities.t,
device fitness activities. For devices that support fitness activities,
all on-device fitness activities must be sent up with the DeviceState
in order for Assistant Server to be able to perform operations on
them.
installedApps (type:
[Link]
soryV1DeviceStateInstalledAppsState.t,default: nil) -
Information about apps currently installed on device.
installedAppsZlib (type: String.t, default: nil) - This
contains a zlib-compressed binary-encoded InstalledAppsState
proto message.
timerState (type:
[Link]
dedV1Timers.t, default: nil) - Optional Information about on-
device timers. For devices that support timers, all on-device timers
must be sent up with the DeviceState in order for Assistant Server
to be able to perform operations on them.
unavailableSettings (type: list(String.t), default: nil) -
This indicates which specific settings are currently unavailable for
modification, despite being listed as a supported setting. Assistant
can use this field to trigger unavailability messages, rather than
claiming that a setting is entirely unsupported on device.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleAssistantAccessoryV1DeviceState{

alarmState:
[Link].GoogleAssistantEmbeddedV1Alarms.t()
| nil,
contextParams: String.t() | nil,
deviceTime: DateTime.t() | nil,
deviceTimeZone:
[Link].t() | nil,
doNotDisturb: boolean() | nil,

fitnessActivitiesState:

[Link].GoogleAssistantEmbeddedV1FitnessActivities.t(
)
 | nil,
installedApps:

[Link].GoogleAssistantAccessoryV1DeviceStateInstalle

dAppsState.t()
| nil,

installedAppsZlib: String.t() | nil,

timerState:

[Link].GoogleAssistantEmbeddedV1Timers.t()
| nil,

unavailableSettings: [String.t()] | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1DeviceStateInstalledAppsState
State of the apps currently installed on the device.

Attributes

apps (type:
list([Link]
eTypesProvider.t), default: nil) - List of apps currently installed
on the device.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleAssistantAccessoryV1DeviceStateInstall
edAppsState{
apps:

[[Link].t()]
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1ResponseConfig
Configuration for the response. Next Id: 11

Attributes

audioOutConfig (type:
[Link]
default: nil) - Specifies the current
soryV1AudioOutConfig.t,
audio mode on the device.
deviceConfig (type:
[Link]
soryV1DeviceConfig.t, default: nil) - Configuration related to a
specific device.
deviceInteraction (type: String.t, default: nil) - The client
interaction to be sent to Assistant. This is a
[Link] message in serialized
binary proto format.
deviceState (type:
[Link]
soryV1DeviceState.t, default: nil) - Device state to pass to the
Assistant server to use in calculating the response.
initialAudioBytes (type: integer(), default: nil) - Specifies
the initial bytes of TTS audio to send.
isNewConversation (type: boolean(), default: nil) - If true, the
server will treat the request as a new conversation and not use state
from the prior request. Set this field to true when the conversation
should be restarted, such as after a device reboot, or after a
significant lapse of time since the prior query.
 outputSampleRateHz (type: integer(), default: nil) - Specifies
the desired audio sample rate of the output TTS stream in Hz.
responseType (type: String.t, default: nil) - Specifies the
requested response type.
screenOutConfig (type:
[Link]
default: nil) - Specifies the desired
soryV1ScreenOutConfig.t,
format to use when server returns a visual screen response.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleAssistantAccessoryV1ResponseConfig{
audioOutConfig:
 [Link].GoogleAssistantAccessoryV1AudioOutConfig.t()
| nil,
deviceConfig:

[Link].GoogleAssistantAccessoryV1DeviceConfig.t()

| nil,
deviceInteraction: String.t() | nil,

deviceState:

[Link].GoogleAssistantAccessoryV1DeviceState.t()
| nil,

initialAudioBytes: integer() | nil,

isNewConversation: boolean() | nil,
outputSampleRateHz: integer() | nil,
responseType: String.t() | nil,
screenOutConfig:

[Link].GoogleAssistantAccessoryV1ScreenOutConfig.t()
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1ScreenOutConfig
Specifies the desired format for the server to use when it returns
screen_out response.

Attributes

dimensions (type:
[Link]
soryV1ScreenOutConfigDimensions.t, default: nil) - Device
dimensions.
fontScaleFactor(type: number(), default: nil) - The scale
factor used to convert Scalable Pixel (SP) units to Density-
independent Pixel (DP) units (DP = SP * scale factor). Fonts are
measured in units of SP, and on some platforms such as Android the
SP to DP scale factor can be affected by the font size a user selects
in accessibility settings.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleAssistantAccessoryV1ScreenOutConfig{
dimensions:

[Link].GoogleAssistantAccessoryV1ScreenOutConfigDime

nsions.t()
| nil,
fontScaleFactor: number() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1ScreenOutConfigDimensions
This contains physical and logical characteristics about the device (e.g.
screen size and DPI, etc).

Attributes

screenDpi (type: number(), default: nil) - Dots (pixels) per inch

of the screen.
screenHeightPx (type: integer(), default: nil) - Height of the
device's screen in pixels. If 0 or not specified, it's assumed to be the
same as screen_width_px. For a square or round screen, it's
recommended to leave this field empty as a bandwidth
optimization.
screenShape (type: String.t, default: nil) - The shape of the
device's screen
screenWidthPx (type: integer(), default: nil) - Width of the
device's screen in pixels.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleAssistantAccessoryV1ScreenOutConfigDim
ensions{
screenDpi: number() | nil,
screenHeightPx: integer() | nil,
screenShape: String.t() | nil,
screenWidthPx: integer() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1Alarm
Alarms are clocks that ring at a specified time on one or more days. The
client schedules a time to ring based on the date/time pattern. When it
rings, it may be rescheduled off the original time by snoozing or it may
be replaced by the next occurrence.

Attributes

alarmId (type: String.t, default: nil) - A string key used as an

identifier to this alarm. This key needs to be unique amongst all
alarms on the device. The client can choose a mechanism of its
choice to ensure this. If the server suggests an alarm_id, the client
can either use the suggestion or create a new unique alarm_id of its
choosing.
alarmSource (type: String.t, default: nil) - The entity that
created this alarm. Note this may be different from the device that
reported this alarm. In particular, this field is meant for remote
alarms which have been synced to the current device by the Clock
app. Synced alarms exist in each device's Clock app and can be
managed by either device; this field indicates their origin.
datePattern (type:
[Link].t,
default: nil) - For single alarms: the one date the alarm should
next be scheduled for.
label (type: String.t, default: nil) - A user-provided name for
this alarm.
recurrencePattern (type:
[Link]
 dedV1AlarmRecurrence.t, default: nil) - For recurring alarms: a
description of the dates when the alarm should recur.
scheduledTime (type: DateTime.t, default: nil) - When
SCHEDULED or SNOOZED, the absolute time the alarm will fire
next. When SNOOZED, this time includes the additional time
added by snoozing the alarm. When FIRING, the absolute time the
alarm had been scheduled to fire. When DISABLED, this field is
undefined and should be ignored.
status (type: String.t, default: nil) - Describes the part of the
lifecycle that an alarm is in.
timePattern (type:
[Link].
t,default: nil) - The time of day the alarm should be scheduled
for. This value does not change when an alarm enters the
SNOOZED state; instead the scheduled_time field should be
adjusted to the new alarm time.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() :: %[Link].GoogleAssistantEmbeddedV1Alarm{

alarmId: String.t() | nil,

alarmSource: String.t() | nil,

datePattern: [Link].t() | nil,
label: String.t() | nil,

recurrencePattern:

[Link].GoogleAssistantEmbeddedV1AlarmRecurrence.t()
| nil,

scheduledTime: DateTime.t() | nil,

status: String.t() | nil,
timePattern: [Link].t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1AlarmRecurrence
A description of the dates when an alarm should recur.

Attributes

dayOfWeek(type: list(String.t), default: nil) - Specifies a

weekly or daily recurrence. Constraint: The date falls on one of
these days of the week, in 0...6 (Sunday...Saturday). Should not be
empty.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link].GoogleAssistantEmbeddedV1AlarmRecurrence{

dayOfWeek: [String.t()] | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1Alarms
Contains information about on-device alarms for devices that support
alarms.

Attributes

alarms (type:
list([Link]
EmbeddedV1Alarm.t), default: nil) - Information about all on-
device alarms.
snoozeDuration (type: String.t, default: nil) - The amount of
time for which alarms should be snoozed. If not specified, the
productivity vertical applies a default snooze duration, which may
be seen here:
[Link]
2734;rcl=415933085
stateFetchError (type: String.t, default: nil) - Indicates if an
error occurred while fetching alarm state. If this value is missing, it
can be assumed that the state fetch was successful.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleAssistantEmbeddedV1Alarms{
alarms:

[[Link].GoogleAssistantEmbeddedV1Alarm.t()]
| nil,

snoozeDuration: String.t() | nil,

stateFetchError: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1DeviceModelCapabilitiesOverride
Device model capabilities override from client.

Attributes

(type: String.t, default: nil) -

deviceModelCapabilities
Device model capabilities from client.
updateMask (type: String.t, default: nil) - If present, overrides
only fields specified in the mask. When doing so, selected message
and repeated fields will be replaced rather than merged. Performs a
regular proto MergeFrom if no mask is specified.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleAssistantEmbeddedV1DeviceModelCapabili
tiesOverride{
deviceModelCapabilities: String.t() | nil,
updateMask: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1FitnessActivities
Contains information about on-device fitness activities for devices that
support fitness.

Attributes

fitnessActivities (type:
list([Link]
default: nil) - Information
EmbeddedV1FitnessActivity.t),
about all on-device activities.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleAssistantEmbeddedV1FitnessActivities{
fitnessActivities:
[

[Link].GoogleAssistantEmbeddedV1FitnessActivity.t()
]

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1FitnessActivity
Describes a particular fitness activity, its current state, and other data
fields associated with that activity (e.g. elapsed time). [Link]

Attributes

activityId (type: String.t, default: nil) - Required A string

key used as an identifier for this activity. This key needs to be
unique amongst all activities on the device. The client can choose a
mechanism of its choice to ensure this. If the server suggests an
activity_id, the client can either use the suggestion or create a new
unique activity_id of its choosing.
mostRecentStartTime (type: DateTime.t, default: nil) -
DEPRECATED: The most recent time this activity was switched to
the ACTIVE state.
previouslyAccumulatedDuration (type: String.t, default: nil)
- DEPRECATED: The total amount of time this activity has spent
in the ACTIVE state until the most recent start time. The total time
spent active may be computed by summing (now -
most_recent_start_time) with previously_accumulated_duration.
state (type: String.t, default: nil) - The current state of this
activity.
type (type: String.t, default: nil) - The type of activity being
done.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleAssistantEmbeddedV1FitnessActivity{
activityId: String.t() | nil,
mostRecentStartTime: DateTime.t() | nil,

previouslyAccumulatedDuration: String.t() | nil,

state: String.t() | nil,

type: String.t() | nil

}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1SurfaceIdentity
Contains fields to identify the device which sent the request.

Attributes

surfaceType (type: String.t, default: nil) - Surface type that

the device identifies as.
userAgentSuffix (type: String.t, default: nil) - * Fully formed
user agent suffix string.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleAssistantEmbeddedV1SurfaceIdentity{
surfaceType: String.t() | nil,
userAgentSuffix: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1Timer
Conceptually, timers are clocks that count down from an initial duration
and ring when they reach 0. In practice, as a timer is running, it holds a
stable expiration time and computes the remaining duration using the
current time. When a timer is paused, it holds a stable remaining
duration.

Attributes

expireTime (type: DateTime.t, default: nil) - The time the timer

is scheduled to expire. [Link] is a Unix epoch
time with a granularity of 1 nanosecond.
label (type: String.t, default: nil) - A user-provided name for
this timer.
originalDuration (type: String.t, default: nil) - The duration
of the timer when it was started. For the ADD_TIME action, this
field contains the amount of time to add to the timer with the given
timer_id.
remainingDuration (type: String.t, default: nil) - The
remaining duration for the timer.
status (type: String.t, default: nil) - Describes the part of the
lifecycle a timer is in.
timerId (type: String.t, default: nil) - A string key used as an
identifier to this timer. This key needs to be unique amongst all
timers on the device. The client can choose a mechanism of its
choice to ensure this. If the server suggests a timer_id, the client can
either use the suggestion or create a new unique timer_id of its
choosing.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link].GoogleAssistantEmbeddedV1Timer{

expireTime: DateTime.t() | nil,

label: String.t() | nil,

originalDuration: String.t() | nil,

remainingDuration: String.t() | nil,

status: String.t() | nil,

timerId: String.t() | nil

}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
1Timers
Contains information about on-device timers for devices that support
timers.

Attributes

(type: String.t, default: nil) - Indicates if an

stateFetchError
error occurred while fetching timer state. If this value is missing, it
can be assumed that the state fetch was successful.
timers (type:
list([Link]
EmbeddedV1Timer.t), default: nil) - Information about all on-
device timers.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleAssistantEmbeddedV1Timers{
stateFetchError: String.t() | nil,
timers:
[[Link].GoogleAssistantEmbeddedV1Timer.t()]
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1AccessControlAction
Represents the action responsible for access control list management
operations.

Attributes

operationType (type: String.t, default: nil) - Identifies the

type of operation.
policy (type:
[Link].GoogleIamV1Policy.t,
default: nil) - Represents the new policy from which bindings are
added, removed or replaced based on the type of the operation. the
policy is limited to a few 10s of KB.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1AccessControlAc
tion{
operationType: String.t() | nil,
policy: [Link].GoogleIamV1Policy.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1Action
Represents the action triggered by Rule Engine when the rule is true.

Attributes

accessControl (type:
[Link]
rehouseV1AccessControlAction.t, default: nil) - Action
triggering access control operations.
actionId (type: String.t, default: nil) - ID of the action.
Managed internally.
addToFolder (type:
[Link]
default: nil) - Action triggering
rehouseV1AddToFolderAction.t,
create document link operation.
dataUpdate (type:
[Link]
rehouseV1DataUpdateAction.t, default: nil) - Action triggering
data update operations.
dataValidation (type:
[Link]
default: nil) - Action
rehouseV1DataValidationAction.t,
triggering data validation operations.
deleteDocumentAction (type:
[Link]
rehouseV1DeleteDocumentAction.t, default: nil) - Action
deleting the document.
 publishToPubSub (type:
[Link]
rehouseV1PublishAction.t, default: nil) - Action publish to
Pub/Sub operation.
removeFromFolderAction (type:
[Link]
default: nil) - Action
rehouseV1RemoveFromFolderAction.t,
removing a document from a folder.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1Action{
accessControl:
[Link].GoogleCloudContentwarehouseV1AccessControlAct
ion.t()
| nil,
actionId: String.t() | nil,
addToFolder:

[Link].GoogleCloudContentwarehouseV1AddToFolderActio
n.t()
| nil,
dataUpdate:

[Link].GoogleCloudContentwarehouseV1DataUpdateAction
.t()
| nil,
dataValidation:

[Link].GoogleCloudContentwarehouseV1DataValidationAc
tion.t()
| nil,
deleteDocumentAction:

[Link].GoogleCloudContentwarehouseV1DeleteDocumentAc
tion.t()
| nil,
publishToPubSub:

[Link].GoogleCloudContentwarehouseV1PublishAction.t(
)
| nil,
removeFromFolderAction:

[Link].GoogleCloudContentwarehouseV1RemoveFromFolder
Action.t()

| nil
}
Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ActionExecutorOutput
Represents the output of the Action Executor.

Attributes

ruleActionsPairs (type:
list([Link]
default: nil) - List of rule
entwarehouseV1RuleActionsPair.t),
and corresponding actions result.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ActionExecutorO
utput{

ruleActionsPairs:
[

[Link].GoogleCloudContentwarehouseV1RuleActionsPair.
t()
]
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ActionOutput
Represents the result of executing an action.

Attributes

actionId (type: String.t, default: nil) - ID of the action.

actionState (type: String.t, default: nil) - State of an action.
outputMessage (type: String.t, default: nil) - Action execution
output message.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1ActionOutput{
actionId: String.t() | nil,
actionState: String.t() | nil,
outputMessage: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1AddToFolderAction
Represents the action responsible for adding document under a folder.

Attributes

(type: list(String.t), default: nil) - Names of the

folders
folder under which new document is to be added. Format:
projects/{project_number}/locations/{location}/documents/{docum
ent_id}.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1AddToFolderActi
on{

folders: [String.t()] | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1CloudAIDocumentOption
Request Option for processing Cloud AI Document in CW Document.

Attributes

customizedEntitiesPropertiesConversions(type: map(),
default: nil) - If set, only selected entities will be converted to
properties.
enableEntitiesConversions (type: boolean(), default: nil) -
Whether to convert all the entities to properties.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1CloudAIDocument
Option{
customizedEntitiesPropertiesConversions: map() | nil,
enableEntitiesConversions: boolean() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1CreateDocumentLinkReques
t
Request message for [Link].

Attributes

documentLink (type:
[Link]
rehouseV1DocumentLink.t,default: nil) - Required. Document
links associated with the source documents (source_document_id).
requestMetadata (type:
[Link]
default: nil) - The meta
rehouseV1RequestMetadata.t,
information collected about the document creator, used to enforce
access control for the service.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1CreateDocumentL

inkRequest{
documentLink:

[Link].GoogleCloudContentwarehouseV1DocumentLink.t()
| nil,
requestMetadata:

[Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()
| nil
}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1CreateDocumentMetadata
Metadata object for CreateDocument request (currently empty).

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link].GoogleCloudContentwarehouseV1CreateDocumentM
etadata{}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1CreateDocumentRequest
Request message for [Link].

Attributes

cloudAiDocumentOption (type:
[Link]
rehouseV1CloudAIDocumentOption.t, default: nil) - Request
Option for processing Cloud AI Document in Document
Warehouse. This field offers limited support for mapping entities
from Cloud AI Document to Warehouse Document. Please consult
with product team before using this field and other available
options.
createMask (type: String.t, default: nil) - Field mask for
creating Document fields. If mask path is empty, it means all fields
are masked. For the FieldMask definition, see
[Link]
buffers/docs/reference/[Link]#fieldmask.
document (type:
[Link]
rehouseV1Document.t, default: nil) - Required. The document to
create.
policy (type:
[Link].GoogleIamV1Policy.t,
default: nil) - Default document policy during creation. This
refers to an Identity and Access (IAM) policy, which specifies
access controls for the Document. Conditions defined in the policy
will be ignored.
 requestMetadata (type:
[Link]
default: nil) - The meta
rehouseV1RequestMetadata.t,
information collected about the end user, used to enforce access
control for the service.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1CreateDocumentR

equest{
cloudAiDocumentOption:

[Link].GoogleCloudContentwarehouseV1CloudAIDocumentO
 ption.t()
| nil,
createMask: String.t() | nil,

document:

[Link].GoogleCloudContentwarehouseV1Document.t()
| nil,
policy: [Link].GoogleIamV1Policy.t() | nil,
requestMetadata:

[Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1CreateDocumentResponse
Response message for [Link].

Attributes

document (type:
[Link]
rehouseV1Document.t, default: nil) - Document created after
executing create request.
longRunningOperations (type:
list([Link]
default: nil) - post-processing LROs
ngOperation.t),
metadata (type:
[Link]
default: nil) - Additional
rehouseV1ResponseMetadata.t,
information for the API invocation, such as the request tracking id.
ruleEngineOutput (type:
[Link]
default: nil) - Output from Rule
rehouseV1RuleEngineOutput.t,
Engine recording the rule evaluator and action executor's output.
Refer format in:
google/cloud/contentwarehouse/v1/rule_engine.proto

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1CreateDocumentR

esponse{
document:

[Link].GoogleCloudContentwarehouseV1Document.t()
| nil,
longRunningOperations:
[[Link].t()] | nil,
metadata:

[Link].GoogleCloudContentwarehouseV1ResponseMetadata
.t()

| nil,
ruleEngineOutput:
 [Link].GoogleCloudContentwarehouseV1RuleEngineOutput

.t()
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1CustomWeightsMetadata
To support the custom weighting across document schemas.

Attributes

weightedSchemaProperties (type:
list([Link]
default: nil) - List
entwarehouseV1WeightedSchemaProperty.t),
of schema and property name. Allows a maximum of 10 schemas to
be specified for relevance boosting.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1CustomWeightsMe
tadata{
weightedSchemaProperties:

[Link].GoogleCloudContentwarehouseV1WeightedSchemaPr
operty.t()
]

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1DataUpdateAction
Represents the action responsible for properties update operations.

Attributes

entries(type: map(), default: nil) - Map of (K, V) -> (valid

name of the field, new value of the field) E.g., ("age", "60") entry
triggers update of field age with a value of 60. If the field is not
present then new entry is added. During update action execution,
value strings will be casted to appropriate types.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1DataUpdateActio
n{
entries: map() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1DataValidationAction
Represents the action responsible for data validation operations.

Attributes

conditions(type: map(), default: nil) - Map of (K, V) -> (field,

string condition to be evaluated on the field) E.g., ("age", "age > 18
&& age < 60") entry triggers validation of field age with the given
condition. Map entries will be ANDed during validation.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1DataValidationA
ction{
conditions: map() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1DateTimeArray
DateTime values.

Attributes

values (type:
list([Link]
default: nil) - List of datetime values. Both
ime.t),
OffsetDateTime and ZonedDateTime are supported.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1DateTimeArray{
values: [[Link].t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1DateTimeTypeOptions
Configurations for a date time property.

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link].GoogleCloudContentwarehouseV1DateTimeTypeOpt

ions{}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1DeleteDocumentAction
Represents the action responsible for deleting the document.

Attributes

enableHardDelete(type: boolean(), default: nil) - Boolean

field to select between hard vs soft delete options. Set 'true' for 'hard
delete' and 'false' for 'soft delete'.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1DeleteDocumentA
ction{
enableHardDelete: boolean() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1DeleteDocumentLinkRequest
Request message for [Link].

Attributes

requestMetadata (type:
[Link]
default: nil) - The meta
rehouseV1RequestMetadata.t,
information collected about the document creator, used to enforce
access control for the service.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1DeleteDocumentL
inkRequest{

requestMetadata:

[Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1DeleteDocumentRequest
Request message for [Link].

Attributes

requestMetadata (type:
[Link]
default: nil) - The meta
rehouseV1RequestMetadata.t,
information collected about the end user, used to enforce access
control for the service.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1DeleteDocumentR
equest{

requestMetadata:

[Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1Document
Defines the structure for content warehouse document proto.

Attributes

cloudAiDocument (type:
[Link]
iV1Document.t, default: nil) - Document AI format to save the
structured content, including OCR.
contentCategory (type: String.t, default: nil) - Indicates the
category (image, audio, video etc.) of the original content.
createTime (type: DateTime.t, default: nil) - Output only. The
time when the document is created.
creator (type: String.t, default: nil) - The user who creates
the document.
displayName (type: String.t, default: nil) - Required. Display
name of the document given by the user. This name will be
displayed in the UI. Customer can populate this field with the name
of the document. This differs from the 'title' field as 'title' is optional
and stores the top heading in the document.
displayUri (type: String.t, default: nil) - Uri to display the
document, for example, in the UI.
dispositionTime (type: DateTime.t, default: nil) - Output only.
If linked to a Collection with RetentionPolicy, the date when the
document becomes mutable.
documentSchemaName (type: String.t, default: nil) - The
Document schema name. Format:
projects/{project_number}/locations/{location}/documentSchemas/
{document_schema_id}.
inlineRawDocument (type: String.t, default: nil) - Raw
document content.
legalHold (type: boolean(), default: nil) - Output only.
Indicates if the document has a legal hold on it.
name (type: String.t, default: nil) - The resource name of the
document. Format:
projects/{project_number}/locations/{location}/documents/{docum
ent_id}. The name is ignored when creating a document.
plainText (type: String.t, default: nil) - Other document
format, such as PPTX, XLXS
properties (type:
list([Link]
entwarehouseV1Property.t), default: nil) - List of values that
are user supplied metadata.
rawDocumentFileType (type: String.t, default: nil) - This is
used when DocAI was not used to load the document and parsing/
extracting is needed for the inline_raw_document. For example, if
inline_raw_document is the byte representation of a PDF file, then
this should be set to: RAW_DOCUMENT_FILE_TYPE_PDF.
rawDocumentPath (type: String.t, default: nil) - Raw document
file in Cloud Storage path.
referenceId (type: String.t, default: nil) - The reference ID
set by customers. Must be unique per project and location.
textExtractionDisabled (type: boolean(), default: nil) - If
true, text extraction will not be performed.
textExtractionEnabled (type: boolean(), default: nil) - If
true, text extraction will be performed.
title (type: String.t, default: nil) - Title that describes the
document. This can be the top heading or text that describes the
document.
updateTime (type: DateTime.t, default: nil) - Output only. The
time when the document is last updated.
 (type: String.t, default: nil) - The user who lastly
updater
updates the document.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1Document{
cloudAiDocument:

[Link].GoogleCloudDocumentaiV1Document.t()
| nil,
contentCategory: String.t() | nil,
createTime: DateTime.t() | nil,
creator: String.t() | nil,
displayName: String.t() | nil,
displayUri: String.t() | nil,
 dispositionTime: DateTime.t() | nil,

documentSchemaName: String.t() | nil,

inlineRawDocument: String.t() | nil,

legalHold: boolean() | nil,

name: String.t() | nil,
plainText: String.t() | nil,
properties:
[

[Link].GoogleCloudContentwarehouseV1Property.t()
]
| nil,
rawDocumentFileType: String.t() | nil,
rawDocumentPath: String.t() | nil,
referenceId: String.t() | nil,
textExtractionDisabled: boolean() | nil,

textExtractionEnabled: boolean() | nil,

title: String.t() | nil,

updateTime: DateTime.t() | nil,

updater: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1DocumentLink
A document-link between source and target document.

Attributes

createTime (type: DateTime.t, default: nil) - Output only. The

time when the documentLink is created.
description (type: String.t, default: nil) - Description of this
document-link.
name (type: String.t, default: nil) - Name of this document-
link. It is required that the parent derived form the name to be
consistent with the source document reference. Otherwise an
exception will be thrown. Format:
projects/{project_number}/locations/{location}/documents/{source
_document_id}/documentLinks/{document_link_id}.
sourceDocumentReference (type:
[Link]
rehouseV1DocumentReference.t, default: nil) - Document
references of the source document.
state (type: String.t, default: nil) - The state of the
documentlink. If target node has been deleted, the link is marked as
invalid. Removing a source node will result in removal of all
associated links.
targetDocumentReference (type:
[Link]
default: nil) - Document
rehouseV1DocumentReference.t,
references of the target document.
 (type: DateTime.t, default: nil) - Output only. The
updateTime
time when the documentLink is last updated.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1DocumentLink{
createTime: DateTime.t() | nil,
description: String.t() | nil,
name: String.t() | nil,
sourceDocumentReference:

[Link].GoogleCloudContentwarehouseV1DocumentReferenc
e.t()
| nil,
 state: String.t() | nil,
targetDocumentReference:

[Link].GoogleCloudContentwarehouseV1DocumentReferenc
e.t()
| nil,

updateTime: DateTime.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1DocumentQuery
Attributes

customPropertyFilter (type: String.t, default: nil) - This

filter specifies a structured syntax to match against the
[PropertyDefinition].is_filterable marked as true. The syntax for
this expression is a subset of SQL syntax. Supported operators are:
= , !=, < , <=, > , and >= where the left of the operator is a
property name and the right of the operator is a number or a quoted
string. You must escape backslash (\) and quote (\") characters.
Supported functions are LOWER([property_name]) to perform a
case insensitive match and EMPTY([property_name]) to filter on
the existence of a key. Boolean expressions (AND/OR/NOT) are
supported up to 3 levels of nesting (for example, "((A AND B AND
C) OR NOT D) AND E"), a maximum of 100 comparisons or
functions are allowed in the expression. The expression must be <
6000 bytes in length. Sample Query:
(LOWER(driving_license)="class \"a\"" OR
EMPTY(driving_license)) AND driving_years > 10
customWeightsMetadata (type:
[Link]
default: nil) - To support
rehouseV1CustomWeightsMetadata.t,
the custom weighting across document schemas, customers need to
provide the properties to be used to boost the ranking in the search
request. For a search query with CustomWeightsMetadata specified,
only the RetrievalImportance for the properties in the
CustomWeightsMetadata will be honored.
documentCreatorFilter (type: list(String.t), default: nil) -
The exact creator(s) of the documents to search against. If a value
isn't specified, documents within the search results are associated
with any creator. If multiple values are specified, documents within
the search results may be associated with any of the specified
creators.
documentNameFilter (type: list(String.t), default: nil) -
Search the documents in the list. Format:
projects/{project_number}/locations/{location}/documents/{docum
ent_id}.
documentSchemaNames (type: list(String.t), default: nil) -
This filter specifies the exact document schema
Document.document_schema_name of the documents to search
against. If a value isn't specified, documents within the search
results are associated with any schema. If multiple values are
specified, documents within the search results may be associated
with any of the specified schemas. At most 20 document schema
names are allowed.
fileTypeFilter (type:
[Link]
rehouseV1FileTypeFilter.t,default: nil) - This filter specifies
the types of files to return: ALL, FOLDER, or FILE. If FOLDER or
FILE is specified, then only either folders or files will be returned,
respectively. If ALL is specified, both folders and files will be
returned. If no value is specified, ALL files will be returned.
folderNameFilter (type: String.t, default: nil) - Search all the
documents under this specified folder. Format:
projects/{project_number}/locations/{location}/documents/{docum
ent_id}.
isNlQuery (type: boolean(), default: nil) - Experimental, do not
use. If the query is a natural language question. False by default. If
true, then the question-answering feature will be used instead of
search, and result_count in SearchDocumentsRequest must be
set. In addition, all other input fields related to search (pagination,
histograms, etc.) will be ignored.
propertyFilter (type:
list([Link]
entwarehouseV1PropertyFilter.t),default: nil) - This filter
specifies a structured syntax to match against the
PropertyDefinition.is_filterable marked as true. The relationship
between the PropertyFilters is OR.
query (type: String.t, default: nil) - The query string that
matches against the full text of the document and the searchable
properties. The query partially supports Google AIP style syntax.
Specifically, the query supports literals, logical operators, negation
operators, comparison operators, and functions. Literals: A bare
literal value (examples: "42", "Hugo") is a value to be matched
against. It searches over the full text of the document and the
searchable properties. Logical operators: "AND", "and", "OR", and
"or" are binary logical operators (example: "engineer OR
developer"). Negation operators: "NOT" and "!" are negation
operators (example: "NOT software"). Comparison operators:
support the binary comparison operators =, !=, <, >, <= and >= for
string, numeric, enum, boolean. Also support like operator ~~ for
string. It provides semantic search functionality by parsing,
stemming and doing synonyms expansion against the input query.
To specify a property in the query, the left hand side expression in
the comparison must be the property ID including the parent. The
right hand side must be literals. For example:
"\"projects/123/locations/us\".property_a < 1" matches results
whose "property_a" is less than 1 in project 123 and us location.
The literals and comparison expression can be connected in a single
query (example: "software engineer
\"projects/123/locations/us\".salary > 100"). Functions: supported
functions are LOWER([property_name]) to perform a case
insensitive match and EMPTY([property_name]) to filter on the
existence of a key. Support nested expressions connected using
parenthesis and logical operators. The default logical operators is
AND if there is no operators between expressions. The query can be
used with other filters e.g. time_filters and
 folder_name_filter.
They are connected with AND operator
under the hood. The maximum number of allowed characters is
255.
queryContext (type: list(String.t), default: nil) - For custom
synonyms. Customers provide the synonyms based on context. One
customer can provide multiple set of synonyms based on different
context. The search query will be expanded based on the custom
synonyms of the query context set. By default, no custom synonyms
wll be applied if no query context is provided. It is not supported
for CMEK compliant deployment.
timeFilters (type:
list([Link]
default: nil) - Documents
entwarehouseV1TimeFilter.t),
created/updated within a range specified by this filter are searched
against.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1DocumentQuery{
customPropertyFilter: String.t() | nil,
customWeightsMetadata:

[Link].GoogleCloudContentwarehouseV1CustomWeightsMet
adata.t()
| nil,
documentCreatorFilter: [String.t()] | nil,
documentNameFilter: [String.t()] | nil,

documentSchemaNames: [String.t()] | nil,

fileTypeFilter:

[Link].GoogleCloudContentwarehouseV1FileTypeFilter.t

()
| nil,

folderNameFilter: String.t() | nil,

isNlQuery: boolean() | nil,
propertyFilter:
[

[Link].GoogleCloudContentwarehouseV1PropertyFilter.t
()

]
| nil,

query: String.t() | nil,

queryContext: [String.t()] | nil,

timeFilters:
[

[Link].GoogleCloudContentwarehouseV1TimeFilter.t()
 ]
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1DocumentReference
References to the documents.

Attributes

createTime (type: DateTime.t, default: nil) - Output only. The

time when the document is created.
deleteTime (type: DateTime.t, default: nil) - Output only. The
time when the document is deleted.
displayName (type: String.t, default: nil) - display_name of
the referenced document; this name does not need to be consistent
to the display_name in the Document proto, depending on the ACL
constraint.
documentIsFolder (type: boolean(), default: nil) - The
document type of the document being referenced.
documentIsLegalHoldFolder (type: boolean(), default: nil) -
Document is a folder with legal hold.
documentIsRetentionFolder (type: boolean(), default: nil) -
Document is a folder with retention policy.
documentName (type: String.t, default: nil) - Required. Name
of the referenced document.
snippet (type: String.t, default: nil) - Stores the subset of the
referenced document's content. This is useful to allow user peek the
information of the referenced document.
updateTime (type: DateTime.t, default: nil) - Output only. The
time when the document is last updated.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1DocumentReferen
ce{

createTime: DateTime.t() | nil,

deleteTime: DateTime.t() | nil,

displayName: String.t() | nil,

documentIsFolder: boolean() | nil,
documentIsLegalHoldFolder: boolean() | nil,
documentIsRetentionFolder: boolean() | nil,
documentName: String.t() | nil,
snippet: String.t() | nil,
updateTime: DateTime.t() | nil
}
Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1DocumentSchema
A document schema used to define document structure.

Attributes

createTime (type: DateTime.t, default: nil) - Output only. The

time when the document schema is created.
description (type: String.t, default: nil) - Schema
description.
displayName (type: String.t, default: nil) - Required. Name of
the schema given by the user. Must be unique per project.
documentIsFolder (type: boolean(), default: nil) - Document
Type, true refers the document is a folder, otherwise it is a typical
document.
name (type: String.t, default: nil) - The resource name of the
document schema. Format:
projects/{project_number}/locations/{location}/documentSchemas/
{document_schema_id}. The name is ignored when creating a
document schema.
propertyDefinitions (type:
list([Link]
entwarehouseV1PropertyDefinition.t), default: nil) -
Document details.
updateTime (type: DateTime.t, default: nil) - Output only. The
time when the document schema is last updated.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1DocumentSchema{
createTime: DateTime.t() | nil,

description: String.t() | nil,

displayName: String.t() | nil,
documentIsFolder: boolean() | nil,

name: String.t() | nil,

propertyDefinitions:

[Link].GoogleCloudContentwarehouseV1PropertyDefiniti
on.t()

]
 | nil,
updateTime: DateTime.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1EnumArray
Enum values.

Attributes

values(type: list(String.t), default: nil) - List of enum

values.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1EnumArray{

values: [String.t()] | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1EnumTypeOptions
Configurations for an enum/categorical property.

Attributes

possibleValues(type: list(String.t), default: nil) -

Required. List of possible enum values.
validationCheckDisabled (type: boolean(), default: nil) -
Make sure the Enum property value provided in the document is in
the possile value list during document creation. The validation
check runs by default.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1EnumTypeOptions
{

possibleValues: [String.t()] | nil,

validationCheckDisabled: boolean() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1EnumValue
Represents the string value of the enum field.

Attributes

value (type: String.t, default: nil) - String value of the enum

field. This must match defined set of enums in document schema
using EnumTypeOptions.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1EnumValue{
value: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ExportToCdwPipeline
The configuration of exporting documents from the Document
Warehouse to CDW pipeline.

Attributes

docAiDataset (type: String.t, default: nil) - Optional. The

CDW dataset resource name. This field is optional. If not set, the
documents will be exported to Cloud Storage only. Format:
projects/{project}/locations/{location}/processors/{processor}/data
set
documents (type: list(String.t), default: nil) - The list of all
the resource names of the documents to be processed. Format:
projects/{project_number}/locations/{location}/documents/{docum
ent_id}.
exportFolderPath (type: String.t, default: nil) - The Cloud
Storage folder path used to store the exported documents before
being sent to CDW. Format: gs:///.
trainingSplitRatio (type: number(), default: nil) - Ratio of
training dataset split. When importing into Document AI
Workbench, documents will be automatically split into training and
test split category with the specified ratio. This field is required if
doc_ai_dataset is set.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ExportToCdwPipe

line{
docAiDataset: String.t() | nil,

documents: [String.t()] | nil,

exportFolderPath: String.t() | nil,
trainingSplitRatio: number() | nil
}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1FetchAclRequest
Request message for [Link]

Attributes

projectOwner (type: boolean(), default: nil) - For Get Project

ACL only. Authorization check for end user will be ignored when
project_owner=true.
requestMetadata (type:
[Link]
default: nil) - The meta
rehouseV1RequestMetadata.t,
information collected about the end user, used to enforce access
control for the service.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1FetchAclRequest
{
projectOwner: boolean() | nil,
requestMetadata:

[Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1FetchAclResponse
Response message for [Link].

Attributes

metadata (type:
[Link]
rehouseV1ResponseMetadata.t,default: nil) - Additional
information for the API invocation, such as the request tracking id.
policy (type:
[Link].GoogleIamV1Policy.t,
default: nil) - The IAM policy.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1FetchAclRespons
e{

metadata:

[Link].GoogleCloudContentwarehouseV1ResponseMetadata
.t()

| nil,
policy: [Link].GoogleIamV1Policy.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1FileTypeFilter
Filter for the specific types of documents returned.

Attributes

fileType (type: String.t, default: nil) - The type of files to

return.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1FileTypeFilter{
fileType: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1FloatArray
Float values.

Attributes

values(type: list(number()), default: nil) - List of float

values.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1FloatArray{
values: [number()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1FloatTypeOptions
Configurations for a float property.

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link].GoogleCloudContentwarehouseV1FloatTypeOption

s{}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1GcsIngestPipeline
The configuration of the Cloud Storage Ingestion pipeline.

Attributes

inputPath(type: String.t, default: nil) - The input Cloud

Storage folder. All files under this folder will be imported to
Document Warehouse. Format: gs:///.
pipelineConfig (type:
[Link]
rehouseV1IngestPipelineConfig.t,default: nil) - Optional.
The config for the Cloud Storage Ingestion pipeline. It provides
additional customization options to run the pipeline and can be
skipped if it is not applicable.
processorType (type: String.t, default: nil) - The Doc AI
processor type name. Only used when the format of ingested files is
Doc AI Document proto format.
schemaName (type: String.t, default: nil) - The Document
Warehouse schema resource name. All documents processed by this
pipeline will use this schema. Format:
projects/{project_number}/locations/{location}/documentSchemas/
{document_schema_id}.
skipIngestedDocuments (type: boolean(), default: nil) - The
flag whether to skip ingested documents. If it is set to true,
documents in Cloud Storage contains key "status" with value
"status=ingested" in custom metadata will be skipped to ingest.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1GcsIngestPipeli
ne{

inputPath: String.t() | nil,

pipelineConfig:

[Link].GoogleCloudContentwarehouseV1IngestPipelineCo
nfig.t()
| nil,
processorType: String.t() | nil,
schemaName: String.t() | nil,
skipIngestedDocuments: boolean() | nil

}
Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1GcsIngestWithDocAiProcess
orsPipeline
The configuration of the Cloud Storage Ingestion with DocAI Processors
pipeline.

Attributes

extractProcessorInfos (type:
list([Link]
entwarehouseV1ProcessorInfo.t), default: nil) - The extract
processors information. One matched extract processor will be used
to process documents based on the classify processor result. If no
classify processor is specified, the first extract processor will be
used.
inputPath (type: String.t, default: nil) - The input Cloud
Storage folder. All files under this folder will be imported to
Document Warehouse. Format: gs:///.
pipelineConfig (type:
[Link]
default: nil) - Optional.
rehouseV1IngestPipelineConfig.t,
The config for the Cloud Storage Ingestion with DocAI Processors
pipeline. It provides additional customization options to run the
pipeline and can be skipped if it is not applicable.
processorResultsFolderPath (type: String.t, default: nil) -
The Cloud Storage folder path used to store the raw results from
processors. Format: gs:///.
 skipIngestedDocuments (type: boolean(), default: nil) - The
flag whether to skip ingested documents. If it is set to true,
documents in Cloud Storage contains key "status" with value
"status=ingested" in custom metadata will be skipped to ingest.
splitClassifyProcessorInfo (type:
[Link]
default: nil) - The split and classify
rehouseV1ProcessorInfo.t,
processor information. The split and classify result will be used to
find a matched extract processor.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
 %[Link].GoogleCloudContentwarehouseV1GcsIngestWithDo

cAiProcessorsPipeline{
extractProcessorInfos:

[Link].GoogleCloudContentwarehouseV1ProcessorInfo.t(

)
]
| nil,
inputPath: String.t() | nil,
pipelineConfig:

[Link].GoogleCloudContentwarehouseV1IngestPipelineCo
nfig.t()

| nil,
processorResultsFolderPath: String.t() | nil,

skipIngestedDocuments: boolean() | nil,

splitClassifyProcessorInfo:

[Link].GoogleCloudContentwarehouseV1ProcessorInfo.t(

)
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1GetDocumentRequest
Request message for [Link].

Attributes

requestMetadata (type:
[Link]
default: nil) - The meta
rehouseV1RequestMetadata.t,
information collected about the end user, used to enforce access
control for the service.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1GetDocumentRequ
est{
requestMetadata:

[Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1HistogramQuery
The histogram request.

Attributes

filters (type:
[Link]
rehouseV1HistogramQueryPropertyNameFilter.t, default: nil)
- Optional. Filter the result of histogram query by the property
names. It only works with histogram query
count('FilterableProperties'). It is an optional. It will perform
histogram on all the property names for all the document schemas.
Setting this field will have a better performance.
histogramQuery (type: String.t, default: nil) - An expression
specifies a histogram request against matching documents for
searches. See SearchDocumentsRequest.histogram_queries for
details about syntax.
requirePreciseResultSize (type: boolean(), default: nil) -
Controls if the histogram query requires the return of a precise
count. Enable this flag may adversely impact performance. Defaults
to true.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1HistogramQuery{
filters:

[Link].GoogleCloudContentwarehouseV1HistogramQueryPr
opertyNameFilter.t()

| nil,
histogramQuery: String.t() | nil,

requirePreciseResultSize: boolean() | nil

}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1HistogramQueryPropertyNa
meFilter
Attributes

documentSchemas (type: list(String.t), default: nil) - This

filter specifies the exact document schema(s)
Document.document_schema_name to run histogram query against.
It is optional. It will perform histogram for property names for all
the document schemas if it is not set. At most 10 document schema
names are allowed. Format:
projects/{project_number}/locations/{location}/documentSchemas/
{document_schema_id}.
propertyNames (type: list(String.t), default: nil) - It is
optional. It will perform histogram for all the property names if it is
not set. The properties need to be defined with the is_filterable flag
set to true and the name of the property should be in the format:
"[Link]". The property needs to be defined in the
schema. Example: the schema id is abc. Then the name of property
for property MORTGAGE_TYPE will be
"abc.MORTGAGE_TYPE".
yAxis (type: String.t, default: nil) - By default, the y_axis is
HISTOGRAM_YAXIS_DOCUMENT if this field is not set.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1HistogramQueryP
ropertyNameFilter{

documentSchemas: [String.t()] | nil,

propertyNames: [String.t()] | nil,

yAxis: String.t() | nil

}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1HistogramQueryResult
Histogram result that matches HistogramQuery specified in searches.

Attributes

histogram(type: map(), default: nil) - A map from the values of

the facet associated with distinct values to the number of matching
entries with corresponding value. The key format is: * (for string
histogram) string values stored in the field.
histogramQuery (type: String.t, default: nil) - Requested
histogram expression.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1HistogramQueryR
esult{

histogram: map() | nil,

histogramQuery: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1IngestPipelineConfig
The ingestion pipeline config.

Attributes

cloudFunction (type: String.t, default: nil) - The Cloud

Function resource name. The Cloud Function needs to live inside
consumer project and is accessible to Document AI Warehouse
P4SA. Only Cloud Functions V2 is supported. Cloud function
execution should complete within 5 minutes or this file ingestion
may fail due to timeout. Format: [Link]
{project_id}.[Link]/{cloud_function} The
following keys are available the request json payload. display_name
properties plain_text reference_id document_schema_name
raw_document_path raw_document_file_type The following keys
from the cloud function json response payload will be ingested to
the Document AI Warehouse as part of Document proto content
and/or related information. The original values will be overridden
if any key is present in the response. display_name properties
plain_text document_acl_policy folder
documentAclPolicy (type:
[Link].GoogleIamV1Policy.t,
default: nil) - The document level acl policy config. This refers to
an Identity and Access (IAM) policy, which specifies access
controls for all documents ingested by the pipeline. The role and
members under the policy needs to be specified. The following
roles are supported for document level acl control:
roles/[Link]
 roles/[Link]
roles/[Link] The following members
are supported for document level acl control: user:user-
email@[Link] * group:group-email@[Link] Note that
for documents searched with LLM, only single level user or group
acl check is supported.
enableDocumentTextExtraction (type: boolean(), default: nil)
- The document text extraction enabled flag. If the flag is set to true,
DWH will perform text extraction on the raw document.
folder (type: String.t, default: nil) - Optional. The name of
the folder to which all ingested documents will be linked during
ingestion process. Format is
projects/{project}/locations/{location}/documents/{folde
r_id}

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1IngestPipelineC
onfig{
cloudFunction: String.t() | nil,
documentAclPolicy:
[Link].GoogleIamV1Policy.t() | nil,
enableDocumentTextExtraction: boolean() | nil,
folder: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1InitializeProjectRequest
Request message for [Link]

Attributes

accessControlMode (type: String.t, default: nil) - Required.

The access control mode for accessing the customer data
databaseType (type: String.t, default: nil) - Required. The
type of database used to store customer data
documentCreatorDefaultRole (type: String.t, default: nil) -
Optional. The default role for the person who create a document.
enableCalUserEmailLogging (type: boolean(), default: nil) -
Optional. Whether to enable CAL user email logging.
kmsKey (type: String.t, default: nil) - Optional. The KMS key
used for CMEK encryption. It is required that the kms key is in the
same region as the endpoint. The same key will be used for all
provisioned resources, if encryption is available. If the kms_key is
left empty, no encryption will be enforced.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1InitializeProje
ctRequest{
accessControlMode: String.t() | nil,
databaseType: String.t() | nil,
documentCreatorDefaultRole: String.t() | nil,
enableCalUserEmailLogging: boolean() | nil,
kmsKey: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.
[Link].V1.
[Link]
useV1InitializeProjectResponse
Response message for [Link]

Attributes

message (type: String.t, default: nil) - The message of the

project initialization process.
state (type: String.t, default: nil) - The state of the project
initialization process.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1InitializeProje
ctResponse{
message: String.t() | nil,
state: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1IntegerArray
Integer values.

Attributes

values(type: list(integer()), default: nil) - List of integer

values.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1IntegerArray{

values: [integer()] | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1IntegerTypeOptions
Configurations for an integer property.

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link].GoogleCloudContentwarehouseV1IntegerTypeOpti
ons{}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1InvalidRule
A triggered rule that failed the validation check(s) after parsing.

Attributes

error (type: String.t, default: nil) - Validation error on a

parsed expression.
rule (type:
[Link]
rehouseV1Rule.t, default: nil) - Triggered rule.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1InvalidRule{
error: String.t() | nil,
rule:
[Link].GoogleCloudContentwarehouseV1Rule.t()

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ListDocumentSchemasRespo
nse
Response message for [Link].

Attributes

documentSchemas (type:
list([Link]
entwarehouseV1DocumentSchema.t), default: nil) - The
document schemas from the specified parent.
nextPageToken (type: String.t, default: nil) - A token, which
can be sent as page_token to retrieve the next page. If this field is
omitted, there are no subsequent pages.

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ListDocumentSch
emasResponse{
documentSchemas:
[

[Link].GoogleCloudContentwarehouseV1DocumentSchema.t
()
]
| nil,
nextPageToken: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ListLinkedSourcesRequest
Response message for [Link].

Attributes

pageSize (type: integer(), default: nil) - The maximum

number of document-links to return. The service may return fewer
than this value. If unspecified, at most 50 document-links will be
returned. The maximum value is 1000; values above 1000 will be
coerced to 1000.
pageToken (type: String.t, default: nil) - A page token,
received from a previous ListLinkedSources call. Provide this to
retrieve the subsequent page. When paginating, all other parameters
provided to ListLinkedSources must match the call that provided
the page token.
requestMetadata (type:
[Link]
default: nil) - The meta
rehouseV1RequestMetadata.t,
information collected about the document creator, used to enforce
access control for the service.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ListLinkedSourc

esRequest{
pageSize: integer() | nil,

pageToken: String.t() | nil,

requestMetadata:

[Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()
| nil
}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ListLinkedSourcesResponse
Response message for [Link].

Attributes

documentLinks (type:
list([Link]
entwarehouseV1DocumentLink.t), default: nil) - Source
document-links.
nextPageToken (type: String.t, default: nil) - A token, which
can be sent as page_token to retrieve the next page. If this field is
omitted, there are no subsequent pages.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ListLinkedSourc
esResponse{
documentLinks:
[

[Link].GoogleCloudContentwarehouseV1DocumentLink.t()
]

| nil,
nextPageToken: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ListLinkedTargetsRequest
Request message for [Link].

Attributes

requestMetadata (type:
[Link]
default: nil) - The meta
rehouseV1RequestMetadata.t,
information collected about the document creator, used to enforce
access control for the service.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ListLinkedTarge
tsRequest{
requestMetadata:

[Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ListLinkedTargetsResponse
Response message for [Link].

Attributes

documentLinks (type:
list([Link]
entwarehouseV1DocumentLink.t), default: nil) - Target
document-links.
nextPageToken (type: String.t, default: nil) - A token, which
can be sent as page_token to retrieve the next page. If this field is
omitted, there are no subsequent pages.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ListLinkedTarge
tsResponse{
documentLinks:
[

[Link].GoogleCloudContentwarehouseV1DocumentLink.t()
]

| nil,
nextPageToken: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ListRuleSetsResponse
Response message for [Link].

Attributes

nextPageToken (type: String.t, default: nil) - A token, which

can be sent as page_token to retrieve the next page. If this field is
omitted, there are no subsequent pages.
ruleSets (type:
list([Link]
entwarehouseV1RuleSet.t), default: nil) - The rule sets from the
specified parent.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ListRuleSetsRes

ponse{
nextPageToken: String.t() | nil,
ruleSets:
[

[Link].GoogleCloudContentwarehouseV1RuleSet.t()
]

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ListSynonymSetsResponse
Response message for [Link].

Attributes

nextPageToken (type: String.t, default: nil) - A page token,

received from a previous ListSynonymSets call. Provide this to
retrieve the subsequent page.
synonymSets (type:
list([Link]
entwarehouseV1SynonymSet.t), default: nil) - The synonymSets
from the specified parent.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ListSynonymSets
Response{

nextPageToken: String.t() | nil,

synonymSets:
[

[Link].GoogleCloudContentwarehouseV1SynonymSet.t()
]
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1LockDocumentRequest
Request message for [Link].

Attributes

collectionId(type: String.t, default: nil) - The collection the

document connects to.
lockingUser (type:
[Link]
default: nil) - The user information who
rehouseV1UserInfo.t,
locks the document.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1LockDocumentReq
uest{
collectionId: String.t() | nil,
lockingUser:

[Link].GoogleCloudContentwarehouseV1UserInfo.t()
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1MapProperty
Map property value. Represents a structured entries of key value pairs,
consisting of field names which map to dynamically typed values.

Attributes

fields (type: %{optional(String.t) =>

[Link]
default: nil) - Unordered map of
rehouseV1Value.t},
dynamically typed values.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1MapProperty{
fields:
%{
optional(String.t()) =>

[Link].GoogleCloudContentwarehouseV1Value.t()
}

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1MapTypeOptions
Configurations for a Map property.

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link].GoogleCloudContentwarehouseV1MapTypeOptions{
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1MergeFieldsOptions
Options for merging updated fields.

Attributes

replaceMessageFields (type: boolean(), default: nil) - When

merging message fields, the default behavior is to merge the content
of two message fields together. If you instead want to use the field
from the source message to replace the corresponding field in the
destination message, set this flag to true. When this flag is set,
specified submessage fields that are missing in source will be
cleared in destination.
replaceRepeatedFields (type: boolean(), default: nil) - When
merging repeated fields, the default behavior is to append entries
from the source repeated field to the destination repeated field. If
you instead want to keep only the entries from the source repeated
field, set this flag to true. If you want to replace a repeated field
within a message field on the destination message, you must set
both replace_repeated_fields and replace_message_fields to true,
otherwise the repeated fields will be appended.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1MergeFieldsOpti
ons{
replaceMessageFields: boolean() | nil,
replaceRepeatedFields: boolean() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ProcessWithDocAiPipeline
The configuration of processing documents in Document Warehouse
with DocAi processors pipeline.

Attributes

documents (type: list(String.t), default: nil) - The list of all

the resource names of the documents to be processed. Format:
projects/{project_number}/locations/{location}/documents/{docum
ent_id}.
exportFolderPath (type: String.t, default: nil) - The Cloud
Storage folder path used to store the exported documents before
being sent to CDW. Format: gs:///.
processorInfo (type:
[Link]
rehouseV1ProcessorInfo.t, default: nil) - The CDW processor
information.
(type: String.t, default: nil) -
processorResultsFolderPath
The Cloud Storage folder path used to store the raw results from
processors. Format: gs:///.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ProcessWithDocA

iPipeline{
documents: [String.t()] | nil,
exportFolderPath: String.t() | nil,
processorInfo:

[Link].GoogleCloudContentwarehouseV1ProcessorInfo.t(

)
| nil,

processorResultsFolderPath: String.t() | nil

}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ProcessorInfo
The DocAI processor information.

Attributes

documentType (type: String.t, default: nil) - The processor will

process the documents with this document type.
processorName (type: String.t, default: nil) - The processor
resource name. Format is
projects/{project}/locations/{location}/processors/{proc
essor}, or
projects/{project}/locations/{location}/processors/{proc
essor}/processorVersions/{processorVersion}
schemaName (type: String.t, default: nil) - The Document
schema resource name. All documents processed by this processor
will use this schema. Format:
projects/{project_number}/locations/{location}/documentSchemas/
{document_schema_id}.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ProcessorInfo{

documentType: String.t() | nil,

processorName: String.t() | nil,
schemaName: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ProjectStatus
Status of a project, including the project state, dbType, aclMode and etc.

Attributes

accessControlMode (type: String.t, default: nil) - Access

control mode.
databaseType (type: String.t, default: nil) - Database type.
documentCreatorDefaultRole (type: String.t, default: nil) -
The default role for the person who create a document.
location (type: String.t, default: nil) - The location of the
queried project.
qaEnabled (type: boolean(), default: nil) - If the qa is enabled
on this project.
state (type: String.t, default: nil) - State of the project.

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ProjectStatus{
accessControlMode: String.t() | nil,
databaseType: String.t() | nil,
documentCreatorDefaultRole: String.t() | nil,
location: String.t() | nil,
qaEnabled: boolean() | nil,
state: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1Property
Property of a document.

Attributes

dateTimeValues (type:
[Link]
rehouseV1DateTimeArray.t,default: nil) - Date time property
values. It is not supported by CMEK compliant deployment.
enumValues (type:
[Link]
rehouseV1EnumArray.t, default: nil) - Enum property values.
floatValues (type:
[Link]
rehouseV1FloatArray.t, default: nil) - Float property values.
integerValues (type:
[Link]
rehouseV1IntegerArray.t, default: nil) - Integer property
values.
mapProperty (type:
[Link]
rehouseV1MapProperty.t, default: nil) - Map property values.
name (type: String.t, default: nil) - Required. Must match the
name of a PropertyDefinition in the DocumentSchema.
propertyValues (type:
[Link]
rehouseV1PropertyArray.t, default: nil) - Nested structured
data property values.
 textValues (type:
[Link]
rehouseV1TextArray.t, default: nil) - String/text property
values.
timestampValues (type:
[Link]
rehouseV1TimestampArray.t,default: nil) - Timestamp property
values. It is not supported by CMEK compliant deployment.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1Property{
dateTimeValues:
[Link].GoogleCloudContentwarehouseV1DateTimeArray.t(
)
| nil,

enumValues:

[Link].GoogleCloudContentwarehouseV1EnumArray.t()
| nil,

floatValues:

[Link].GoogleCloudContentwarehouseV1FloatArray.t()
| nil,
integerValues:

[Link].GoogleCloudContentwarehouseV1IntegerArray.t()
| nil,
mapProperty:

[Link].GoogleCloudContentwarehouseV1MapProperty.t()

| nil,
name: String.t() | nil,

propertyValues:

[Link].GoogleCloudContentwarehouseV1PropertyArray.t(
)

| nil,
textValues:

[Link].GoogleCloudContentwarehouseV1TextArray.t()
| nil,
timestampValues:

[Link].GoogleCloudContentwarehouseV1TimestampArray.t
()

| nil
}
Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1PropertyArray
Property values.

Attributes

properties (type:
list([Link]
entwarehouseV1Property.t), default: nil) - List of property
values.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1PropertyArray{
properties:

[Link].GoogleCloudContentwarehouseV1Property.t()
]

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1PropertyDefinition
Defines the metadata for a schema property.

Attributes

dateTimeTypeOptions (type:
[Link]
rehouseV1DateTimeTypeOptions.t, default: nil) - Date time
property. It is not supported by CMEK compliant deployment.
displayName (type: String.t, default: nil) - The display-name
for the property, used for front-end.
enumTypeOptions (type:
[Link]
rehouseV1EnumTypeOptions.t, default: nil) - Enum/categorical
property.
floatTypeOptions (type:
[Link]
rehouseV1FloatTypeOptions.t, default: nil) - Float property.
integerTypeOptions (type:
[Link]
rehouseV1IntegerTypeOptions.t, default: nil) - Integer
property.
(type: boolean(), default: nil) - Whether the
isFilterable
property can be filtered. If this is a sub-property, all the parent
properties must be marked filterable.
isMetadata (type: boolean(), default: nil) - Whether the
property is user supplied metadata. This out-of-the box placeholder
setting can be used to tag derived properties. Its value and
interpretation logic should be implemented by API user.
isRepeatable (type: boolean(), default: nil) - Whether the
property can have multiple values.
isRequired (type: boolean(), default: nil) - Whether the
property is mandatory. Default is 'false', i.e. populating property
value can be skipped. If 'true' then user must populate the value for
this property.
isSearchable (type: boolean(), default: nil) - Indicates that the
property should be included in a global search.
mapTypeOptions (type:
[Link]
rehouseV1MapTypeOptions.t, default: nil) - Map property.
name (type: String.t, default: nil) - Required. The name of the
metadata property. Must be unique within a document schema and
is case insensitive. Names must be non-blank, start with a letter, and
can contain alphanumeric characters and: /, :, -, _, and .
propertyTypeOptions (type:
[Link]
rehouseV1PropertyTypeOptions.t, default: nil) - Nested
structured data property.
retrievalImportance (type: String.t, default: nil) - The
retrieval importance of the property during search.
schemaSources (type:
list([Link]
default:
entwarehouseV1PropertyDefinitionSchemaSource.t),
nil) - The mapping information between this property to another
schema source.
textTypeOptions (type:
[Link]
rehouseV1TextTypeOptions.t, default: nil) - Text/string
property.
timestampTypeOptions (type:
[Link]
 rehouseV1TimestampTypeOptions.t,default: nil) - Timestamp
property. It is not supported by CMEK compliant deployment.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1PropertyDefinit
ion{

dateTimeTypeOptions:

[Link].GoogleCloudContentwarehouseV1DateTimeTypeOpti
ons.t()
| nil,
displayName: String.t() | nil,
 enumTypeOptions:

[Link].GoogleCloudContentwarehouseV1EnumTypeOptions.
t()
| nil,
floatTypeOptions:

[Link].GoogleCloudContentwarehouseV1FloatTypeOptions
.t()
| nil,
integerTypeOptions:

[Link].GoogleCloudContentwarehouseV1IntegerTypeOptio

ns.t()
| nil,

isFilterable: boolean() | nil,

isMetadata: boolean() | nil,

isRepeatable: boolean() | nil,

isRequired: boolean() | nil,
isSearchable: boolean() | nil,

mapTypeOptions:

[Link].GoogleCloudContentwarehouseV1MapTypeOptions.t
()
| nil,
name: String.t() | nil,
propertyTypeOptions:

[Link].GoogleCloudContentwarehouseV1PropertyTypeOpti
ons.t()

| nil,
retrievalImportance: String.t() | nil,

schemaSources:
[

[Link].GoogleCloudContentwarehouseV1PropertyDefiniti
 onSchemaSource.t()

]
| nil,

textTypeOptions:

[Link].GoogleCloudContentwarehouseV1TextTypeOptions.
t()
| nil,
timestampTypeOptions:

[Link].GoogleCloudContentwarehouseV1TimestampTypeOpt
ions.t()
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1PropertyDefinitionSchemaSo
urce
The schema source information.

Attributes

name (type: String.t, default: nil) - The schema name in the

source.
processorType (type: String.t, default: nil) - The Doc AI
processor type name.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1PropertyDefinit
ionSchemaSource{

name: String.t() | nil,

processorType: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1PropertyFilter
Attributes

condition(type: String.t, default: nil) - The filter condition.

The syntax for this expression is a subset of SQL syntax. Supported
operators are: = , !=, < , <=, > , >=, and ~~ where the left of the
operator is a property name and the right of the operator is a
number or a quoted string. You must escape backslash (\) and quote
(\") characters. ~~ is the LIKE operator. The right of the operator
must be a string. The only supported property data type for LIKE is
text_values. It provides semantic search functionality by parsing,
stemming and doing synonyms expansion against the input query. It
matches if the property contains semantic similar content to the
query. It is not regex matching or wildcard matching. For example,
"[Link] ~~ \"google\"" will match records whose
property [Link] have values like "Google Inc.",
"Google LLC" or "Google Company". Supported functions are
LOWER([property_name]) to perform a case insensitive match and
EMPTY([property_name]) to filter on the existence of a key.
Boolean expressions (AND/OR/NOT) are supported up to 3 levels
of nesting (for example, "((A AND B AND C) OR NOT D) AND
E"), a maximum of 100 comparisons or functions are allowed in the
expression. The expression must be < 6000 bytes in length. Only
properties that are marked filterable are allowed
(PropertyDefinition.is_filterable). Property names do not need to be
prefixed by the document schema id (as is the case with
histograms), however property names will need to be prefixed by its
parent hierarchy, if any. For example:
 top_property_name.sub_property_name. Sample Query:
(LOWER(driving_license)="class \"a\"" OR
CMEK
EMPTY(driving_license)) AND driving_years > 10
compliant deployment only supports: Operators: = , < , <=, > , and
>=. Boolean expressions: AND and OR.
documentSchemaName (type: String.t, default: nil) - The
Document schema name Document.document_schema_name.
Format:
projects/{project_number}/locations/{location}/documentSchemas/
{document_schema_id}.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link].GoogleCloudContentwarehouseV1PropertyFilter{

condition: String.t() | nil,

documentSchemaName: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1PropertyTypeOptions
Configurations for a nested structured data property.

Attributes

propertyDefinitions (type:
list([Link]
default: nil) -
entwarehouseV1PropertyDefinition.t),
Required. List of property definitions.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1PropertyTypeOpt
ions{
propertyDefinitions:
[

[Link].GoogleCloudContentwarehouseV1PropertyDefiniti

on.t()
]

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1PublishAction
Represents the action responsible for publishing messages to a Pub/Sub
topic.

Attributes

messages (type: list(String.t), default: nil) - Messages to be

published.
topicId (type: String.t, default: nil) - The topic id in the
Pub/Sub service for which messages will be published to.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1PublishAction{
messages: [String.t()] | nil,
topicId: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1QAResult
Additional result info for the question-answering feature.

Attributes

confidenceScore (type: number(), default: nil) - The calibrated

confidence score for this document, in the range [0., 1.]. This
represents the confidence level for whether the returned document
and snippet answers the user's query.
highlights (type:
list([Link]
default: nil) -
entwarehouseV1QAResultHighlight.t),
Highlighted sections in the snippet.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1QAResult{
confidenceScore: number() | nil,

highlights:
[

[Link].GoogleCloudContentwarehouseV1QAResultHighligh

t.t()
]
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1QAResultHighlight
A text span in the search text snippet that represents a highlighted
section (answer context, highly relevant sentence, etc.).

Attributes

endIndex (type: integer(), default: nil) - End index of the

highlight, exclusive.
startIndex (type: integer(), default: nil) - Start index of the
highlight.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1QAResultHighlig
ht{
endIndex: integer() | nil,

startIndex: integer() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RemoveFromFolderAction
Represents the action responsible for remove a document from a specific
folder.

Attributes

condition(type: String.t, default: nil) - Condition of the

action to be executed.
folder (type: String.t, default: nil) - Name of the folder under
which new document is to be added. Format:
projects/{project_number}/locations/{location}/documents/{docum
ent_id}.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RemoveFromFolde

rAction{
condition: String.t() | nil,

folder: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RequestMetadata
Meta information is used to improve the performance of the service.

Attributes

userInfo (type:
[Link]
default: nil) - Provides user unique
rehouseV1UserInfo.t,
identification and groups information.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RequestMetadata
{
userInfo:

[Link].GoogleCloudContentwarehouseV1UserInfo.t()
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1ResponseMetadata
Additional information returned to client, such as debugging
information.

Attributes

(type: String.t, default: nil) - A unique id

requestId
associated with this call. This id is logged for tracking purpose.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1ResponseMetadat
a{
requestId: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1Rule
Represents the rule for a content warehouse trigger.

Attributes

actions (type:
list([Link]
entwarehouseV1Action.t), default: nil) - List of actions that are
executed when the rule is satisfied.
condition (type: String.t, default: nil) - Represents the
conditional expression to be evaluated. Expression should evaluate
to a boolean result. When the condition is true actions are executed.
Example: user_role = "hsbc_role_1" AND [Link] > 20000
description (type: String.t, default: nil) - Short description of
the rule and its context.
ruleId (type: String.t, default: nil) - ID of the rule. It has to be
unique across all the examples. This is managed internally.
triggerType (type: String.t, default: nil) - Identifies the
trigger type for running the policy.

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1Rule{

actions:
[

[Link].GoogleCloudContentwarehouseV1Action.t()
]

| nil,
condition: String.t() | nil,

description: String.t() | nil,

ruleId: String.t() | nil,

triggerType: String.t() | nil

}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RuleActionsPair
Represents a rule and outputs of associated actions.

Attributes

actionOutputs (type:
list([Link]
default: nil) - Outputs of
entwarehouseV1ActionOutput.t),
executing the actions associated with the above rule.
rule (type:
[Link]
rehouseV1Rule.t, default: nil) - Represents the rule.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RuleActionsPair
{
actionOutputs:
[

[Link].GoogleCloudContentwarehouseV1ActionOutput.t()
]

| nil,
rule:
[Link].GoogleCloudContentwarehouseV1Rule.t()

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RuleEngineOutput
Records the output of Rule Engine including rule evaluation and actions
result.

Attributes

actionExecutorOutput (type:
[Link]
default: nil) - Output from
rehouseV1ActionExecutorOutput.t,
Action Executor containing rule and corresponding actions
execution result.
documentName (type: String.t, default: nil) - Name of the
document against which the rules and actions were evaluated.
ruleEvaluatorOutput (type:
[Link]
default: nil) - Output from
rehouseV1RuleEvaluatorOutput.t,
Rule Evaluator containing matched, unmatched and invalid rules.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RuleEngineOutpu
t{
actionExecutorOutput:

[Link].GoogleCloudContentwarehouseV1ActionExecutorOu
tput.t()

| nil,
documentName: String.t() | nil,

ruleEvaluatorOutput:

[Link].GoogleCloudContentwarehouseV1RuleEvaluatorOut
put.t()

| nil
}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RuleEvaluatorOutput
Represents the output of the Rule Evaluator.

Attributes

invalidRules (type:
list([Link]
default: nil) - A subset of
entwarehouseV1InvalidRule.t),
triggered rules that failed the validation check(s) after parsing.
matchedRules (type:
list([Link]
entwarehouseV1Rule.t),default: nil) - A subset of triggered
rules that are evaluated true for a given request.
triggeredRules (type:
list([Link]
default: nil) - List of rules fetched from
entwarehouseV1Rule.t),
database for the given request trigger type.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RuleEvaluatorOu
tput{

invalidRules:
[

[Link].GoogleCloudContentwarehouseV1InvalidRule.t()
]
| nil,
matchedRules:
[
[Link].GoogleCloudContentwarehouseV1Rule.t()

]
| nil,
triggeredRules:
[
[Link].GoogleCloudContentwarehouseV1Rule.t()
]
| nil
}
Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RuleSet
Represents a set of rules from a single customer.

Attributes

description (type: String.t, default: nil) - Short description of

the rule-set.
name (type: String.t, default: nil) - The resource name of the
rule set. Managed internally. Format:
projects/{project_number}/locations/{location}/ruleSet/{rule_set_i
d}. The name is ignored when creating a rule set.
rules (type:
list([Link]
entwarehouseV1Rule.t), default: nil) - List of rules given by the
customer.
source (type: String.t, default: nil) - Source of the rules i.e.,
customer name.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RuleSet{
description: String.t() | nil,
name: String.t() | nil,
rules:
[

[Link].GoogleCloudContentwarehouseV1Rule.t()
]

| nil,
source: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RunPipelineMetadata
Metadata message of RunPipeline method.

Attributes

exportToCdwPipelineMetadata (type:
[Link]
rehouseV1RunPipelineMetadataExportToCdwPipelineMetadata.
t, default: nil) - The pipeline metadata for Export-to-CDW
pipeline.
failedFileCount (type: integer(), default: nil) - Number of
files that have failed at some point in the pipeline.
gcsIngestPipelineMetadata (type:
[Link]
rehouseV1RunPipelineMetadataGcsIngestPipelineMetadata.t,
default: nil) - The pipeline metadata for GcsIngest pipeline.
individualDocumentStatuses (type:
list([Link]
entwarehouseV1RunPipelineMetadataIndividualDocumentStatu
default: nil) - The list of response details of each document.
s.t),
processWithDocAiPipelineMetadata (type:
[Link]
rehouseV1RunPipelineMetadataProcessWithDocAiPipelineMeta
data.t,default: nil) - The pipeline metadata for Process-with-
DocAi pipeline.
totalFileCount (type: integer(), default: nil) - Number of
files that were processed by the pipeline.
 userInfo (type:
[Link]
default: nil) - User unique identification
rehouseV1UserInfo.t,
and groups information.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RunPipelineMeta
data{
exportToCdwPipelineMetadata:

[Link].GoogleCloudContentwarehouseV1RunPipelineMetad

ataExportToCdwPipelineMetadata.t()
 | nil,

failedFileCount: integer() | nil,

gcsIngestPipelineMetadata:

[Link].GoogleCloudContentwarehouseV1RunPipelineMetad
ataGcsIngestPipelineMetadata.t()
| nil,
individualDocumentStatuses:

[Link].GoogleCloudContentwarehouseV1RunPipelineMetad
ataIndividualDocumentStatus.t()
]
| nil,
processWithDocAiPipelineMetadata:

[Link].GoogleCloudContentwarehouseV1RunPipelineMetad
ataProcessWithDocAiPipelineMetadata.t()

| nil,
totalFileCount: integer() | nil,
userInfo:

[Link].GoogleCloudContentwarehouseV1UserInfo.t()
| nil
}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RunPipelineMetadataExport
ToCdwPipelineMetadata
The metadata message for Export-to-CDW pipeline.

Attributes

docAiDataset (type: String.t, default: nil) - The output CDW

dataset resource name.
documents (type: list(String.t), default: nil) - The input list
of all the resource names of the documents to be exported.
outputPath (type: String.t, default: nil) - The output Cloud
Storage folder in this pipeline.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RunPipelineMeta

dataExportToCdwPipelineMetadata{
docAiDataset: String.t() | nil,

documents: [String.t()] | nil,

outputPath: String.t() | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RunPipelineMetadataGcsIng
estPipelineMetadata
The metadata message for GcsIngest pipeline.

Attributes

(type: String.t, default: nil) - The input Cloud

inputPath
Storage folder in this pipeline. Format: gs:///.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RunPipelineMeta
dataGcsIngestPipelineMetadata{
inputPath: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RunPipelineMetadataIndivid
ualDocumentStatus
The status of processing a document.

Attributes

documentId (type: String.t, default: nil) - Document identifier

of an existing document.
status (type:
[Link].t,
default: nil) - The status processing the document.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RunPipelineMeta
dataIndividualDocumentStatus{
documentId: String.t() | nil,

status: [Link].t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RunPipelineMetadataProcess
WithDocAiPipelineMetadata
The metadata message for Process-with-DocAi pipeline.

Attributes

documents (type: list(String.t), default: nil) - The input list

of all the resource names of the documents to be processed.
processorInfo (type:
[Link]
default: nil) - The DocAI processor
rehouseV1ProcessorInfo.t,
to process the documents with.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RunPipelineMeta

dataProcessWithDocAiPipelineMetadata{
documents: [String.t()] | nil,

processorInfo:

[Link].GoogleCloudContentwarehouseV1ProcessorInfo.t(

)
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1RunPipelineRequest
Request message for [Link].

Attributes

exportCdwPipeline (type:
[Link]
default: nil) - Export
rehouseV1ExportToCdwPipeline.t,
docuemnts from Document Warehouse to CDW for training
purpose.
gcsIngestPipeline (type:
[Link]
rehouseV1GcsIngestPipeline.t, default: nil) - Cloud Storage
ingestion pipeline.
gcsIngestWithDocAiProcessorsPipeline (type:
[Link]
rehouseV1GcsIngestWithDocAiProcessorsPipeline.t, default:
nil) - Use DocAI processors to process documents in Cloud
Storage and ingest them to Document Warehouse.
processWithDocAiPipeline (type:
[Link]
default: nil) - Use a
rehouseV1ProcessWithDocAiPipeline.t,
DocAI processor to process documents in Document Warehouse,
and re-ingest the updated results into Document Warehouse.
requestMetadata (type:
[Link]
rehouseV1RequestMetadata.t, default: nil) - The meta
 information collected about the end user, used to enforce access
control for the service.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1RunPipelineRequ
est{
exportCdwPipeline:

[Link].GoogleCloudContentwarehouseV1ExportToCdwPipel
ine.t()
| nil,

gcsIngestPipeline:
 [Link].GoogleCloudContentwarehouseV1GcsIngestPipelin

e.t()
| nil,
gcsIngestWithDocAiProcessorsPipeline:

[Link].GoogleCloudContentwarehouseV1GcsIngestWithDoc
AiProcessorsPipeline.t()
| nil,
processWithDocAiPipeline:

[Link].GoogleCloudContentwarehouseV1ProcessWithDocAi
Pipeline.t()

| nil,
requestMetadata:

[Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1SearchDocumentsRequest
Request message for [Link].

Attributes

documentQuery (type:
[Link]
default: nil) - Query used to search
rehouseV1DocumentQuery.t,
against documents (keyword, filters, etc.).
histogramQueries (type:
list([Link]
entwarehouseV1HistogramQuery.t), default: nil) - An
expression specifying a histogram request against matching
documents. Expression syntax is an aggregation function call with
histogram facets and other options. The following aggregation
functions are supported: count(string_histogram_facet): Count
the number of matching entities for each distinct attribute value.
Data types: Histogram facet (aka filterable properties): Facet names
with format <schema id>.<facet>. Facets will have the format of:
a-zA-Z. If the facet is a child facet, then the parent hierarchy needs
to be specified separated by dots in the prefix after the schema id.
Thus, the format for a multi- level facet is: <schema id>.<parent
facet name>. <child facet name>. Example:
schema123.root_parent_facet.middle_facet.child_facet
DocumentSchemaId: (with no schema id prefix) to get histograms
for each document type (returns the schema id path, e.g.
projects/12345/locations/us-west/documentSchemas/abc123).
Example expression: Document type counts:
count('DocumentSchemaId') * For schema id, abc123, get the
counts for MORTGAGE_TYPE:
count('abc123.MORTGAGE_TYPE')
offset (type: integer(), default: nil) - An integer that specifies
the current offset (that is, starting result location, amongst the
documents deemed by the API as relevant) in search results. This
field is only considered if page_token is unset. The maximum
allowed value is 5000. Otherwise an error is thrown. For example, 0
means to return results starting from the first matching document,
and 10 means to return from the 11th document. This can be used
for pagination, (for example, pageSize = 10 and offset = 10 means
to return from the second page).
orderBy (type: String.t, default: nil) - The criteria determining
how search results are sorted. For non-empty query, default is
"relevance desc" . For empty query, default is "upload_date
desc". Supported options are: "relevance desc" : By relevance
descending, as determined by the API algorithms. "upload_date
desc": By upload date descending. "upload_date": By upload
date ascending. "update_date desc" : By last updated date
descending. "update_date": By last updated date ascending.
"retrieval_importance desc" : By retrieval importance of
properties descending. This feature is still under development,
please do not use unless otherwise instructed to do so.
pageSize (type: integer(), default: nil) - A limit on the number
of documents returned in the search results. Increasing this value
above the default value of 10 can increase search response time.
The value can be between 1 and 100.
pageToken (type: String.t, default: nil) - The token specifying
the current offset within search results. See
SearchDocumentsResponse.next_page_token for an explanation of
how to obtain the next set of query results.
qaSizeLimit (type: integer(), default: nil) - Experimental, do
not use. The limit on the number of documents returned for the
question-answering feature. To enable the question-answering
feature, set [DocumentQuery].is_nl_query to true.
 requestMetadata (type:
[Link]
rehouseV1RequestMetadata.t, default: nil) - The meta
information collected about the end user, used to enforce access
control and improve the search quality of the service.
requireTotalSize (type: boolean(), default: nil) - Controls if
the search document request requires the return of a total size of
matched documents. See SearchDocumentsResponse.total_size.
Enabling this flag may adversely impact performance. Hint: If this
is used with pagination, set this flag on the initial query but set this
to false on subsequent page calls (keep the total count locally).
Defaults to false.
totalResultSize (type: String.t, default: nil) - Controls if the
search document request requires the return of a total size of
matched documents. See SearchDocumentsResponse.total_size.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1SearchDocuments
Request{
documentQuery:

[Link].GoogleCloudContentwarehouseV1DocumentQuery.t(
)

| nil,
histogramQueries:

[Link].GoogleCloudContentwarehouseV1HistogramQuery.t
()
]
| nil,
offset: integer() | nil,
orderBy: String.t() | nil,
pageSize: integer() | nil,
pageToken: String.t() | nil,
qaSizeLimit: integer() | nil,
requestMetadata:

[Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()

| nil,
requireTotalSize: boolean() | nil,

totalResultSize: String.t() | nil

}
Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1SearchDocumentsResponse
Response message for [Link].

Attributes

histogramQueryResults (type:
list([Link]
default: nil) - The
entwarehouseV1HistogramQueryResult.t),
histogram results that match with the specified
SearchDocumentsRequest.histogram_queries.
matchingDocuments (type:
list([Link]
entwarehouseV1SearchDocumentsResponseMatchingDocument.t),
default: nil) - The document entities that match the specified
SearchDocumentsRequest.
metadata (type:
[Link]
rehouseV1ResponseMetadata.t, default: nil) - Additional
information for the API invocation, such as the request tracking id.
nextPageToken (type: String.t, default: nil) - The token that
specifies the starting position of the next page of results. This field
is empty if there are no more results.
questionAnswer (type: String.t, default: nil) - Experimental.
Question answer from the query against the document.
totalSize (type: integer(), default: nil) - The total number of
matched documents which is available only if the client set
SearchDocumentsRequest.require_total_size to true or set
SearchDocumentsRequest.total_result_size to ESTIMATED_SIZE or
 ACTUAL_SIZE. Otherwise, the value will be -1. Typically a UI
would handle this condition by displaying "of many", for example:
"Displaying 10 of many".

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1SearchDocuments
Response{

histogramQueryResults:
[

[Link].GoogleCloudContentwarehouseV1HistogramQueryRe

sult.t()
 ]

| nil,
matchingDocuments:

[Link].GoogleCloudContentwarehouseV1SearchDocumentsR
esponseMatchingDocument.t()

]
| nil,

metadata:

[Link].GoogleCloudContentwarehouseV1ResponseMetadata
.t()

| nil,
nextPageToken: String.t() | nil,
questionAnswer: String.t() | nil,
totalSize: integer() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1SearchDocumentsResponseM
atchingDocument
Document entry with metadata inside SearchDocumentsResponse

Attributes

document (type:
[Link]
rehouseV1Document.t, default: nil) - Document that matches the
specified SearchDocumentsRequest. This document only contains
indexed metadata information.
matchedTokenPageIndices (type: list(String.t), default: nil)
- Return the 1-based page indices where those pages have one or
more matched tokens.
qaResult (type:
[Link]
rehouseV1QAResult.t, default: nil) - Experimental. Additional
result info if the question-answering feature is enabled.
searchTextSnippet (type: String.t, default: nil) - Contains
snippets of text from the document full raw text that most closely
match a search query's keywords, if available. All HTML tags in
the original fields are stripped when returned in this field, and
matching query keywords are enclosed in HTML bold tags. If the
question-answering feature is enabled, this field will instead contain
a snippet that answers the user's natural-language query. No HTML
bold tags will be present, and highlights in the answer snippet can
be found in [Link].
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1SearchDocuments

ResponseMatchingDocument{
document:

[Link].GoogleCloudContentwarehouseV1Document.t()
| nil,
matchedTokenPageIndices: [String.t()] | nil,
qaResult:

[Link].GoogleCloudContentwarehouseV1QAResult.t()

| nil,
 searchTextSnippet: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1SetAclRequest
Request message for [Link].

Attributes

policy (type:
[Link].GoogleIamV1Policy.t,
default: nil) - Required. REQUIRED: The complete policy to be
applied to the resource. The size of the policy is limited to a few
10s of KB. This refers to an Identity and Access (IAM) policy,
which specifies access controls for the Document. You can set ACL
with condition for projects only. Supported operators are: = , !=, < ,
<=, > , and >= where the left of the operator is DocumentSchemaId
or property name and the right of the operator is a number or a
quoted string. You must escape backslash (\) and quote (\")
characters. Boolean expressions (AND/OR) are supported up to 3
levels of nesting (for example, "((A AND B AND C) OR D) AND
E"), a maximum of 10 comparisons are allowed in the expression.
The expression must be < 6000 bytes in length. Sample condition:
"DocumentSchemaId = \"some schema id\" OR
[Link] >= 10"
projectOwner (type: boolean(), default: nil) - For Set Project
ACL only. Authorization check for end user will be ignored when
project_owner=true.
requestMetadata (type:
[Link]
rehouseV1RequestMetadata.t, default: nil) - The meta
 information collected about the end user, used to enforce access
control for the service.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1SetAclRequest{

policy: [Link].GoogleIamV1Policy.t() | nil,

projectOwner: boolean() | nil,

requestMetadata:

[Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()
 | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1SetAclResponse
Response message for [Link].

Attributes

metadata (type:
[Link]
rehouseV1ResponseMetadata.t,default: nil) - Additional
information for the API invocation, such as the request tracking id.
policy (type:
[Link].GoogleIamV1Policy.t,
default: nil) - The policy will be attached to a resource (e.g.
projecct, document).

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1SetAclResponse{
metadata:

[Link].GoogleCloudContentwarehouseV1ResponseMetadata
.t()
| nil,
policy: [Link].GoogleIamV1Policy.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1SynonymSet
Represents a list of synonyms for a given context. For example a context
"sales" could contain: Synonym 1: sale, invoice, bill, order Synonym 2:
money, credit, finance, payment Synonym 3: shipping, freight, transport
Each SynonymSets should be disjoint

Attributes

(type: String.t, default: nil) - This is a freeform field.

context
Example contexts can be "sales," "engineering," "real estate,"
"accounting," etc. The context can be supplied during search
requests.
name (type: String.t, default: nil) - The resource name of the
SynonymSet This is mandatory for [Link]. Format:
projects/{project_number}/locations/{location}/synonymSets/{cont
ext}.
synonyms (type:
list([Link]
entwarehouseV1SynonymSetSynonym.t), default: nil) - List of
Synonyms for the context.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1SynonymSet{

context: String.t() | nil,

name: String.t() | nil,

synonyms:
[

[Link].GoogleCloudContentwarehouseV1SynonymSetSynony

m.t()
]
| nil
}

Functions
decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1SynonymSetSynonym
Represents a list of words given by the customer All these words are
synonyms of each other.

Attributes

words(type: list(String.t), default: nil) - For example: sale,

invoice, bill, order

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1SynonymSetSynon
ym{
words: [String.t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1TextArray
String/text values.

Attributes

values (type: list(String.t), default: nil) - List of text values.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::
%[Link].GoogleCloudContentwarehouseV1TextArray{
values: [String.t()] | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1TextTypeOptions
Configurations for a text property.

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link].GoogleCloudContentwarehouseV1TextTypeOptions

{}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1TimeFilter
Filter on create timestamp or update timestamp of documents.

Attributes

timeField(type: String.t, default: nil) - Specifies which time

field to filter documents on. Defaults to
TimeField.UPLOAD_TIME.
timeRange (type:
[Link].t
, default: nil) -

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1TimeFilter{
timeField: String.t() | nil,
timeRange: [Link].t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1TimestampArray
Timestamp values.

Attributes

values (type:
list([Link]
entwarehouseV1TimestampValue.t), default: nil) - List of
timestamp values.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1TimestampArray{

values:
[

[Link].GoogleCloudContentwarehouseV1TimestampValue.t
()
]

| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1TimestampTypeOptions
Configurations for a timestamp property.

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link].GoogleCloudContentwarehouseV1TimestampTypeOp

tions{}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1TimestampValue
Timestamp value type.

Attributes

textValue (type: String.t, default: nil) - The string must

represent a valid instant in UTC and is parsed using
[Link].ISO_INSTANT. e.g. "2013-
09-29T18:46:19Z"
timestampValue (type: DateTime.t, default: nil) - Timestamp
value

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1TimestampValue{
textValue: String.t() | nil,

timestampValue: DateTime.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1UpdateDocumentMetadata
Metadata object for UpdateDocument request (currently empty).

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link].GoogleCloudContentwarehouseV1UpdateDocumentM

etadata{}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1UpdateDocumentRequest
Request message for [Link].

Attributes

cloudAiDocumentOption (type:
[Link]
default: nil) - Request
rehouseV1CloudAIDocumentOption.t,
Option for processing Cloud AI Document in Document
Warehouse. This field offers limited support for mapping entities
from Cloud AI Document to Warehouse Document. Please consult
with product team before using this field and other available
options.
document (type:
[Link]
rehouseV1Document.t, default: nil) - Required. The document to
update.
requestMetadata (type:
[Link]
default: nil) - The meta
rehouseV1RequestMetadata.t,
information collected about the end user, used to enforce access
control for the service.
updateOptions (type:
[Link]
rehouseV1UpdateOptions.t, default: nil) - Options for the
update operation.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1UpdateDocumentR
equest{
cloudAiDocumentOption:

[Link].GoogleCloudContentwarehouseV1CloudAIDocumentO
ption.t()
| nil,
document:

[Link].GoogleCloudContentwarehouseV1Document.t()

| nil,
requestMetadata:
 [Link].GoogleCloudContentwarehouseV1RequestMetadata.
t()
| nil,
updateOptions:

[Link].GoogleCloudContentwarehouseV1UpdateOptions.t(
)
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1UpdateDocumentResponse
Response message for [Link].

Attributes

document (type:
[Link]
default: nil) - Updated document after
rehouseV1Document.t,
executing update request.
metadata (type:
[Link]
default: nil) - Additional
rehouseV1ResponseMetadata.t,
information for the API invocation, such as the request tracking id.
ruleEngineOutput (type:
[Link]
default: nil) - Output from Rule
rehouseV1RuleEngineOutput.t,
Engine recording the rule evaluator and action executor's output.
Refer format in:
google/cloud/contentwarehouse/v1/rule_engine.proto

Summary
Types
t()
Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1UpdateDocumentR
esponse{

document:

[Link].GoogleCloudContentwarehouseV1Document.t()
| nil,

metadata:

[Link].GoogleCloudContentwarehouseV1ResponseMetadata
.t()
| nil,
ruleEngineOutput:

[Link].GoogleCloudContentwarehouseV1RuleEngineOutput
.t()

| nil
}
Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1UpdateDocumentSchemaReq
uest
Request message for
[Link].

Attributes

documentSchema (type:
[Link]
default: nil) - Required. The
rehouseV1DocumentSchema.t,
document schema to update with.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1UpdateDocumentS

chemaRequest{
documentSchema:

[Link].GoogleCloudContentwarehouseV1DocumentSchema.t
()
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1UpdateOptions
Options for Update operations.

Attributes

mergeFieldsOptions (type:
[Link]
rehouseV1MergeFieldsOptions.t, default: nil) - Options for
merging.
updateMask (type: String.t, default: nil) - Field mask for
merging Document fields. For the FieldMask definition, see
[Link]
buffers/docs/reference/[Link]#fieldmask
updateType (type: String.t, default: nil) - Type for update.

Summary
Types
t()

Functions
decode(value, options)
Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1UpdateOptions{
mergeFieldsOptions:

[Link].GoogleCloudContentwarehouseV1MergeFieldsOptio
ns.t()
| nil,

updateMask: String.t() | nil,

updateType: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1UpdateRuleSetRequest
Request message for [Link].

Attributes

ruleSet (type:
[Link]
rehouseV1RuleSet.t, default: nil) - Required. The rule set to
update.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1UpdateRuleSetRe

quest{
ruleSet:

[Link].GoogleCloudContentwarehouseV1RuleSet.t()
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1UserInfo
The user information.

Attributes

groupIds(type: list(String.t), default: nil) - The unique

group identifications which the user is belong to. The format is
"group:yyyy@[Link]";
id (type: String.t, default: nil) - A unique user identification
string, as determined by the client. The maximum number of
allowed characters is 255. Allowed characters include numbers 0 to
9, uppercase and lowercase letters, and restricted special symbols (:,
@, +, -, _, ~) The format is "user:xxxx@[Link]";

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleCloudContentwarehouseV1UserInfo{
groupIds: [String.t()] | nil,
id: String.t() | nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1Value
Value represents a dynamically typed value which can be either be a
float, a integer, a string, or a datetime value. A producer of value is
expected to set one of these variants. Absence of any variant indicates an
error.

Attributes

booleanValue (type: boolean(), default: nil) - Represents a

boolean value.
datetimeValue (type:
[Link].t
, default: nil) - Represents a datetime value.
enumValue (type:
[Link]
rehouseV1EnumValue.t, default: nil) - Represents an enum value.
floatValue (type: number(), default: nil) - Represents a float
value.
intValue (type: integer(), default: nil) - Represents a integer
value.
stringValue (type: String.t, default: nil) - Represents a string
value.
timestampValue (type:
[Link]
rehouseV1TimestampValue.t, default: nil) - Represents a
timestamp value.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1Value{
booleanValue: boolean() | nil,

datetimeValue:
[Link].t() | nil,

enumValue:

[Link].GoogleCloudContentwarehouseV1EnumValue.t()
| nil,

floatValue: number() | nil,

intValue: integer() | nil,
stringValue: String.t() | nil,
timestampValue:
 [Link].GoogleCloudContentwarehouseV1TimestampValue.t

()
| nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1WeightedSchemaProperty
Specifies the schema property name.

Attributes

documentSchemaName (type: String.t, default: nil) - The

document schema name.
propertyNames (type: list(String.t), default: nil) - The
property definition names in the schema.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types
 t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1WeightedSchemaP
roperty{
documentSchemaName: String.t() | nil,
propertyNames: [String.t()] | nil

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1beta1CreateDocumentMetad
ata
Metadata object for CreateDocument request (currently empty).

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link].GoogleCloudContentwarehouseV1beta1CreateDocu

mentMetadata{}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1beta1InitializeProjectRespon
se
Response message for [Link]

Attributes

message (type: String.t, default: nil) - The message of the

project initialization process.
state (type: String.t, default: nil) - The state of the project
initialization process.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::

%[Link].GoogleCloudContentwarehouseV1beta1Initialize

ProjectResponse{
message: String.t() | nil,

state: String.t() | nil

}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
[Link]
useV1beta1UpdateDocumentMetad
ata
Metadata object for UpdateDocument request (currently empty).

Attributes

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()
 @type t() ::

%[Link].GoogleCloudContentwarehouseV1beta1UpdateDocu
mentMetadata{}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
Model.GoogleCloudDocumentaiV1
Barcode
Encodes the detailed information of a barcode.

Attributes

format (type: String.t, default: nil) - Format of a barcode. The

supported formats are: - CODE_128: Code 128 type. - CODE_39:
Code 39 type. - CODE_93: Code 93 type. - CODABAR: Codabar type.
- DATA_MATRIX: 2D Data Matrix type. - ITF: ITF type. - EAN_13:
EAN-13 type. - EAN_8: EAN-8 type. - QR_CODE: 2D QR code type.
- UPC_A: UPC-A type. - UPC_E: UPC-E type. - PDF417: PDF417
type. - AZTEC: 2D Aztec code type. - DATABAR: GS1 DataBar code
type.
rawValue (type: String.t, default: nil) - Raw value encoded in
the barcode. For example:
'MEBKM:TITLE:Google;URL:[Link]
valueFormat (type: String.t, default: nil) - Value format
describes the format of the value that a barcode encodes. The
supported formats are: - CONTACT_INFO: Contact information. -
EMAIL: Email address. - ISBN: ISBN identifier. - PHONE: Phone
number. - PRODUCT: Product. - SMS: SMS message. - TEXT: Text
string. - URL: URL address. - WIFI: Wifi information. - GEO: Geo-
localization. - CALENDAR_EVENT: Calendar event. -
DRIVER_LICENSE: Driver's license.
Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() :: %[Link].GoogleCloudDocumentaiV1Barcode{

format: String.t() | nil,

rawValue: String.t() | nil,

valueFormat: String.t() | nil

}

Functions

decode(value, options)
@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
Model.GoogleCloudDocumentaiV1
BoundingPoly
A bounding polygon for the detected image annotation.

Attributes

normalizedVertices (type:
list([Link]
default: nil) - The bounding
mentaiV1NormalizedVertex.t),
polygon normalized vertices.
vertices (type:
list([Link]
mentaiV1Vertex.t), default: nil) - The bounding polygon
vertices.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleCloudDocumentaiV1BoundingPoly{
normalizedVertices:
[

[Link].GoogleCloudDocumentaiV1NormalizedVertex.t()
]
| nil,
vertices:
[[Link].GoogleCloudDocumentaiV1Vertex.t()]
| nil
}

Functions

decode(value, options)

@spec decode(struct(), keyword()) :: struct()

Unwrap a decoded JSON object into its complex fields.

[Link].V1.
Model.GoogleCloudDocumentaiV1
Document
Document represents the canonical document resource in Document AI.
It is an interchange format that provides insights into documents and
allows for collaboration between users and Document AI to iterate and
optimize for quality.

Attributes

content (type: String.t, default: nil) - Optional. Inline

document content, represented as a stream of bytes. Note: As with
all bytes fields, protobuffers use a pure binary representation,
whereas JSON representations use base64.
entities (type:
list([Link]
default: nil) - A list of entities
mentaiV1DocumentEntity.t),
detected on [Link]. For document shards, entities in this list
may cross shard boundaries.
entityRelations (type:
list([Link]
mentaiV1DocumentEntityRelation.t),default: nil) -
Placeholder. Relationship among [Link].
error (type:
[Link].t,
default: nil) - Any error that occurred while processing this
document.
mimeType (type: String.t, default: nil) - An IANA published
media type (MIME type).
 pages (type:
list([Link]
mentaiV1DocumentPage.t), default: nil) - Visual page layout for
the Document.
revisions (type:
list([Link]
default: nil) - Placeholder.
mentaiV1DocumentRevision.t),
Revision history of this document.
shardInfo (type:
[Link]
iV1DocumentShardInfo.t, default: nil) - Information about the
sharding if this document is sharded part of a larger document. If
the document is not sharded, this message is not specified.
text (type: String.t, default: nil) - Optional. UTF-8 encoded
text in reading order from the document.
textChanges (type:
list([Link]
mentaiV1DocumentTextChange.t),default: nil) - Placeholder. A
list of text corrections made to [Link]. This is usually used
for annotating corrections to OCR mistakes. Text changes for a
given revision may not overlap with each other.
textStyles (type:
list([Link]
mentaiV1DocumentStyle.t), default: nil) - Styles for the
[Link].
uri (type: String.t, default: nil) - Optional. Currently supports
Google Cloud Storage URI of the form
gs://bucket_name/object_name. Object versioning is not
supported. For more information, refer to Google Cloud Storage
Request URIs.

Summary
Types
t()

Functions
decode(value, options)

Unwrap a decoded JSON object into its complex fields.

Types

t()

@type t() ::
%[Link].GoogleCloudDocumentaiV1Document{
content: String.t() | nil,
entities:
[

[Link].GoogleCloudDocumentaiV1DocumentEntity.t()

]
| nil,

entityRelations:
[

[Link].GoogleCloudDocumentaiV1DocumentEntityRelation

.t()
]

| nil,
error: [Link].t() | nil,
 mimeType: String.t() | nil,

pages:
[

[Link].GoogleCloudDocumentaiV1DocumentPage.t()
]

| nil,
revisions:

[Link].GoogleCloudDocumentaiV1DocumentRevision.t()
]

| nil,
shardInfo:

[Link].GoogleCloudDocumentaiV1DocumentShardInfo.t()
| nil,

text: String.t() | nil,

textChanges:

[Link].GoogleCloudDocumentaiV1DocumentTextChange.t()
]

| nil,
textStyles:

[Link].GoogleCloudDocumentaiV1DocumentStyle.t()
]

| nil,
uri: String.t() | nil

Functions