Get specific billing details

GET 
/bv/billing/v1/billings/:id

Fetches the specific billing details within the organization.

Request

Path Parameters

id stringrequired

The billing ID

Responses

200

A successful response.

application/json

Schema

Schema

billing object
id string
org_id string
org_name string
org_type string
Possible values: [ORGANIZATION_TYPE_ROOT, ORGANIZATION_TYPE_GENERAL_DISTRIBUTOR, ORGANIZATION_TYPE_RESELLER, ORGANIZATION_TYPE_BUSINESS]
parent_org_name string
parent_org_type string
Possible values: [ORGANIZATION_TYPE_ROOT, ORGANIZATION_TYPE_GENERAL_DISTRIBUTOR, ORGANIZATION_TYPE_RESELLER, ORGANIZATION_TYPE_BUSINESS]
org_time_zone string
plan_type string
Possible values: [PLAN_TYPE_STANDARD, PLAN_TYPE_PAY_AS_YOU_GO]
logo_type string
Possible values: [LOGO_TYPE_BLEND_VISION, LOGO_TYPE_BLEND_VISION_AIM, LOGO_TYPE_BLEND_VISION_ONE, LOGO_TYPE_BLEND_VISION_AISK]
currency_code string
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
start_time date-time
end_time date-time
plans object[]
Array [
id string
name string
count int64
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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_gpt3_5_turbo_with_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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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_gpt3_5_turbo_with_16k_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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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_gpt4_with_8k_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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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_gpt4_with_32k_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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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_gpt4_with_128k_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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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[]
Array [
start_time date-time
end_time date-time
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
value string
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:
• 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).
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.
]
update_time date-time

Example (from schema)

{
  "billing": {
    "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": "LOGO_TYPE_BLEND_VISION",
    "currency_code": "string",
    "total_price": {
      "value": "string"
    },
    "subscription_price": {
      "value": "string"
    },
    "overage_price": {
      "value": "string"
    },
    "additional_price": {
      "value": "string"
    },
    "start_time": "2024-05-20T05:01:36.405Z",
    "end_time": "2024-05-20T05:01:36.405Z",
    "plans": [
      {
        "id": "string",
        "name": "string",
        "count": "string",
        "price": {
          "value": "string"
        },
        "unit_price": {
          "value": "string"
        }
      }
    ],
    "storage": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "encoding": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "live": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "drm": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "cdn": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "audio_encoding_times": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "player_license": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "bot": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "message": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "embedding_character": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "stt": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "stored_character": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "premium_support_price": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "live_support_price": {
      "usage": {
        "value": "string"
      },
      "price": {
        "value": "string"
      },
      "quota": {
        "value": "string"
      },
      "overage_usage": {
        "value": "string"
      },
      "unit_price": {
        "value": "string"
      }
    },
    "video_library_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "history_vod_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "history_audio_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "encoding_base_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "encoding_pte_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "encoding_faster_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "encoding_h265_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "encoding_live_to_vod_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "encoding_audio_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "cdn_base_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "cdn_others_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "live_base_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "live_4k_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "live_ull_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "drm_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "audio_encoding_times_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "player_license_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "bot_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "message_base_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "message_gpt3_5_turbo_with_4k_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "message_gpt3_5_turbo_with_16k_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "message_gpt4_with_8k_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "message_gpt4_with_32k_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "message_gpt4_with_128k_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "embedding_character_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "stt_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "stored_character_usage_info": {
      "real_usage": {
        "value": "string"
      },
      "rate": {
        "value": "string"
      },
      "usage": {
        "value": "string"
      }
    },
    "live_support_histories": [
      {
        "start_time": "2024-05-20T05:01:36.411Z",
        "end_time": "2024-05-20T05:01:36.411Z",
        "hour_count": {
          "value": "string"
        },
        "unit_price": {
          "value": "string"
        },
        "price": {
          "value": "string"
        }
      }
    ],
    "update_time": "2024-05-20T05:01:36.411Z"
  }
}

400

A bad request response. The code is 3 means got an invalid argument. There are more HTTP status code mappings listed on here and gRPC code on here.

application/json

Schema

Schema

code int32
message string
details object[]
Array [
@type string
A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in path/google.protobuf.Duration). The name should be in a canonical form (e.g., leading "." is not accepted).
In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme http, https, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
• If no scheme is provided, https is assumed.
• An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error.
• Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. As of May 2023, there are no widely used type server implementations and no plans to implement one.
Schemes other than http, https (or the empty scheme) might be used with implementation specific semantics.
]

Example (from schema)

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

401

A unauthenticated response. The header authorization was missing or unidentified.

application/json

Schema

Schema

code int32
message string
details object[]
Array [
@type string
A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in path/google.protobuf.Duration). The name should be in a canonical form (e.g., leading "." is not accepted).
In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme http, https, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
• If no scheme is provided, https is assumed.
• An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error.
• Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. As of May 2023, there are no widely used type server implementations and no plans to implement one.
Schemes other than http, https (or the empty scheme) might be used with implementation specific semantics.
]

Example (from schema)

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

403

A forbidden response. It means that the provided authorization did not have enough permission to access the resource or the API.

application/json

Schema

Schema

code int32
message string
details object[]
Array [
@type string
A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in path/google.protobuf.Duration). The name should be in a canonical form (e.g., leading "." is not accepted).
In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme http, https, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
• If no scheme is provided, https is assumed.
• An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error.
• Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. As of May 2023, there are no widely used type server implementations and no plans to implement one.
Schemes other than http, https (or the empty scheme) might be used with implementation specific semantics.
]

Example (from schema)

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

500

A server error response. There are more HTTP status code mappings listed on here.

application/json

Schema

Schema

code int32
message string
details object[]
Array [
@type string
A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in path/google.protobuf.Duration). The name should be in a canonical form (e.g., leading "." is not accepted).
In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme http, https, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
• If no scheme is provided, https is assumed.
• An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error.
• Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. As of May 2023, there are no widely used type server implementations and no plans to implement one.
Schemes other than http, https (or the empty scheme) might be used with implementation specific semantics.
]

Example (from schema)

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

default

An unexpected error response.

application/json

Schema

Schema

code int32
message string
details object[]
Array [
@type string
A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in path/google.protobuf.Duration). The name should be in a canonical form (e.g., leading "." is not accepted).
In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme http, https, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:
• If no scheme is provided, https is assumed.
• An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error.
• Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)
Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. As of May 2023, there are no widely used type server implementations and no plans to implement one.
Schemes other than http, https (or the empty scheme) might be used with implementation specific semantics.
]

Example (from schema)

{
  "code": 0,
  "message": "string",
  "details": [
    {
      "@type": "string"
    }
  ]
}

Loading...