List billings for sub-organizations
GET/bv/billing/v1/billings:list-sub-org
Lists specific billing details for all sub-organizations under the current billing entity. It provides a consolidated view of billings.
Request
Query Parameters
Responses
- 200
- 400
- 401
- 403
- 500
- default
A successful response.
- application/json
- Schema
- Example (from schema)
Schema
- Array [
- Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Array [
- Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - ]
- Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Array [
- Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - Removing an explicitly-provided
+
sign (+2.5
->2.5
). - Replacing a zero-length integer value with
0
(.5
->0.5
). - Coercing the exponent character to lower-case (
2.5E8
->2.5e8
). - Removing an explicitly-provided zero exponent (
2.5e0
->2.5
). - ]
- ]
billings object[]
Possible values: [ORGANIZATION_TYPE_ROOT
, ORGANIZATION_TYPE_GENERAL_DISTRIBUTOR
, ORGANIZATION_TYPE_RESELLER
, ORGANIZATION_TYPE_BUSINESS
]
Possible values: [ORGANIZATION_TYPE_ROOT
, ORGANIZATION_TYPE_GENERAL_DISTRIBUTOR
, ORGANIZATION_TYPE_RESELLER
, ORGANIZATION_TYPE_BUSINESS
]
Possible values: [PLAN_TYPE_STANDARD
, PLAN_TYPE_PAY_AS_YOU_GO
]
Possible values: [LOGO_TYPE_BLEND_VISION
, LOGO_TYPE_BLEND_VISION_AIM
, LOGO_TYPE_BLEND_VISION_ONE
, LOGO_TYPE_BLEND_VISION_AISK
]
total_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
subscription_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
additional_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
plans object[]
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
storage object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
encoding object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
live object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
drm object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
cdn object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
audio_encoding_times object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
player_license object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
bot object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
message object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
embedding_character object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
stt object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
stored_character object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
ai_insight object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
premium_support_price object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
live_support_price object
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
quota object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
overage_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
video_library_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
history_vod_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
history_audio_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
encoding_base_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
encoding_pte_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
encoding_faster_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
encoding_h265_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
encoding_live_to_vod_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
encoding_audio_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
cdn_base_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
cdn_others_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
live_base_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
live_4k_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
live_ull_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
drm_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
audio_encoding_times_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
player_license_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
bot_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
message_base_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
embedding_character_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
stt_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
stored_character_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
ai_insight_usage_info object
real_usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
rate object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
usage object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
live_support_histories object[]
hour_count object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
unit_price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
price object
A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's BigDecimal or Python's decimal.Decimal.
The decimal value, as a string.
The string representation consists of an optional sign, +
(U+002B
)
or -
(U+002D
), followed by a sequence of zero or more decimal digits
("the integer"), optionally followed by a fraction, optionally followed
by an exponent.
The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand.
The exponent consists of the character e
(U+0065
) or E
(U+0045
)
followed by one or more decimal digits.
Services should normalize decimal values before storing them by:
Services may perform additional normalization based on its own needs
and the internal decimal implementation selected, such as shifting the
decimal point and exponent value together (example: 2.5e-1
<-> 0.25
).
Additionally, services may preserve trailing zeroes in the fraction
to indicate increased precision, but are not required to do so.
Note that only the .
character is supported to divide the integer
and the fraction; ,
should not be supported regardless of locale.
Additionally, thousand separators should not be supported. If a
service does support them, values must be normalized.
The ENBF grammar is:
DecimalString =
[Sign] Significand [Exponent];
Sign = '+' | '-';
Significand =
Digits ['.'] [Digits] | [Digits] '.' Digits;
Exponent = ('e' | 'E') [Sign] Digits;
Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };
Services should clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values.
Services may choose to accept values passed as input even when the
value has a higher precision or scale than the service supports, and
should round the value to fit the supported scale. Alternatively, the
service may error with 400 Bad Request
(INVALID_ARGUMENT
in gRPC)
if precision would be lost.
Services should error with 400 Bad Request
(INVALID_ARGUMENT
in
gRPC) if the service receives a value outside of the supported range.
pagination object
Output only. The total numbers of the list in the current pagination.
Output only. The number of items per page in the current pagination.
Output only. The current page in the current pagination.
{
"billings": [
{
"id": "string",
"org_id": "string",
"org_name": "string",
"org_type": "ORGANIZATION_TYPE_ROOT",
"parent_org_name": "string",
"parent_org_type": "ORGANIZATION_TYPE_ROOT",
"org_time_zone": "string",
"plan_type": "PLAN_TYPE_STANDARD",
"logo_type":