diff --git a/addressvalidation/v1/addressvalidation-api.json b/addressvalidation/v1/addressvalidation-api.json new file mode 100644 index 0000000000..a3e218837a --- /dev/null +++ b/addressvalidation/v1/addressvalidation-api.json @@ -0,0 +1,834 @@ +{ + "auth": { + "oauth2": { + "scopes": { + "https://www.googleapis.com/auth/cloud-platform": { + "description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." + }, + "https://www.googleapis.com/auth/maps-platform.addressvalidation": { + "description": "Private Service: https://www.googleapis.com/auth/maps-platform.addressvalidation" + } + } + } + }, + "basePath": "", + "baseUrl": "https://addressvalidation.googleapis.com/", + "batchPath": "batch", + "canonicalName": "Address Validation", + "description": "The Address Validation API allows developers to verify the accuracy of addresses. Given an address, it returns information about the correctness of the components of the parsed address, a geocode, and a verdict on the deliverability of the parsed address.", + "discoveryVersion": "v1", + "documentationLink": "https://developers.google.com/maps/documentation/addressvalidation", + "fullyEncodeReservedExpansion": true, + "icons": { + "x16": "http://www.google.com/images/icons/product/search-16.gif", + "x32": "http://www.google.com/images/icons/product/search-32.gif" + }, + "id": "addressvalidation:v1", + "kind": "discovery#restDescription", + "mtlsRootUrl": "https://addressvalidation.mtls.googleapis.com/", + "name": "addressvalidation", + "ownerDomain": "google.com", + "ownerName": "Google", + "parameters": { + "$.xgafv": { + "description": "V1 error format.", + "enum": [ + "1", + "2" + ], + "enumDescriptions": [ + "v1 error format", + "v2 error format" + ], + "location": "query", + "type": "string" + }, + "access_token": { + "description": "OAuth access token.", + "location": "query", + "type": "string" + }, + "alt": { + "default": "json", + "description": "Data format for response.", + "enum": [ + "json", + "media", + "proto" + ], + "enumDescriptions": [ + "Responses with Content-Type of application/json", + "Media download with context-dependent Content-Type", + "Responses with Content-Type of application/x-protobuf" + ], + "location": "query", + "type": "string" + }, + "callback": { + "description": "JSONP", + "location": "query", + "type": "string" + }, + "fields": { + "description": "Selector specifying which fields to include in a partial response.", + "location": "query", + "type": "string" + }, + "key": { + "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", + "location": "query", + "type": "string" + }, + "oauth_token": { + "description": "OAuth 2.0 token for the current user.", + "location": "query", + "type": "string" + }, + "prettyPrint": { + "default": "true", + "description": "Returns response with indentations and line breaks.", + "location": "query", + "type": "boolean" + }, + "quotaUser": { + "description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", + "location": "query", + "type": "string" + }, + "uploadType": { + "description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", + "location": "query", + "type": "string" + }, + "upload_protocol": { + "description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", + "location": "query", + "type": "string" + } + }, + "protocol": "rest", + "resources": { + "v1": { + "methods": { + "provideValidationFeedback": { + "description": "Feedback about the outcome of the sequence of validation attempts. This should be the last call made after a sequence of validation calls for the same address, and should be called once the transaction is concluded. This should only be sent once for the sequence of `ValidateAddress` requests needed to validate an address fully.", + "flatPath": "v1:provideValidationFeedback", + "httpMethod": "POST", + "id": "addressvalidation.provideValidationFeedback", + "parameterOrder": [], + "parameters": {}, + "path": "v1:provideValidationFeedback", + "request": { + "$ref": "GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest" + }, + "response": { + "$ref": "GoogleMapsAddressvalidationV1ProvideValidationFeedbackResponse" + }, + "scopes": [ + "https://www.googleapis.com/auth/cloud-platform", + "https://www.googleapis.com/auth/maps-platform.addressvalidation" + ] + }, + "validateAddress": { + "description": "Validates an address.", + "flatPath": "v1:validateAddress", + "httpMethod": "POST", + "id": "addressvalidation.validateAddress", + "parameterOrder": [], + "parameters": {}, + "path": "v1:validateAddress", + "request": { + "$ref": "GoogleMapsAddressvalidationV1ValidateAddressRequest" + }, + "response": { + "$ref": "GoogleMapsAddressvalidationV1ValidateAddressResponse" + }, + "scopes": [ + "https://www.googleapis.com/auth/cloud-platform", + "https://www.googleapis.com/auth/maps-platform.addressvalidation" + ] + } + } + } + }, + "revision": "20240410", + "rootUrl": "https://addressvalidation.googleapis.com/", + "schemas": { + "GoogleGeoTypeViewport": { + "description": "A latitude-longitude viewport, represented as two diagonally opposite `low` and `high` points. A viewport is considered a closed region, i.e. it includes its boundary. The latitude bounds must range between -90 to 90 degrees inclusive, and the longitude bounds must range between -180 to 180 degrees inclusive. Various cases include: - If `low` = `high`, the viewport consists of that single point. - If `low.longitude` \u003e `high.longitude`, the longitude range is inverted (the viewport crosses the 180 degree longitude line). - If `low.longitude` = -180 degrees and `high.longitude` = 180 degrees, the viewport includes all longitudes. - If `low.longitude` = 180 degrees and `high.longitude` = -180 degrees, the longitude range is empty. - If `low.latitude` \u003e `high.latitude`, the latitude range is empty. Both `low` and `high` must be populated, and the represented box cannot be empty (as specified by the definitions above). An empty viewport will result in an error. For example, this viewport fully encloses New York City: { \"low\": { \"latitude\": 40.477398, \"longitude\": -74.259087 }, \"high\": { \"latitude\": 40.91618, \"longitude\": -73.70018 } }", + "id": "GoogleGeoTypeViewport", + "properties": { + "high": { + "$ref": "GoogleTypeLatLng", + "description": "Required. The high point of the viewport." + }, + "low": { + "$ref": "GoogleTypeLatLng", + "description": "Required. The low point of the viewport." + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1Address": { + "description": "Details of the post-processed address. Post-processing includes correcting misspelled parts of the address, replacing incorrect parts, and inferring missing parts.", + "id": "GoogleMapsAddressvalidationV1Address", + "properties": { + "addressComponents": { + "description": "Unordered list. The individual address components of the formatted and corrected address, along with validation information. This provides information on the validation status of the individual components. Address components are not ordered in a particular way. Do not make any assumptions on the ordering of the address components in the list.", + "items": { + "$ref": "GoogleMapsAddressvalidationV1AddressComponent" + }, + "type": "array" + }, + "formattedAddress": { + "description": "The post-processed address, formatted as a single-line address following the address formatting rules of the region where the address is located.", + "type": "string" + }, + "missingComponentTypes": { + "description": "The types of components that were expected to be present in a correctly formatted mailing address but were not found in the input AND could not be inferred. Components of this type are not present in `formatted_address`, `postal_address`, or `address_components`. An example might be `['street_number', 'route']` for an input like \"Boulder, Colorado, 80301, USA\". The list of possible types can be found [here](https://developers.google.com/maps/documentation/geocoding/requests-geocoding#Types).", + "items": { + "type": "string" + }, + "type": "array" + }, + "postalAddress": { + "$ref": "GoogleTypePostalAddress", + "description": "The post-processed address represented as a postal address." + }, + "unconfirmedComponentTypes": { + "description": "The types of the components that are present in the `address_components` but could not be confirmed to be correct. This field is provided for the sake of convenience: its contents are equivalent to iterating through the `address_components` to find the types of all the components where the confirmation_level is not CONFIRMED or the inferred flag is not set to `true`. The list of possible types can be found [here](https://developers.google.com/maps/documentation/geocoding/requests-geocoding#Types).", + "items": { + "type": "string" + }, + "type": "array" + }, + "unresolvedTokens": { + "description": "Any tokens in the input that could not be resolved. This might be an input that was not recognized as a valid part of an address (for example in an input like \"123235253253 Main St, San Francisco, CA, 94105\", the unresolved tokens may look like `[\"123235253253\"]` since that does not look like a valid street number.", + "items": { + "type": "string" + }, + "type": "array" + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1AddressComponent": { + "description": "Represents an address component, such as a street, city, or state.", + "id": "GoogleMapsAddressvalidationV1AddressComponent", + "properties": { + "componentName": { + "$ref": "GoogleMapsAddressvalidationV1ComponentName", + "description": "The name for this component." + }, + "componentType": { + "description": "The type of the address component. See [Table 2: Additional types returned by the Places service](https://developers.google.com/places/web-service/supported_types#table2) for a list of possible types.", + "type": "string" + }, + "confirmationLevel": { + "description": "Indicates the level of certainty that we have that the component is correct.", + "enum": [ + "CONFIRMATION_LEVEL_UNSPECIFIED", + "CONFIRMED", + "UNCONFIRMED_BUT_PLAUSIBLE", + "UNCONFIRMED_AND_SUSPICIOUS" + ], + "enumDescriptions": [ + "Default value. This value is unused.", + "We were able to verify that this component exists and makes sense in the context of the rest of the address.", + "This component could not be confirmed, but it is plausible that it exists. For example, a street number within a known valid range of numbers on a street where specific house numbers are not known.", + "This component was not confirmed and is likely to be wrong. For example, a neighborhood that does not fit the rest of the address." + ], + "type": "string" + }, + "inferred": { + "description": "Indicates that the component was not part of the input, but we inferred it for the address location and believe it should be provided for a complete address.", + "type": "boolean" + }, + "replaced": { + "description": "Indicates the name of the component was replaced with a completely different one, for example a wrong postal code being replaced with one that is correct for the address. This is not a cosmetic change, the input component has been changed to a different one.", + "type": "boolean" + }, + "spellCorrected": { + "description": "Indicates a correction to a misspelling in the component name. The API does not always flag changes from one spelling variant to another, such as when changing \"centre\" to \"center\". It also does not always flag common misspellings, such as when changing \"Amphitheater Pkwy\" to \"Amphitheatre Pkwy\".", + "type": "boolean" + }, + "unexpected": { + "description": "Indicates an address component that is not expected to be present in a postal address for the given region. We have retained it only because it was part of the input.", + "type": "boolean" + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1AddressMetadata": { + "description": "The metadata for the address. `metadata` is not guaranteed to be fully populated for every address sent to the Address Validation API.", + "id": "GoogleMapsAddressvalidationV1AddressMetadata", + "properties": { + "business": { + "description": "Indicates that this is the address of a business. If unset, indicates that the value is unknown.", + "type": "boolean" + }, + "poBox": { + "description": "Indicates that the address of a PO box. If unset, indicates that the value is unknown.", + "type": "boolean" + }, + "residential": { + "description": "Indicates that this is the address of a residence. If unset, indicates that the value is unknown.", + "type": "boolean" + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1ComponentName": { + "description": "A wrapper for the name of the component.", + "id": "GoogleMapsAddressvalidationV1ComponentName", + "properties": { + "languageCode": { + "description": "The BCP-47 language code. This will not be present if the component name is not associated with a language, such as a street number.", + "type": "string" + }, + "text": { + "description": "The name text. For example, \"5th Avenue\" for a street name or \"1253\" for a street number.", + "type": "string" + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1Geocode": { + "description": "Contains information about the place the input was geocoded to.", + "id": "GoogleMapsAddressvalidationV1Geocode", + "properties": { + "bounds": { + "$ref": "GoogleGeoTypeViewport", + "description": "The bounds of the geocoded place." + }, + "featureSizeMeters": { + "description": "The size of the geocoded place, in meters. This is another measure of the coarseness of the geocoded location, but in physical size rather than in semantic meaning.", + "format": "float", + "type": "number" + }, + "location": { + "$ref": "GoogleTypeLatLng", + "description": "The geocoded location of the input. Using place IDs is preferred over using addresses, latitude/longitude coordinates, or plus codes. Using coordinates when routing or calculating driving directions will always result in the point being snapped to the road nearest to those coordinates. This may not be a road that will quickly or safely lead to the destination and may not be near an access point to the property. Additionally, when a location is reverse geocoded, there is no guarantee that the returned address will match the original." + }, + "placeId": { + "description": "The PlaceID of the place this input geocodes to. For more information about Place IDs see [here](https://developers.google.com/maps/documentation/places/web-service/place-id).", + "type": "string" + }, + "placeTypes": { + "description": "The type(s) of place that the input geocoded to. For example, `['locality', 'political']`. The full list of types can be found [here](https://developers.google.com/maps/documentation/geocoding/requests-geocoding#Types).", + "items": { + "type": "string" + }, + "type": "array" + }, + "plusCode": { + "$ref": "GoogleMapsAddressvalidationV1PlusCode", + "description": "The plus code corresponding to the `location`." + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1LanguageOptions": { + "description": "Preview: This feature is in Preview (pre-GA). Pre-GA products and features might have limited support, and changes to pre-GA products and features might not be compatible with other pre-GA versions. Pre-GA Offerings are covered by the [Google Maps Platform Service Specific Terms](https://cloud.google.com/maps-platform/terms/maps-service-terms). For more information, see the [launch stage descriptions](https://developers.google.com/maps/launch-stages). Enables the Address Validation API to include additional information in the response.", + "id": "GoogleMapsAddressvalidationV1LanguageOptions", + "properties": { + "returnEnglishLatinAddress": { + "description": "Preview: Return a [google.maps.addressvalidation.v1.Address] in English. See [google.maps.addressvalidation.v1.ValidationResult.english_latin_address] for details.", + "type": "boolean" + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1PlusCode": { + "description": "Plus code (http://plus.codes) is a location reference with two formats: global code defining a 14mx14m (1/8000th of a degree) or smaller rectangle, and compound code, replacing the prefix with a reference location.", + "id": "GoogleMapsAddressvalidationV1PlusCode", + "properties": { + "compoundCode": { + "description": "Place's compound code, such as \"33GV+HQ, Ramberg, Norway\", containing the suffix of the global code and replacing the prefix with a formatted name of a reference entity.", + "type": "string" + }, + "globalCode": { + "description": "Place's global (full) code, such as \"9FWM33GV+HQ\", representing an 1/8000 by 1/8000 degree area (~14 by 14 meters).", + "type": "string" + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest": { + "description": "The request for sending validation feedback.", + "id": "GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest", + "properties": { + "conclusion": { + "description": "Required. The outcome of the sequence of validation attempts. If this field is set to `VALIDATION_CONCLUSION_UNSPECIFIED`, an `INVALID_ARGUMENT` error will be returned.", + "enum": [ + "VALIDATION_CONCLUSION_UNSPECIFIED", + "VALIDATED_VERSION_USED", + "USER_VERSION_USED", + "UNVALIDATED_VERSION_USED", + "UNUSED" + ], + "enumDescriptions": [ + "This value is unused. If the `ProvideValidationFeedbackRequest.conclusion` field is set to `VALIDATION_CONCLUSION_UNSPECIFIED`, an `INVALID_ARGUMENT` error will be returned.", + "The version of the address returned by the Address Validation API was used for the transaction.", + "The version of the address provided by the user was used for the transaction", + "A version of the address that was entered after the last validation attempt but that was not re-validated was used for the transaction.", + "The transaction was abandoned and the address was not used." + ], + "type": "string" + }, + "responseId": { + "description": "Required. The ID of the response that this feedback is for. This should be the response_id from the first response in a series of address validation attempts.", + "type": "string" + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1ProvideValidationFeedbackResponse": { + "description": "The response for validation feedback. The response is empty if the feedback is sent successfully.", + "id": "GoogleMapsAddressvalidationV1ProvideValidationFeedbackResponse", + "properties": {}, + "type": "object" + }, + "GoogleMapsAddressvalidationV1UspsAddress": { + "description": "USPS representation of a US address.", + "id": "GoogleMapsAddressvalidationV1UspsAddress", + "properties": { + "city": { + "description": "City name.", + "type": "string" + }, + "cityStateZipAddressLine": { + "description": "City + state + postal code.", + "type": "string" + }, + "firm": { + "description": "Firm name.", + "type": "string" + }, + "firstAddressLine": { + "description": "First address line.", + "type": "string" + }, + "secondAddressLine": { + "description": "Second address line.", + "type": "string" + }, + "state": { + "description": "2 letter state code.", + "type": "string" + }, + "urbanization": { + "description": "Puerto Rican urbanization name.", + "type": "string" + }, + "zipCode": { + "description": "Postal code e.g. 10009.", + "type": "string" + }, + "zipCodeExtension": { + "description": "4-digit postal code extension e.g. 5023.", + "type": "string" + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1UspsData": { + "description": "The USPS data for the address. `uspsData` is not guaranteed to be fully populated for every US or PR address sent to the Address Validation API. It's recommended to integrate the backup address fields in the response if you utilize uspsData as the primary part of the response.", + "id": "GoogleMapsAddressvalidationV1UspsData", + "properties": { + "abbreviatedCity": { + "description": "Abbreviated city.", + "type": "string" + }, + "addressRecordType": { + "description": "Type of the address record that matches the input address. * `F`: FIRM. This is a match to a Firm Record, which is the finest level of match available for an address. * `G`: GENERAL DELIVERY. This is a match to a General Delivery record. * `H`: BUILDING / APARTMENT. This is a match to a Building or Apartment record. * `P`: POST OFFICE BOX. This is a match to a Post Office Box. * `R`: RURAL ROUTE or HIGHWAY CONTRACT: This is a match to either a Rural Route or a Highway Contract record, both of which may have associated Box Number ranges. * `S`: STREET RECORD: This is a match to a Street record containing a valid primary number range.", + "type": "string" + }, + "carrierRoute": { + "description": "The carrier route code. A four character code consisting of a one letter prefix and a three digit route designator. Prefixes: * `C`: Carrier route (or city route) * `R`: Rural route * `H`: Highway Contract Route * `B`: Post Office Box Section * `G`: General delivery unit", + "type": "string" + }, + "carrierRouteIndicator": { + "description": "Carrier route rate sort indicator.", + "type": "string" + }, + "cassProcessed": { + "description": "Indicator that the request has been CASS processed.", + "type": "boolean" + }, + "county": { + "description": "County name.", + "type": "string" + }, + "defaultAddress": { + "description": "Indicator that a default address was found, but more specific addresses exists.", + "type": "boolean" + }, + "deliveryPointCheckDigit": { + "description": "The delivery point check digit. This number is added to the end of the delivery_point_barcode for mechanically scanned mail. Adding all the digits of the delivery_point_barcode, delivery_point_check_digit, postal code, and ZIP+4 together should yield a number divisible by 10.", + "type": "string" + }, + "deliveryPointCode": { + "description": "2 digit delivery point code", + "type": "string" + }, + "dpvCmra": { + "description": "Indicates if the address is a CMRA (Commercial Mail Receiving Agency)--a private business receiving mail for clients. Returns a single character. * `Y`: The address is a CMRA * `N`: The address is not a CMRA", + "type": "string" + }, + "dpvConfirmation": { + "description": "The possible values for DPV confirmation. Returns a single character or returns no value. * `N`: Primary and any secondary number information failed to DPV confirm. * `D`: Address was DPV confirmed for the primary number only, and the secondary number information was missing. * `S`: Address was DPV confirmed for the primary number only, and the secondary number information was present but not confirmed. * `Y`: Address was DPV confirmed for primary and any secondary numbers. * Empty: If the response does not contain a `dpv_confirmation` value, the address was not submitted for DPV confirmation.", + "type": "string" + }, + "dpvDoorNotAccessible": { + "description": "Flag indicates addresses where USPS cannot knock on a door to deliver mail. Returns a single character. * `Y`: The door is not accessible. * `N`: No indication the door is not accessible.", + "type": "string" + }, + "dpvDrop": { + "description": "Flag indicates mail is delivered to a single receptable at a site. Returns a single character. * `Y`: The mail is delivered to a single receptable at a site. * `N`: The mail is not delivered to a single receptable at a site.", + "type": "string" + }, + "dpvEnhancedDeliveryCode": { + "description": "Indicates that more than one DPV return code is valid for the address. Returns a single character. * `Y`: Address was DPV confirmed for primary and any secondary numbers. * `N`: Primary and any secondary number information failed to DPV confirm. * `S`: Address was DPV confirmed for the primary number only, and the secondary number information was present by not confirmed, or a single trailing alpha on a primary number was dropped to make a DPV match and secondary information required. * `D`: Address was DPV confirmed for the primary number only, and the secondary number information was missing. * `R`: Address confirmed but assigned to phantom route R777 and R779 and USPS delivery is not provided.", + "type": "string" + }, + "dpvFootnote": { + "description": "The footnotes from delivery point validation. Multiple footnotes may be strung together in the same string. * `AA`: Input address matched to the ZIP+4 file * `A1`: Input address was not matched to the ZIP+4 file * `BB`: Matched to DPV (all components) * `CC`: Secondary number not matched and not required * `C1`: Secondary number not matched but required * `N1`: High-rise address missing secondary number * `M1`: Primary number missing * `M3`: Primary number invalid * `P1`: Input address PO, RR or HC box number missing * `P3`: Input address PO, RR, or HC Box number invalid * `F1`: Input address matched to a military address * `G1`: Input address matched to a general delivery address * `U1`: Input address matched to a unique ZIP code * `PB`: Input address matched to PBSA record * `RR`: DPV confirmed address with PMB information * `R1`: DPV confirmed address without PMB information * `R7`: Carrier Route R777 or R779 record * `IA`: Informed Address identified * `TA`: Primary number matched by dropping a trailing alpha", + "type": "string" + }, + "dpvNoSecureLocation": { + "description": "Flag indicates door is accessible, but package will not be left due to security concerns. Returns a single character. * `Y`: The package will not be left due to security concerns. * `N`: No indication the package will not be left due to security concerns.", + "type": "string" + }, + "dpvNoStat": { + "description": "Is this a no stat address or an active address? No stat addresses are ones which are not continuously occupied or addresses that the USPS does not service. Returns a single character. * `Y`: The address is not active * `N`: The address is active", + "type": "string" + }, + "dpvNoStatReasonCode": { + "description": "Indicates the NoStat type. Returns a reason code as int. * `1`: IDA (Internal Drop Address) – Addresses that do not receive mail directly from the USPS but are delivered to a drop address that services them. * `2`: CDS - Addresses that have not yet become deliverable. For example, a new subdivision where lots and primary numbers have been determined, but no structure exists yet for occupancy. * `3`: Collision - Addresses that do not actually DPV confirm. * `4`: CMZ (College, Military and Other Types) - ZIP + 4 records USPS has incorporated into the data. * `5`: Regular - Indicates addresses not receiving delivery and the addresses are not counted as possible deliveries. * `6`: Secondary Required - The address requires secondary information.", + "format": "int32", + "type": "integer" + }, + "dpvNonDeliveryDays": { + "description": "Flag indicates mail delivery is not performed every day of the week. Returns a single character. * `Y`: The mail delivery is not performed every day of the week. * `N`: No indication the mail delivery is not performed every day of the week.", + "type": "string" + }, + "dpvNonDeliveryDaysValues": { + "description": "Integer identifying non-delivery days. It can be interrogated using bit flags: 0x40 – Sunday is a non-delivery day 0x20 – Monday is a non-delivery day 0x10 – Tuesday is a non-delivery day 0x08 – Wednesday is a non-delivery day 0x04 – Thursday is a non-delivery day 0x02 – Friday is a non-delivery day 0x01 – Saturday is a non-delivery day", + "format": "int32", + "type": "integer" + }, + "dpvPbsa": { + "description": "Indicates the address was matched to PBSA record. Returns a single character. * `Y`: The address was matched to PBSA record. * `N`: The address was not matched to PBSA record.", + "type": "string" + }, + "dpvThrowback": { + "description": "Indicates that mail is not delivered to the street address. Returns a single character. * `Y`: The mail is not delivered to the street address. * `N`: The mail is delivered to the street address.", + "type": "string" + }, + "dpvVacant": { + "description": "Is this place vacant? Returns a single character. * `Y`: The address is vacant * `N`: The address is not vacant", + "type": "string" + }, + "elotFlag": { + "description": "eLOT Ascending/Descending Flag (A/D).", + "type": "string" + }, + "elotNumber": { + "description": "Enhanced Line of Travel (eLOT) number.", + "type": "string" + }, + "errorMessage": { + "description": "Error message for USPS data retrieval. This is populated when USPS processing is suspended because of the detection of artificially created addresses. The USPS data fields might not be populated when this error is present.", + "type": "string" + }, + "ewsNoMatch": { + "description": "The delivery address is matchable, but the EWS file indicates that an exact match will be available soon.", + "type": "boolean" + }, + "fipsCountyCode": { + "description": "FIPS county code.", + "type": "string" + }, + "lacsLinkIndicator": { + "description": "LACSLink indicator.", + "type": "string" + }, + "lacsLinkReturnCode": { + "description": "LACSLink return code.", + "type": "string" + }, + "pmbDesignator": { + "description": "PMB (Private Mail Box) unit designator.", + "type": "string" + }, + "pmbNumber": { + "description": "PMB (Private Mail Box) number;", + "type": "string" + }, + "poBoxOnlyPostalCode": { + "description": "PO Box only postal code.", + "type": "boolean" + }, + "postOfficeCity": { + "description": "Main post office city.", + "type": "string" + }, + "postOfficeState": { + "description": "Main post office state.", + "type": "string" + }, + "standardizedAddress": { + "$ref": "GoogleMapsAddressvalidationV1UspsAddress", + "description": "USPS standardized address." + }, + "suitelinkFootnote": { + "description": "Footnotes from matching a street or highrise record to suite information. If business name match is found, the secondary number is returned. * `A`: SuiteLink record match, business address improved. * `00`: No match, business address is not improved.", + "type": "string" + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1ValidateAddressRequest": { + "description": "The request for validating an address.", + "id": "GoogleMapsAddressvalidationV1ValidateAddressRequest", + "properties": { + "address": { + "$ref": "GoogleTypePostalAddress", + "description": "Required. The address being validated. Unformatted addresses should be submitted via `address_lines`. The total length of the fields in this input must not exceed 280 characters. Supported regions can be found [here](https://developers.google.com/maps/documentation/address-validation/coverage). The language_code value in the input address is reserved for future uses and is ignored today. The validated address result will be populated based on the preferred language for the given address, as identified by the system. The Address Validation API ignores the values in recipients and organization. Any values in those fields will be discarded and not returned. Please do not set them." + }, + "enableUspsCass": { + "description": "Enables USPS CASS compatible mode. This affects _only_ the [google.maps.addressvalidation.v1.ValidationResult.usps_data] field of [google.maps.addressvalidation.v1.ValidationResult]. Note: for USPS CASS enabled requests for addresses in Puerto Rico, a [google.type.PostalAddress.region_code] of the `address` must be provided as \"PR\", or an [google.type.PostalAddress.administrative_area] of the `address` must be provided as \"Puerto Rico\" (case-insensitive) or \"PR\". It's recommended to use a componentized `address`, or alternatively specify at least two [google.type.PostalAddress.address_lines] where the first line contains the street number and name and the second line contains the city, state, and zip code.", + "type": "boolean" + }, + "languageOptions": { + "$ref": "GoogleMapsAddressvalidationV1LanguageOptions", + "description": "Optional. Preview: This feature is in Preview (pre-GA). Pre-GA products and features might have limited support, and changes to pre-GA products and features might not be compatible with other pre-GA versions. Pre-GA Offerings are covered by the [Google Maps Platform Service Specific Terms](https://cloud.google.com/maps-platform/terms/maps-service-terms). For more information, see the [launch stage descriptions](https://developers.google.com/maps/launch-stages). Enables the Address Validation API to include additional information in the response." + }, + "previousResponseId": { + "description": "This field must be empty for the first address validation request. If more requests are necessary to fully validate a single address (for example if the changes the user makes after the initial validation need to be re-validated), then each followup request must populate this field with the response_id from the very first response in the validation sequence.", + "type": "string" + }, + "sessionToken": { + "description": "Optional. A string which identifies an Autocomplete session for billing purposes. Must be a URL and filename safe base64 string with at most 36 ASCII characters in length. Otherwise an INVALID_ARGUMENT error is returned. The session begins when the user makes an Autocomplete query, and concludes when they select a place and a call to Place Details or Address Validation is made. Each session can have multiple Autocomplete queries, followed by one Place Details or Address Validation request. The credentials used for each request within a session must belong to the same Google Cloud Console project. Once a session has concluded, the token is no longer valid; your app must generate a fresh token for each session. If the `sessionToken` parameter is omitted, or if you reuse a session token, the session is charged as if no session token was provided (each request is billed separately). Note: Address Validation can only be used in sessions with the Autocomplete (New) API, not the Autocomplete API. See https://developers.google.com/maps/documentation/places/web-service/session-pricing for more details.", + "type": "string" + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1ValidateAddressResponse": { + "description": "The response to an address validation request.", + "id": "GoogleMapsAddressvalidationV1ValidateAddressResponse", + "properties": { + "responseId": { + "description": "The UUID that identifies this response. If the address needs to be re-validated, this UUID *must* accompany the new request.", + "type": "string" + }, + "result": { + "$ref": "GoogleMapsAddressvalidationV1ValidationResult", + "description": "The result of the address validation." + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1ValidationResult": { + "description": "The result of validating an address.", + "id": "GoogleMapsAddressvalidationV1ValidationResult", + "properties": { + "address": { + "$ref": "GoogleMapsAddressvalidationV1Address", + "description": "Information about the address itself as opposed to the geocode." + }, + "englishLatinAddress": { + "$ref": "GoogleMapsAddressvalidationV1Address", + "description": "Preview: This feature is in Preview (pre-GA). Pre-GA products and features might have limited support, and changes to pre-GA products and features might not be compatible with other pre-GA versions. Pre-GA Offerings are covered by the [Google Maps Platform Service Specific Terms](https://cloud.google.com/maps-platform/terms/maps-service-terms). For more information, see the [launch stage descriptions](https://developers.google.com/maps/launch-stages). The address translated to English. Translated addresses are not reusable as API input. The service provides them so that the user can use their native language to confirm or deny the validation of the originally-provided address. If part of the address doesn't have an English translation, the service returns that part in an alternate language that uses a Latin script. See [here](https://developers.google.com/maps/documentation/address-validation/convert-addresses-english) for an explanation of how the alternate language is selected. If part of the address doesn't have any translations or transliterations in a language that uses a Latin script, the service returns that part in the local language associated with the address. Enable this output by using the [google.maps.addressvalidation.v1.LanguageOptions.return_english_latin_address] flag. Note: the [google.maps.addressvalidation.v1.Address.unconfirmed_component_types] field in the `english_latin_address` and the [google.maps.addressvalidation.v1.AddressComponent.confirmation_level] fields in `english_latin_address.address_components` are not populated." + }, + "geocode": { + "$ref": "GoogleMapsAddressvalidationV1Geocode", + "description": "Information about the location and place that the address geocoded to." + }, + "metadata": { + "$ref": "GoogleMapsAddressvalidationV1AddressMetadata", + "description": "Other information relevant to deliverability. `metadata` is not guaranteed to be fully populated for every address sent to the Address Validation API." + }, + "uspsData": { + "$ref": "GoogleMapsAddressvalidationV1UspsData", + "description": "Extra deliverability flags provided by USPS. Only provided in region `US` and `PR`." + }, + "verdict": { + "$ref": "GoogleMapsAddressvalidationV1Verdict", + "description": "Overall verdict flags" + } + }, + "type": "object" + }, + "GoogleMapsAddressvalidationV1Verdict": { + "description": "High level overview of the address validation result and geocode.", + "id": "GoogleMapsAddressvalidationV1Verdict", + "properties": { + "addressComplete": { + "description": "The address is considered complete if there are no unresolved tokens, no unexpected or missing address components. If unset, indicates that the value is `false`. See `missing_component_types`, `unresolved_tokens` or `unexpected` fields for more details.", + "type": "boolean" + }, + "geocodeGranularity": { + "description": "Information about the granularity of the `geocode`. This can be understood as the semantic meaning of how coarse or fine the geocoded location is. This can differ from the `validation_granularity` above occasionally. For example, our database might record the existence of an apartment number but do not have a precise location for the apartment within a big apartment complex. In that case, the `validation_granularity` will be `SUB_PREMISE` but the `geocode_granularity` will be `PREMISE`.", + "enum": [ + "GRANULARITY_UNSPECIFIED", + "SUB_PREMISE", + "PREMISE", + "PREMISE_PROXIMITY", + "BLOCK", + "ROUTE", + "OTHER" + ], + "enumDescriptions": [ + "Default value. This value is unused.", + "Below-building level result, such as an apartment.", + "Building-level result.", + "A geocode that approximates the building-level location of the address.", + "The address or geocode indicates a block. Only used in regions which have block-level addressing, such as Japan.", + "The geocode or address is granular to route, such as a street, road, or highway.", + "All other granularities, which are bucketed together since they are not deliverable." + ], + "type": "string" + }, + "hasInferredComponents": { + "description": "At least one address component was inferred (added) that wasn't in the input, see [google.maps.addressvalidation.v1.Address.address_components] for details.", + "type": "boolean" + }, + "hasReplacedComponents": { + "description": "At least one address component was replaced, see [google.maps.addressvalidation.v1.Address.address_components] for details.", + "type": "boolean" + }, + "hasUnconfirmedComponents": { + "description": "At least one address component cannot be categorized or validated, see [google.maps.addressvalidation.v1.Address.address_components] for details.", + "type": "boolean" + }, + "inputGranularity": { + "description": "The granularity of the **input** address. This is the result of parsing the input address and does not give any validation signals. For validation signals, refer to `validation_granularity` below. For example, if the input address includes a specific apartment number, then the `input_granularity` here will be `SUB_PREMISE`. If we cannot match the apartment number in the databases or the apartment number is invalid, the `validation_granularity` will likely be `PREMISE` or below.", + "enum": [ + "GRANULARITY_UNSPECIFIED", + "SUB_PREMISE", + "PREMISE", + "PREMISE_PROXIMITY", + "BLOCK", + "ROUTE", + "OTHER" + ], + "enumDescriptions": [ + "Default value. This value is unused.", + "Below-building level result, such as an apartment.", + "Building-level result.", + "A geocode that approximates the building-level location of the address.", + "The address or geocode indicates a block. Only used in regions which have block-level addressing, such as Japan.", + "The geocode or address is granular to route, such as a street, road, or highway.", + "All other granularities, which are bucketed together since they are not deliverable." + ], + "type": "string" + }, + "validationGranularity": { + "description": "The granularity level that the API can fully **validate** the address to. For example, an `validation_granularity` of `PREMISE` indicates all address components at the level of `PREMISE` or more coarse can be validated. Per address component validation result can be found in [google.maps.addressvalidation.v1.Address.address_components].", + "enum": [ + "GRANULARITY_UNSPECIFIED", + "SUB_PREMISE", + "PREMISE", + "PREMISE_PROXIMITY", + "BLOCK", + "ROUTE", + "OTHER" + ], + "enumDescriptions": [ + "Default value. This value is unused.", + "Below-building level result, such as an apartment.", + "Building-level result.", + "A geocode that approximates the building-level location of the address.", + "The address or geocode indicates a block. Only used in regions which have block-level addressing, such as Japan.", + "The geocode or address is granular to route, such as a street, road, or highway.", + "All other granularities, which are bucketed together since they are not deliverable." + ], + "type": "string" + } + }, + "type": "object" + }, + "GoogleTypeLatLng": { + "description": "An object that represents a latitude/longitude pair. This is expressed as a pair of doubles to represent degrees latitude and degrees longitude. Unless specified otherwise, this object must conform to the WGS84 standard. Values must be within normalized ranges.", + "id": "GoogleTypeLatLng", + "properties": { + "latitude": { + "description": "The latitude in degrees. It must be in the range [-90.0, +90.0].", + "format": "double", + "type": "number" + }, + "longitude": { + "description": "The longitude in degrees. It must be in the range [-180.0, +180.0].", + "format": "double", + "type": "number" + } + }, + "type": "object" + }, + "GoogleTypePostalAddress": { + "description": "Represents a postal address, e.g. for postal delivery or payments addresses. Given a postal address, a postal service can deliver items to a premise, P.O. Box or similar. It is not intended to model geographical locations (roads, towns, mountains). In typical usage an address would be created via user input or from importing existing data, depending on the type of process. Advice on address input / editing: - Use an internationalization-ready address widget such as https://github.com/google/libaddressinput) - Users should not be presented with UI elements for input or editing of fields outside countries where that field is used. For more guidance on how to use this schema, please see: https://support.google.com/business/answer/6397478", + "id": "GoogleTypePostalAddress", + "properties": { + "addressLines": { + "description": "Unstructured address lines describing the lower levels of an address. Because values in address_lines do not have type information and may sometimes contain multiple values in a single field (e.g. \"Austin, TX\"), it is important that the line order is clear. The order of address lines should be \"envelope order\" for the country/region of the address. In places where this can vary (e.g. Japan), address_language is used to make it explicit (e.g. \"ja\" for large-to-small ordering and \"ja-Latn\" or \"en\" for small-to-large). This way, the most specific line of an address can be selected based on the language. The minimum permitted structural representation of an address consists of a region_code with all remaining information placed in the address_lines. It would be possible to format such an address very approximately without geocoding, but no semantic reasoning could be made about any of the address components until it was at least partially resolved. Creating an address only containing a region_code and address_lines, and then geocoding is the recommended way to handle completely unstructured addresses (as opposed to guessing which parts of the address should be localities or administrative areas).", + "items": { + "type": "string" + }, + "type": "array" + }, + "administrativeArea": { + "description": "Optional. Highest administrative subdivision which is used for postal addresses of a country or region. For example, this can be a state, a province, an oblast, or a prefecture. Specifically, for Spain this is the province and not the autonomous community (e.g. \"Barcelona\" and not \"Catalonia\"). Many countries don't use an administrative area in postal addresses. E.g. in Switzerland this should be left unpopulated.", + "type": "string" + }, + "languageCode": { + "description": "Optional. BCP-47 language code of the contents of this address (if known). This is often the UI language of the input form or is expected to match one of the languages used in the address' country/region, or their transliterated equivalents. This can affect formatting in certain countries, but is not critical to the correctness of the data and will never affect any validation or other non-formatting related operations. If this value is not known, it should be omitted (rather than specifying a possibly incorrect default). Examples: \"zh-Hant\", \"ja\", \"ja-Latn\", \"en\".", + "type": "string" + }, + "locality": { + "description": "Optional. Generally refers to the city/town portion of the address. Examples: US city, IT comune, UK post town. In regions of the world where localities are not well defined or do not fit into this structure well, leave locality empty and use address_lines.", + "type": "string" + }, + "organization": { + "description": "Optional. The name of the organization at the address.", + "type": "string" + }, + "postalCode": { + "description": "Optional. Postal code of the address. Not all countries use or require postal codes to be present, but where they are used, they may trigger additional validation with other parts of the address (e.g. state/zip validation in the U.S.A.).", + "type": "string" + }, + "recipients": { + "description": "Optional. The recipient at the address. This field may, under certain circumstances, contain multiline information. For example, it might contain \"care of\" information.", + "items": { + "type": "string" + }, + "type": "array" + }, + "regionCode": { + "description": "Required. CLDR region code of the country/region of the address. This is never inferred and it is up to the user to ensure the value is correct. See https://cldr.unicode.org/ and https://www.unicode.org/cldr/charts/30/supplemental/territory_information.html for details. Example: \"CH\" for Switzerland.", + "type": "string" + }, + "revision": { + "description": "The schema revision of the `PostalAddress`. This must be set to 0, which is the latest revision. All new revisions **must** be backward compatible with old revisions.", + "format": "int32", + "type": "integer" + }, + "sortingCode": { + "description": "Optional. Additional, country-specific, sorting code. This is not used in most regions. Where it is used, the value is either a string like \"CEDEX\", optionally followed by a number (e.g. \"CEDEX 7\"), or just a number alone, representing the \"sector code\" (Jamaica), \"delivery area indicator\" (Malawi) or \"post office indicator\" (e.g. Côte d'Ivoire).", + "type": "string" + }, + "sublocality": { + "description": "Optional. Sublocality of the address. For example, this can be neighborhoods, boroughs, districts.", + "type": "string" + } + }, + "type": "object" + } + }, + "servicePath": "", + "title": "Address Validation API", + "version": "v1", + "version_module": true +} \ No newline at end of file diff --git a/addressvalidation/v1/addressvalidation-gen.go b/addressvalidation/v1/addressvalidation-gen.go new file mode 100644 index 0000000000..e0c21ec8d5 --- /dev/null +++ b/addressvalidation/v1/addressvalidation-gen.go @@ -0,0 +1,1714 @@ +// Copyright 2024 Google LLC. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Code generated file. DO NOT EDIT. + +// Package addressvalidation provides access to the Address Validation API. +// +// For product documentation, see: https://developers.google.com/maps/documentation/addressvalidation +// +// # Library status +// +// These client libraries are officially supported by Google. However, this +// library is considered complete and is in maintenance mode. This means +// that we will address critical bugs and security issues but will not add +// any new features. +// +// When possible, we recommend using our newer +// [Cloud Client Libraries for Go](https://pkg.go.dev/cloud.google.com/go) +// that are still actively being worked and iterated on. +// +// # Creating a client +// +// Usage example: +// +// import "google.golang.org/api/addressvalidation/v1" +// ... +// ctx := context.Background() +// addressvalidationService, err := addressvalidation.NewService(ctx) +// +// In this example, Google Application Default Credentials are used for +// authentication. For information on how to create and obtain Application +// Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials. +// +// # Other authentication options +// +// By default, all available scopes (see "Constants") are used to authenticate. +// To restrict scopes, use [google.golang.org/api/option.WithScopes]: +// +// addressvalidationService, err := addressvalidation.NewService(ctx, option.WithScopes(addressvalidation.MapsPlatformAddressvalidationScope)) +// +// To use an API key for authentication (note: some APIs do not support API +// keys), use [google.golang.org/api/option.WithAPIKey]: +// +// addressvalidationService, err := addressvalidation.NewService(ctx, option.WithAPIKey("AIza...")) +// +// To use an OAuth token (e.g., a user token obtained via a three-legged OAuth +// flow, use [google.golang.org/api/option.WithTokenSource]: +// +// config := &oauth2.Config{...} +// // ... +// token, err := config.Exchange(ctx, ...) +// addressvalidationService, err := addressvalidation.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token))) +// +// See [google.golang.org/api/option.ClientOption] for details on options. +package addressvalidation // import "google.golang.org/api/addressvalidation/v1" + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "net/url" + "strconv" + "strings" + + googleapi "google.golang.org/api/googleapi" + internal "google.golang.org/api/internal" + gensupport "google.golang.org/api/internal/gensupport" + option "google.golang.org/api/option" + internaloption "google.golang.org/api/option/internaloption" + htransport "google.golang.org/api/transport/http" +) + +// Always reference these packages, just in case the auto-generated code +// below doesn't. +var _ = bytes.NewBuffer +var _ = strconv.Itoa +var _ = fmt.Sprintf +var _ = json.NewDecoder +var _ = io.Copy +var _ = url.Parse +var _ = gensupport.MarshalJSON +var _ = googleapi.Version +var _ = errors.New +var _ = strings.Replace +var _ = context.Canceled +var _ = internaloption.WithDefaultEndpoint +var _ = internal.Version + +const apiId = "addressvalidation:v1" +const apiName = "addressvalidation" +const apiVersion = "v1" +const basePath = "https://addressvalidation.googleapis.com/" +const basePathTemplate = "https://addressvalidation.UNIVERSE_DOMAIN/" +const mtlsBasePath = "https://addressvalidation.mtls.googleapis.com/" +const defaultUniverseDomain = "googleapis.com" + +// OAuth2 scopes used by this API. +const ( + // See, edit, configure, and delete your Google Cloud data and see the + // email address for your Google Account. + CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform" + + // Private Service: + // https://www.googleapis.com/auth/maps-platform.addressvalidation + MapsPlatformAddressvalidationScope = "https://www.googleapis.com/auth/maps-platform.addressvalidation" +) + +// NewService creates a new Service. +func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) { + scopesOption := internaloption.WithDefaultScopes( + "https://www.googleapis.com/auth/cloud-platform", + "https://www.googleapis.com/auth/maps-platform.addressvalidation", + ) + // NOTE: prepend, so we don't override user-specified scopes. + opts = append([]option.ClientOption{scopesOption}, opts...) + opts = append(opts, internaloption.WithDefaultEndpoint(basePath)) + opts = append(opts, internaloption.WithDefaultEndpointTemplate(basePathTemplate)) + opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath)) + opts = append(opts, internaloption.WithDefaultUniverseDomain(defaultUniverseDomain)) + client, endpoint, err := htransport.NewClient(ctx, opts...) + if err != nil { + return nil, err + } + s, err := New(client) + if err != nil { + return nil, err + } + if endpoint != "" { + s.BasePath = endpoint + } + return s, nil +} + +// New creates a new Service. It uses the provided http.Client for requests. +// +// Deprecated: please use NewService instead. +// To provide a custom HTTP client, use option.WithHTTPClient. +// If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead. +func New(client *http.Client) (*Service, error) { + if client == nil { + return nil, errors.New("client is nil") + } + s := &Service{client: client, BasePath: basePath} + s.V1 = NewV1Service(s) + return s, nil +} + +type Service struct { + client *http.Client + BasePath string // API endpoint base URL + UserAgent string // optional additional User-Agent fragment + + V1 *V1Service +} + +func (s *Service) userAgent() string { + if s.UserAgent == "" { + return googleapi.UserAgent + } + return googleapi.UserAgent + " " + s.UserAgent +} + +func NewV1Service(s *Service) *V1Service { + rs := &V1Service{s: s} + return rs +} + +type V1Service struct { + s *Service +} + +// GoogleGeoTypeViewport: A latitude-longitude viewport, represented as +// two diagonally opposite `low` and `high` points. A viewport is +// considered a closed region, i.e. it includes its boundary. The +// latitude bounds must range between -90 to 90 degrees inclusive, and +// the longitude bounds must range between -180 to 180 degrees +// inclusive. Various cases include: - If `low` = `high`, the viewport +// consists of that single point. - If `low.longitude` > +// `high.longitude`, the longitude range is inverted (the viewport +// crosses the 180 degree longitude line). - If `low.longitude` = -180 +// degrees and `high.longitude` = 180 degrees, the viewport includes all +// longitudes. - If `low.longitude` = 180 degrees and `high.longitude` = +// -180 degrees, the longitude range is empty. - If `low.latitude` > +// `high.latitude`, the latitude range is empty. Both `low` and `high` +// must be populated, and the represented box cannot be empty (as +// specified by the definitions above). An empty viewport will result in +// an error. For example, this viewport fully encloses New York City: { +// "low": { "latitude": 40.477398, "longitude": -74.259087 }, "high": { +// "latitude": 40.91618, "longitude": -73.70018 } } +type GoogleGeoTypeViewport struct { + // High: Required. The high point of the viewport. + High *GoogleTypeLatLng `json:"high,omitempty"` + + // Low: Required. The low point of the viewport. + Low *GoogleTypeLatLng `json:"low,omitempty"` + + // ForceSendFields is a list of field names (e.g. "High") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "High") to include in API + // requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleGeoTypeViewport) MarshalJSON() ([]byte, error) { + type NoMethod GoogleGeoTypeViewport + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1Address: Details of the post-processed +// address. Post-processing includes correcting misspelled parts of the +// address, replacing incorrect parts, and inferring missing parts. +type GoogleMapsAddressvalidationV1Address struct { + // AddressComponents: Unordered list. The individual address components + // of the formatted and corrected address, along with validation + // information. This provides information on the validation status of + // the individual components. Address components are not ordered in a + // particular way. Do not make any assumptions on the ordering of the + // address components in the list. + AddressComponents []*GoogleMapsAddressvalidationV1AddressComponent `json:"addressComponents,omitempty"` + + // FormattedAddress: The post-processed address, formatted as a + // single-line address following the address formatting rules of the + // region where the address is located. + FormattedAddress string `json:"formattedAddress,omitempty"` + + // MissingComponentTypes: The types of components that were expected to + // be present in a correctly formatted mailing address but were not + // found in the input AND could not be inferred. Components of this type + // are not present in `formatted_address`, `postal_address`, or + // `address_components`. An example might be `['street_number', + // 'route']` for an input like "Boulder, Colorado, 80301, USA". The list + // of possible types can be found here + // (https://developers.google.com/maps/documentation/geocoding/requests-geocoding#Types). + MissingComponentTypes []string `json:"missingComponentTypes,omitempty"` + + // PostalAddress: The post-processed address represented as a postal + // address. + PostalAddress *GoogleTypePostalAddress `json:"postalAddress,omitempty"` + + // UnconfirmedComponentTypes: The types of the components that are + // present in the `address_components` but could not be confirmed to be + // correct. This field is provided for the sake of convenience: its + // contents are equivalent to iterating through the `address_components` + // to find the types of all the components where the confirmation_level + // is not CONFIRMED or the inferred flag is not set to `true`. The list + // of possible types can be found here + // (https://developers.google.com/maps/documentation/geocoding/requests-geocoding#Types). + UnconfirmedComponentTypes []string `json:"unconfirmedComponentTypes,omitempty"` + + // UnresolvedTokens: Any tokens in the input that could not be resolved. + // This might be an input that was not recognized as a valid part of an + // address (for example in an input like "123235253253 Main St, San + // Francisco, CA, 94105", the unresolved tokens may look like + // `["123235253253"]` since that does not look like a valid street + // number. + UnresolvedTokens []string `json:"unresolvedTokens,omitempty"` + + // ForceSendFields is a list of field names (e.g. "AddressComponents") + // to unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "AddressComponents") to + // include in API requests with the JSON null value. By default, fields + // with empty values are omitted from API requests. However, any field + // with an empty value appearing in NullFields will be sent to the + // server as null. It is an error if a field in this list has a + // non-empty value. This may be used to include null fields in Patch + // requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1Address) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1Address + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1AddressComponent: Represents an address +// component, such as a street, city, or state. +type GoogleMapsAddressvalidationV1AddressComponent struct { + // ComponentName: The name for this component. + ComponentName *GoogleMapsAddressvalidationV1ComponentName `json:"componentName,omitempty"` + + // ComponentType: The type of the address component. See Table 2: + // Additional types returned by the Places service + // (https://developers.google.com/places/web-service/supported_types#table2) + // for a list of possible types. + ComponentType string `json:"componentType,omitempty"` + + // ConfirmationLevel: Indicates the level of certainty that we have that + // the component is correct. + // + // Possible values: + // "CONFIRMATION_LEVEL_UNSPECIFIED" - Default value. This value is + // unused. + // "CONFIRMED" - We were able to verify that this component exists and + // makes sense in the context of the rest of the address. + // "UNCONFIRMED_BUT_PLAUSIBLE" - This component could not be + // confirmed, but it is plausible that it exists. For example, a street + // number within a known valid range of numbers on a street where + // specific house numbers are not known. + // "UNCONFIRMED_AND_SUSPICIOUS" - This component was not confirmed and + // is likely to be wrong. For example, a neighborhood that does not fit + // the rest of the address. + ConfirmationLevel string `json:"confirmationLevel,omitempty"` + + // Inferred: Indicates that the component was not part of the input, but + // we inferred it for the address location and believe it should be + // provided for a complete address. + Inferred bool `json:"inferred,omitempty"` + + // Replaced: Indicates the name of the component was replaced with a + // completely different one, for example a wrong postal code being + // replaced with one that is correct for the address. This is not a + // cosmetic change, the input component has been changed to a different + // one. + Replaced bool `json:"replaced,omitempty"` + + // SpellCorrected: Indicates a correction to a misspelling in the + // component name. The API does not always flag changes from one + // spelling variant to another, such as when changing "centre" to + // "center". It also does not always flag common misspellings, such as + // when changing "Amphitheater Pkwy" to "Amphitheatre Pkwy". + SpellCorrected bool `json:"spellCorrected,omitempty"` + + // Unexpected: Indicates an address component that is not expected to be + // present in a postal address for the given region. We have retained it + // only because it was part of the input. + Unexpected bool `json:"unexpected,omitempty"` + + // ForceSendFields is a list of field names (e.g. "ComponentName") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "ComponentName") to include + // in API requests with the JSON null value. By default, fields with + // empty values are omitted from API requests. However, any field with + // an empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1AddressComponent) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1AddressComponent + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1AddressMetadata: The metadata for the +// address. `metadata` is not guaranteed to be fully populated for every +// address sent to the Address Validation API. +type GoogleMapsAddressvalidationV1AddressMetadata struct { + // Business: Indicates that this is the address of a business. If unset, + // indicates that the value is unknown. + Business bool `json:"business,omitempty"` + + // PoBox: Indicates that the address of a PO box. If unset, indicates + // that the value is unknown. + PoBox bool `json:"poBox,omitempty"` + + // Residential: Indicates that this is the address of a residence. If + // unset, indicates that the value is unknown. + Residential bool `json:"residential,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Business") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "Business") to include in + // API requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1AddressMetadata) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1AddressMetadata + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1ComponentName: A wrapper for the name of +// the component. +type GoogleMapsAddressvalidationV1ComponentName struct { + // LanguageCode: The BCP-47 language code. This will not be present if + // the component name is not associated with a language, such as a + // street number. + LanguageCode string `json:"languageCode,omitempty"` + + // Text: The name text. For example, "5th Avenue" for a street name or + // "1253" for a street number. + Text string `json:"text,omitempty"` + + // ForceSendFields is a list of field names (e.g. "LanguageCode") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "LanguageCode") to include + // in API requests with the JSON null value. By default, fields with + // empty values are omitted from API requests. However, any field with + // an empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1ComponentName) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1ComponentName + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1Geocode: Contains information about the +// place the input was geocoded to. +type GoogleMapsAddressvalidationV1Geocode struct { + // Bounds: The bounds of the geocoded place. + Bounds *GoogleGeoTypeViewport `json:"bounds,omitempty"` + + // FeatureSizeMeters: The size of the geocoded place, in meters. This is + // another measure of the coarseness of the geocoded location, but in + // physical size rather than in semantic meaning. + FeatureSizeMeters float64 `json:"featureSizeMeters,omitempty"` + + // Location: The geocoded location of the input. Using place IDs is + // preferred over using addresses, latitude/longitude coordinates, or + // plus codes. Using coordinates when routing or calculating driving + // directions will always result in the point being snapped to the road + // nearest to those coordinates. This may not be a road that will + // quickly or safely lead to the destination and may not be near an + // access point to the property. Additionally, when a location is + // reverse geocoded, there is no guarantee that the returned address + // will match the original. + Location *GoogleTypeLatLng `json:"location,omitempty"` + + // PlaceId: The PlaceID of the place this input geocodes to. For more + // information about Place IDs see here + // (https://developers.google.com/maps/documentation/places/web-service/place-id). + PlaceId string `json:"placeId,omitempty"` + + // PlaceTypes: The type(s) of place that the input geocoded to. For + // example, `['locality', 'political']`. The full list of types can be + // found here + // (https://developers.google.com/maps/documentation/geocoding/requests-geocoding#Types). + PlaceTypes []string `json:"placeTypes,omitempty"` + + // PlusCode: The plus code corresponding to the `location`. + PlusCode *GoogleMapsAddressvalidationV1PlusCode `json:"plusCode,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Bounds") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "Bounds") to include in API + // requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1Geocode) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1Geocode + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +func (s *GoogleMapsAddressvalidationV1Geocode) UnmarshalJSON(data []byte) error { + type NoMethod GoogleMapsAddressvalidationV1Geocode + var s1 struct { + FeatureSizeMeters gensupport.JSONFloat64 `json:"featureSizeMeters"` + *NoMethod + } + s1.NoMethod = (*NoMethod)(s) + if err := json.Unmarshal(data, &s1); err != nil { + return err + } + s.FeatureSizeMeters = float64(s1.FeatureSizeMeters) + return nil +} + +// GoogleMapsAddressvalidationV1LanguageOptions: Preview: This feature +// is in Preview (pre-GA). Pre-GA products and features might have +// limited support, and changes to pre-GA products and features might +// not be compatible with other pre-GA versions. Pre-GA Offerings are +// covered by the Google Maps Platform Service Specific Terms +// (https://cloud.google.com/maps-platform/terms/maps-service-terms). +// For more information, see the launch stage descriptions +// (https://developers.google.com/maps/launch-stages). Enables the +// Address Validation API to include additional information in the +// response. +type GoogleMapsAddressvalidationV1LanguageOptions struct { + // ReturnEnglishLatinAddress: Preview: Return a + // [google.maps.addressvalidation.v1.Address] in English. See + // [google.maps.addressvalidation.v1.ValidationResult.english_latin_addre + // ss] for details. + ReturnEnglishLatinAddress bool `json:"returnEnglishLatinAddress,omitempty"` + + // ForceSendFields is a list of field names (e.g. + // "ReturnEnglishLatinAddress") to unconditionally include in API + // requests. By default, fields with empty or default values are omitted + // from API requests. However, any non-pointer, non-interface field + // appearing in ForceSendFields will be sent to the server regardless of + // whether the field is empty or not. This may be used to include empty + // fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. + // "ReturnEnglishLatinAddress") to include in API requests with the JSON + // null value. By default, fields with empty values are omitted from API + // requests. However, any field with an empty value appearing in + // NullFields will be sent to the server as null. It is an error if a + // field in this list has a non-empty value. This may be used to include + // null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1LanguageOptions) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1LanguageOptions + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1PlusCode: Plus code (http://plus.codes) +// is a location reference with two formats: global code defining a +// 14mx14m (1/8000th of a degree) or smaller rectangle, and compound +// code, replacing the prefix with a reference location. +type GoogleMapsAddressvalidationV1PlusCode struct { + // CompoundCode: Place's compound code, such as "33GV+HQ, Ramberg, + // Norway", containing the suffix of the global code and replacing the + // prefix with a formatted name of a reference entity. + CompoundCode string `json:"compoundCode,omitempty"` + + // GlobalCode: Place's global (full) code, such as "9FWM33GV+HQ", + // representing an 1/8000 by 1/8000 degree area (~14 by 14 meters). + GlobalCode string `json:"globalCode,omitempty"` + + // ForceSendFields is a list of field names (e.g. "CompoundCode") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "CompoundCode") to include + // in API requests with the JSON null value. By default, fields with + // empty values are omitted from API requests. However, any field with + // an empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1PlusCode) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1PlusCode + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest: The +// request for sending validation feedback. +type GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest struct { + // Conclusion: Required. The outcome of the sequence of validation + // attempts. If this field is set to + // `VALIDATION_CONCLUSION_UNSPECIFIED`, an `INVALID_ARGUMENT` error will + // be returned. + // + // Possible values: + // "VALIDATION_CONCLUSION_UNSPECIFIED" - This value is unused. If the + // `ProvideValidationFeedbackRequest.conclusion` field is set to + // `VALIDATION_CONCLUSION_UNSPECIFIED`, an `INVALID_ARGUMENT` error will + // be returned. + // "VALIDATED_VERSION_USED" - The version of the address returned by + // the Address Validation API was used for the transaction. + // "USER_VERSION_USED" - The version of the address provided by the + // user was used for the transaction + // "UNVALIDATED_VERSION_USED" - A version of the address that was + // entered after the last validation attempt but that was not + // re-validated was used for the transaction. + // "UNUSED" - The transaction was abandoned and the address was not + // used. + Conclusion string `json:"conclusion,omitempty"` + + // ResponseId: Required. The ID of the response that this feedback is + // for. This should be the response_id from the first response in a + // series of address validation attempts. + ResponseId string `json:"responseId,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Conclusion") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "Conclusion") to include in + // API requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1ProvideValidationFeedbackResponse: The +// response for validation feedback. The response is empty if the +// feedback is sent successfully. +type GoogleMapsAddressvalidationV1ProvideValidationFeedbackResponse struct { + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` +} + +// GoogleMapsAddressvalidationV1UspsAddress: USPS representation of a US +// address. +type GoogleMapsAddressvalidationV1UspsAddress struct { + // City: City name. + City string `json:"city,omitempty"` + + // CityStateZipAddressLine: City + state + postal code. + CityStateZipAddressLine string `json:"cityStateZipAddressLine,omitempty"` + + // Firm: Firm name. + Firm string `json:"firm,omitempty"` + + // FirstAddressLine: First address line. + FirstAddressLine string `json:"firstAddressLine,omitempty"` + + // SecondAddressLine: Second address line. + SecondAddressLine string `json:"secondAddressLine,omitempty"` + + // State: 2 letter state code. + State string `json:"state,omitempty"` + + // Urbanization: Puerto Rican urbanization name. + Urbanization string `json:"urbanization,omitempty"` + + // ZipCode: Postal code e.g. 10009. + ZipCode string `json:"zipCode,omitempty"` + + // ZipCodeExtension: 4-digit postal code extension e.g. 5023. + ZipCodeExtension string `json:"zipCodeExtension,omitempty"` + + // ForceSendFields is a list of field names (e.g. "City") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "City") to include in API + // requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1UspsAddress) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1UspsAddress + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1UspsData: The USPS data for the address. +// `uspsData` is not guaranteed to be fully populated for every US or PR +// address sent to the Address Validation API. It's recommended to +// integrate the backup address fields in the response if you utilize +// uspsData as the primary part of the response. +type GoogleMapsAddressvalidationV1UspsData struct { + // AbbreviatedCity: Abbreviated city. + AbbreviatedCity string `json:"abbreviatedCity,omitempty"` + + // AddressRecordType: Type of the address record that matches the input + // address. * `F`: FIRM. This is a match to a Firm Record, which is the + // finest level of match available for an address. * `G`: GENERAL + // DELIVERY. This is a match to a General Delivery record. * `H`: + // BUILDING / APARTMENT. This is a match to a Building or Apartment + // record. * `P`: POST OFFICE BOX. This is a match to a Post Office Box. + // * `R`: RURAL ROUTE or HIGHWAY CONTRACT: This is a match to either a + // Rural Route or a Highway Contract record, both of which may have + // associated Box Number ranges. * `S`: STREET RECORD: This is a match + // to a Street record containing a valid primary number range. + AddressRecordType string `json:"addressRecordType,omitempty"` + + // CarrierRoute: The carrier route code. A four character code + // consisting of a one letter prefix and a three digit route designator. + // Prefixes: * `C`: Carrier route (or city route) * `R`: Rural route * + // `H`: Highway Contract Route * `B`: Post Office Box Section * `G`: + // General delivery unit + CarrierRoute string `json:"carrierRoute,omitempty"` + + // CarrierRouteIndicator: Carrier route rate sort indicator. + CarrierRouteIndicator string `json:"carrierRouteIndicator,omitempty"` + + // CassProcessed: Indicator that the request has been CASS processed. + CassProcessed bool `json:"cassProcessed,omitempty"` + + // County: County name. + County string `json:"county,omitempty"` + + // DefaultAddress: Indicator that a default address was found, but more + // specific addresses exists. + DefaultAddress bool `json:"defaultAddress,omitempty"` + + // DeliveryPointCheckDigit: The delivery point check digit. This number + // is added to the end of the delivery_point_barcode for mechanically + // scanned mail. Adding all the digits of the delivery_point_barcode, + // delivery_point_check_digit, postal code, and ZIP+4 together should + // yield a number divisible by 10. + DeliveryPointCheckDigit string `json:"deliveryPointCheckDigit,omitempty"` + + // DeliveryPointCode: 2 digit delivery point code + DeliveryPointCode string `json:"deliveryPointCode,omitempty"` + + // DpvCmra: Indicates if the address is a CMRA (Commercial Mail + // Receiving Agency)--a private business receiving mail for clients. + // Returns a single character. * `Y`: The address is a CMRA * `N`: The + // address is not a CMRA + DpvCmra string `json:"dpvCmra,omitempty"` + + // DpvConfirmation: The possible values for DPV confirmation. Returns a + // single character or returns no value. * `N`: Primary and any + // secondary number information failed to DPV confirm. * `D`: Address + // was DPV confirmed for the primary number only, and the secondary + // number information was missing. * `S`: Address was DPV confirmed for + // the primary number only, and the secondary number information was + // present but not confirmed. * `Y`: Address was DPV confirmed for + // primary and any secondary numbers. * Empty: If the response does not + // contain a `dpv_confirmation` value, the address was not submitted for + // DPV confirmation. + DpvConfirmation string `json:"dpvConfirmation,omitempty"` + + // DpvDoorNotAccessible: Flag indicates addresses where USPS cannot + // knock on a door to deliver mail. Returns a single character. * `Y`: + // The door is not accessible. * `N`: No indication the door is not + // accessible. + DpvDoorNotAccessible string `json:"dpvDoorNotAccessible,omitempty"` + + // DpvDrop: Flag indicates mail is delivered to a single receptable at a + // site. Returns a single character. * `Y`: The mail is delivered to a + // single receptable at a site. * `N`: The mail is not delivered to a + // single receptable at a site. + DpvDrop string `json:"dpvDrop,omitempty"` + + // DpvEnhancedDeliveryCode: Indicates that more than one DPV return code + // is valid for the address. Returns a single character. * `Y`: Address + // was DPV confirmed for primary and any secondary numbers. * `N`: + // Primary and any secondary number information failed to DPV confirm. * + // `S`: Address was DPV confirmed for the primary number only, and the + // secondary number information was present by not confirmed, or a + // single trailing alpha on a primary number was dropped to make a DPV + // match and secondary information required. * `D`: Address was DPV + // confirmed for the primary number only, and the secondary number + // information was missing. * `R`: Address confirmed but assigned to + // phantom route R777 and R779 and USPS delivery is not provided. + DpvEnhancedDeliveryCode string `json:"dpvEnhancedDeliveryCode,omitempty"` + + // DpvFootnote: The footnotes from delivery point validation. Multiple + // footnotes may be strung together in the same string. * `AA`: Input + // address matched to the ZIP+4 file * `A1`: Input address was not + // matched to the ZIP+4 file * `BB`: Matched to DPV (all components) * + // `CC`: Secondary number not matched and not required * `C1`: Secondary + // number not matched but required * `N1`: High-rise address missing + // secondary number * `M1`: Primary number missing * `M3`: Primary + // number invalid * `P1`: Input address PO, RR or HC box number missing + // * `P3`: Input address PO, RR, or HC Box number invalid * `F1`: Input + // address matched to a military address * `G1`: Input address matched + // to a general delivery address * `U1`: Input address matched to a + // unique ZIP code * `PB`: Input address matched to PBSA record * `RR`: + // DPV confirmed address with PMB information * `R1`: DPV confirmed + // address without PMB information * `R7`: Carrier Route R777 or R779 + // record * `IA`: Informed Address identified * `TA`: Primary number + // matched by dropping a trailing alpha + DpvFootnote string `json:"dpvFootnote,omitempty"` + + // DpvNoSecureLocation: Flag indicates door is accessible, but package + // will not be left due to security concerns. Returns a single + // character. * `Y`: The package will not be left due to security + // concerns. * `N`: No indication the package will not be left due to + // security concerns. + DpvNoSecureLocation string `json:"dpvNoSecureLocation,omitempty"` + + // DpvNoStat: Is this a no stat address or an active address? No stat + // addresses are ones which are not continuously occupied or addresses + // that the USPS does not service. Returns a single character. * `Y`: + // The address is not active * `N`: The address is active + DpvNoStat string `json:"dpvNoStat,omitempty"` + + // DpvNoStatReasonCode: Indicates the NoStat type. Returns a reason code + // as int. * `1`: IDA (Internal Drop Address) – Addresses that do not + // receive mail directly from the USPS but are delivered to a drop + // address that services them. * `2`: CDS - Addresses that have not yet + // become deliverable. For example, a new subdivision where lots and + // primary numbers have been determined, but no structure exists yet for + // occupancy. * `3`: Collision - Addresses that do not actually DPV + // confirm. * `4`: CMZ (College, Military and Other Types) - ZIP + 4 + // records USPS has incorporated into the data. * `5`: Regular - + // Indicates addresses not receiving delivery and the addresses are not + // counted as possible deliveries. * `6`: Secondary Required - The + // address requires secondary information. + DpvNoStatReasonCode int64 `json:"dpvNoStatReasonCode,omitempty"` + + // DpvNonDeliveryDays: Flag indicates mail delivery is not performed + // every day of the week. Returns a single character. * `Y`: The mail + // delivery is not performed every day of the week. * `N`: No indication + // the mail delivery is not performed every day of the week. + DpvNonDeliveryDays string `json:"dpvNonDeliveryDays,omitempty"` + + // DpvNonDeliveryDaysValues: Integer identifying non-delivery days. It + // can be interrogated using bit flags: 0x40 – Sunday is a + // non-delivery day 0x20 – Monday is a non-delivery day 0x10 – + // Tuesday is a non-delivery day 0x08 – Wednesday is a non-delivery + // day 0x04 – Thursday is a non-delivery day 0x02 – Friday is a + // non-delivery day 0x01 – Saturday is a non-delivery day + DpvNonDeliveryDaysValues int64 `json:"dpvNonDeliveryDaysValues,omitempty"` + + // DpvPbsa: Indicates the address was matched to PBSA record. Returns a + // single character. * `Y`: The address was matched to PBSA record. * + // `N`: The address was not matched to PBSA record. + DpvPbsa string `json:"dpvPbsa,omitempty"` + + // DpvThrowback: Indicates that mail is not delivered to the street + // address. Returns a single character. * `Y`: The mail is not delivered + // to the street address. * `N`: The mail is delivered to the street + // address. + DpvThrowback string `json:"dpvThrowback,omitempty"` + + // DpvVacant: Is this place vacant? Returns a single character. * `Y`: + // The address is vacant * `N`: The address is not vacant + DpvVacant string `json:"dpvVacant,omitempty"` + + // ElotFlag: eLOT Ascending/Descending Flag (A/D). + ElotFlag string `json:"elotFlag,omitempty"` + + // ElotNumber: Enhanced Line of Travel (eLOT) number. + ElotNumber string `json:"elotNumber,omitempty"` + + // ErrorMessage: Error message for USPS data retrieval. This is + // populated when USPS processing is suspended because of the detection + // of artificially created addresses. The USPS data fields might not be + // populated when this error is present. + ErrorMessage string `json:"errorMessage,omitempty"` + + // EwsNoMatch: The delivery address is matchable, but the EWS file + // indicates that an exact match will be available soon. + EwsNoMatch bool `json:"ewsNoMatch,omitempty"` + + // FipsCountyCode: FIPS county code. + FipsCountyCode string `json:"fipsCountyCode,omitempty"` + + // LacsLinkIndicator: LACSLink indicator. + LacsLinkIndicator string `json:"lacsLinkIndicator,omitempty"` + + // LacsLinkReturnCode: LACSLink return code. + LacsLinkReturnCode string `json:"lacsLinkReturnCode,omitempty"` + + // PmbDesignator: PMB (Private Mail Box) unit designator. + PmbDesignator string `json:"pmbDesignator,omitempty"` + + // PmbNumber: PMB (Private Mail Box) number; + PmbNumber string `json:"pmbNumber,omitempty"` + + // PoBoxOnlyPostalCode: PO Box only postal code. + PoBoxOnlyPostalCode bool `json:"poBoxOnlyPostalCode,omitempty"` + + // PostOfficeCity: Main post office city. + PostOfficeCity string `json:"postOfficeCity,omitempty"` + + // PostOfficeState: Main post office state. + PostOfficeState string `json:"postOfficeState,omitempty"` + + // StandardizedAddress: USPS standardized address. + StandardizedAddress *GoogleMapsAddressvalidationV1UspsAddress `json:"standardizedAddress,omitempty"` + + // SuitelinkFootnote: Footnotes from matching a street or highrise + // record to suite information. If business name match is found, the + // secondary number is returned. * `A`: SuiteLink record match, business + // address improved. * `00`: No match, business address is not improved. + SuitelinkFootnote string `json:"suitelinkFootnote,omitempty"` + + // ForceSendFields is a list of field names (e.g. "AbbreviatedCity") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "AbbreviatedCity") to + // include in API requests with the JSON null value. By default, fields + // with empty values are omitted from API requests. However, any field + // with an empty value appearing in NullFields will be sent to the + // server as null. It is an error if a field in this list has a + // non-empty value. This may be used to include null fields in Patch + // requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1UspsData) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1UspsData + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1ValidateAddressRequest: The request for +// validating an address. +type GoogleMapsAddressvalidationV1ValidateAddressRequest struct { + // Address: Required. The address being validated. Unformatted addresses + // should be submitted via `address_lines`. The total length of the + // fields in this input must not exceed 280 characters. Supported + // regions can be found here + // (https://developers.google.com/maps/documentation/address-validation/coverage). + // The language_code value in the input address is reserved for future + // uses and is ignored today. The validated address result will be + // populated based on the preferred language for the given address, as + // identified by the system. The Address Validation API ignores the + // values in recipients and organization. Any values in those fields + // will be discarded and not returned. Please do not set them. + Address *GoogleTypePostalAddress `json:"address,omitempty"` + + // EnableUspsCass: Enables USPS CASS compatible mode. This affects + // _only_ the + // [google.maps.addressvalidation.v1.ValidationResult.usps_data] field + // of [google.maps.addressvalidation.v1.ValidationResult]. Note: for + // USPS CASS enabled requests for addresses in Puerto Rico, a + // [google.type.PostalAddress.region_code] of the `address` must be + // provided as "PR", or an + // [google.type.PostalAddress.administrative_area] of the `address` must + // be provided as "Puerto Rico" (case-insensitive) or "PR". It's + // recommended to use a componentized `address`, or alternatively + // specify at least two [google.type.PostalAddress.address_lines] where + // the first line contains the street number and name and the second + // line contains the city, state, and zip code. + EnableUspsCass bool `json:"enableUspsCass,omitempty"` + + // LanguageOptions: Optional. Preview: This feature is in Preview + // (pre-GA). Pre-GA products and features might have limited support, + // and changes to pre-GA products and features might not be compatible + // with other pre-GA versions. Pre-GA Offerings are covered by the + // Google Maps Platform Service Specific Terms + // (https://cloud.google.com/maps-platform/terms/maps-service-terms). + // For more information, see the launch stage descriptions + // (https://developers.google.com/maps/launch-stages). Enables the + // Address Validation API to include additional information in the + // response. + LanguageOptions *GoogleMapsAddressvalidationV1LanguageOptions `json:"languageOptions,omitempty"` + + // PreviousResponseId: This field must be empty for the first address + // validation request. If more requests are necessary to fully validate + // a single address (for example if the changes the user makes after the + // initial validation need to be re-validated), then each followup + // request must populate this field with the response_id from the very + // first response in the validation sequence. + PreviousResponseId string `json:"previousResponseId,omitempty"` + + // SessionToken: Optional. A string which identifies an Autocomplete + // session for billing purposes. Must be a URL and filename safe base64 + // string with at most 36 ASCII characters in length. Otherwise an + // INVALID_ARGUMENT error is returned. The session begins when the user + // makes an Autocomplete query, and concludes when they select a place + // and a call to Place Details or Address Validation is made. Each + // session can have multiple Autocomplete queries, followed by one Place + // Details or Address Validation request. The credentials used for each + // request within a session must belong to the same Google Cloud Console + // project. Once a session has concluded, the token is no longer valid; + // your app must generate a fresh token for each session. If the + // `sessionToken` parameter is omitted, or if you reuse a session token, + // the session is charged as if no session token was provided (each + // request is billed separately). Note: Address Validation can only be + // used in sessions with the Autocomplete (New) API, not the + // Autocomplete API. See + // https://developers.google.com/maps/documentation/places/web-service/session-pricing + // for more details. + SessionToken string `json:"sessionToken,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Address") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "Address") to include in + // API requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1ValidateAddressRequest) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1ValidateAddressRequest + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1ValidateAddressResponse: The response to +// an address validation request. +type GoogleMapsAddressvalidationV1ValidateAddressResponse struct { + // ResponseId: The UUID that identifies this response. If the address + // needs to be re-validated, this UUID *must* accompany the new request. + ResponseId string `json:"responseId,omitempty"` + + // Result: The result of the address validation. + Result *GoogleMapsAddressvalidationV1ValidationResult `json:"result,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "ResponseId") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "ResponseId") to include in + // API requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1ValidateAddressResponse) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1ValidateAddressResponse + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1ValidationResult: The result of +// validating an address. +type GoogleMapsAddressvalidationV1ValidationResult struct { + // Address: Information about the address itself as opposed to the + // geocode. + Address *GoogleMapsAddressvalidationV1Address `json:"address,omitempty"` + + // EnglishLatinAddress: Preview: This feature is in Preview (pre-GA). + // Pre-GA products and features might have limited support, and changes + // to pre-GA products and features might not be compatible with other + // pre-GA versions. Pre-GA Offerings are covered by the Google Maps + // Platform Service Specific Terms + // (https://cloud.google.com/maps-platform/terms/maps-service-terms). + // For more information, see the launch stage descriptions + // (https://developers.google.com/maps/launch-stages). The address + // translated to English. Translated addresses are not reusable as API + // input. The service provides them so that the user can use their + // native language to confirm or deny the validation of the + // originally-provided address. If part of the address doesn't have an + // English translation, the service returns that part in an alternate + // language that uses a Latin script. See here + // (https://developers.google.com/maps/documentation/address-validation/convert-addresses-english) + // for an explanation of how the alternate language is selected. If part + // of the address doesn't have any translations or transliterations in a + // language that uses a Latin script, the service returns that part in + // the local language associated with the address. Enable this output by + // using the + // [google.maps.addressvalidation.v1.LanguageOptions.return_english_latin + // _address] flag. Note: the + // [google.maps.addressvalidation.v1.Address.unconfirmed_component_types] + // field in the `english_latin_address` and the + // [google.maps.addressvalidation.v1.AddressComponent.confirmation_level] + // fields in `english_latin_address.address_components` are not + // populated. + EnglishLatinAddress *GoogleMapsAddressvalidationV1Address `json:"englishLatinAddress,omitempty"` + + // Geocode: Information about the location and place that the address + // geocoded to. + Geocode *GoogleMapsAddressvalidationV1Geocode `json:"geocode,omitempty"` + + // Metadata: Other information relevant to deliverability. `metadata` is + // not guaranteed to be fully populated for every address sent to the + // Address Validation API. + Metadata *GoogleMapsAddressvalidationV1AddressMetadata `json:"metadata,omitempty"` + + // UspsData: Extra deliverability flags provided by USPS. Only provided + // in region `US` and `PR`. + UspsData *GoogleMapsAddressvalidationV1UspsData `json:"uspsData,omitempty"` + + // Verdict: Overall verdict flags + Verdict *GoogleMapsAddressvalidationV1Verdict `json:"verdict,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Address") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "Address") to include in + // API requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1ValidationResult) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1ValidationResult + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleMapsAddressvalidationV1Verdict: High level overview of the +// address validation result and geocode. +type GoogleMapsAddressvalidationV1Verdict struct { + // AddressComplete: The address is considered complete if there are no + // unresolved tokens, no unexpected or missing address components. If + // unset, indicates that the value is `false`. See + // `missing_component_types`, `unresolved_tokens` or `unexpected` fields + // for more details. + AddressComplete bool `json:"addressComplete,omitempty"` + + // GeocodeGranularity: Information about the granularity of the + // `geocode`. This can be understood as the semantic meaning of how + // coarse or fine the geocoded location is. This can differ from the + // `validation_granularity` above occasionally. For example, our + // database might record the existence of an apartment number but do not + // have a precise location for the apartment within a big apartment + // complex. In that case, the `validation_granularity` will be + // `SUB_PREMISE` but the `geocode_granularity` will be `PREMISE`. + // + // Possible values: + // "GRANULARITY_UNSPECIFIED" - Default value. This value is unused. + // "SUB_PREMISE" - Below-building level result, such as an apartment. + // "PREMISE" - Building-level result. + // "PREMISE_PROXIMITY" - A geocode that approximates the + // building-level location of the address. + // "BLOCK" - The address or geocode indicates a block. Only used in + // regions which have block-level addressing, such as Japan. + // "ROUTE" - The geocode or address is granular to route, such as a + // street, road, or highway. + // "OTHER" - All other granularities, which are bucketed together + // since they are not deliverable. + GeocodeGranularity string `json:"geocodeGranularity,omitempty"` + + // HasInferredComponents: At least one address component was inferred + // (added) that wasn't in the input, see + // [google.maps.addressvalidation.v1.Address.address_components] for + // details. + HasInferredComponents bool `json:"hasInferredComponents,omitempty"` + + // HasReplacedComponents: At least one address component was replaced, + // see [google.maps.addressvalidation.v1.Address.address_components] for + // details. + HasReplacedComponents bool `json:"hasReplacedComponents,omitempty"` + + // HasUnconfirmedComponents: At least one address component cannot be + // categorized or validated, see + // [google.maps.addressvalidation.v1.Address.address_components] for + // details. + HasUnconfirmedComponents bool `json:"hasUnconfirmedComponents,omitempty"` + + // InputGranularity: The granularity of the **input** address. This is + // the result of parsing the input address and does not give any + // validation signals. For validation signals, refer to + // `validation_granularity` below. For example, if the input address + // includes a specific apartment number, then the `input_granularity` + // here will be `SUB_PREMISE`. If we cannot match the apartment number + // in the databases or the apartment number is invalid, the + // `validation_granularity` will likely be `PREMISE` or below. + // + // Possible values: + // "GRANULARITY_UNSPECIFIED" - Default value. This value is unused. + // "SUB_PREMISE" - Below-building level result, such as an apartment. + // "PREMISE" - Building-level result. + // "PREMISE_PROXIMITY" - A geocode that approximates the + // building-level location of the address. + // "BLOCK" - The address or geocode indicates a block. Only used in + // regions which have block-level addressing, such as Japan. + // "ROUTE" - The geocode or address is granular to route, such as a + // street, road, or highway. + // "OTHER" - All other granularities, which are bucketed together + // since they are not deliverable. + InputGranularity string `json:"inputGranularity,omitempty"` + + // ValidationGranularity: The granularity level that the API can fully + // **validate** the address to. For example, an `validation_granularity` + // of `PREMISE` indicates all address components at the level of + // `PREMISE` or more coarse can be validated. Per address component + // validation result can be found in + // [google.maps.addressvalidation.v1.Address.address_components]. + // + // Possible values: + // "GRANULARITY_UNSPECIFIED" - Default value. This value is unused. + // "SUB_PREMISE" - Below-building level result, such as an apartment. + // "PREMISE" - Building-level result. + // "PREMISE_PROXIMITY" - A geocode that approximates the + // building-level location of the address. + // "BLOCK" - The address or geocode indicates a block. Only used in + // regions which have block-level addressing, such as Japan. + // "ROUTE" - The geocode or address is granular to route, such as a + // street, road, or highway. + // "OTHER" - All other granularities, which are bucketed together + // since they are not deliverable. + ValidationGranularity string `json:"validationGranularity,omitempty"` + + // ForceSendFields is a list of field names (e.g. "AddressComplete") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "AddressComplete") to + // include in API requests with the JSON null value. By default, fields + // with empty values are omitted from API requests. However, any field + // with an empty value appearing in NullFields will be sent to the + // server as null. It is an error if a field in this list has a + // non-empty value. This may be used to include null fields in Patch + // requests. + NullFields []string `json:"-"` +} + +func (s *GoogleMapsAddressvalidationV1Verdict) MarshalJSON() ([]byte, error) { + type NoMethod GoogleMapsAddressvalidationV1Verdict + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// GoogleTypeLatLng: An object that represents a latitude/longitude +// pair. This is expressed as a pair of doubles to represent degrees +// latitude and degrees longitude. Unless specified otherwise, this +// object must conform to the WGS84 standard. Values must be within +// normalized ranges. +type GoogleTypeLatLng struct { + // Latitude: The latitude in degrees. It must be in the range [-90.0, + // +90.0]. + Latitude float64 `json:"latitude,omitempty"` + + // Longitude: The longitude in degrees. It must be in the range [-180.0, + // +180.0]. + Longitude float64 `json:"longitude,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Latitude") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "Latitude") to include in + // API requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleTypeLatLng) MarshalJSON() ([]byte, error) { + type NoMethod GoogleTypeLatLng + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +func (s *GoogleTypeLatLng) UnmarshalJSON(data []byte) error { + type NoMethod GoogleTypeLatLng + var s1 struct { + Latitude gensupport.JSONFloat64 `json:"latitude"` + Longitude gensupport.JSONFloat64 `json:"longitude"` + *NoMethod + } + s1.NoMethod = (*NoMethod)(s) + if err := json.Unmarshal(data, &s1); err != nil { + return err + } + s.Latitude = float64(s1.Latitude) + s.Longitude = float64(s1.Longitude) + return nil +} + +// GoogleTypePostalAddress: Represents a postal address, e.g. for postal +// delivery or payments addresses. Given a postal address, a postal +// service can deliver items to a premise, P.O. Box or similar. It is +// not intended to model geographical locations (roads, towns, +// mountains). In typical usage an address would be created via user +// input or from importing existing data, depending on the type of +// process. Advice on address input / editing: - Use an +// internationalization-ready address widget such as +// https://github.com/google/libaddressinput) - Users should not be +// presented with UI elements for input or editing of fields outside +// countries where that field is used. For more guidance on how to use +// this schema, please see: +// https://support.google.com/business/answer/6397478 +type GoogleTypePostalAddress struct { + // AddressLines: Unstructured address lines describing the lower levels + // of an address. Because values in address_lines do not have type + // information and may sometimes contain multiple values in a single + // field (e.g. "Austin, TX"), it is important that the line order is + // clear. The order of address lines should be "envelope order" for the + // country/region of the address. In places where this can vary (e.g. + // Japan), address_language is used to make it explicit (e.g. "ja" for + // large-to-small ordering and "ja-Latn" or "en" for small-to-large). + // This way, the most specific line of an address can be selected based + // on the language. The minimum permitted structural representation of + // an address consists of a region_code with all remaining information + // placed in the address_lines. It would be possible to format such an + // address very approximately without geocoding, but no semantic + // reasoning could be made about any of the address components until it + // was at least partially resolved. Creating an address only containing + // a region_code and address_lines, and then geocoding is the + // recommended way to handle completely unstructured addresses (as + // opposed to guessing which parts of the address should be localities + // or administrative areas). + AddressLines []string `json:"addressLines,omitempty"` + + // AdministrativeArea: Optional. Highest administrative subdivision + // which is used for postal addresses of a country or region. For + // example, this can be a state, a province, an oblast, or a prefecture. + // Specifically, for Spain this is the province and not the autonomous + // community (e.g. "Barcelona" and not "Catalonia"). Many countries + // don't use an administrative area in postal addresses. E.g. in + // Switzerland this should be left unpopulated. + AdministrativeArea string `json:"administrativeArea,omitempty"` + + // LanguageCode: Optional. BCP-47 language code of the contents of this + // address (if known). This is often the UI language of the input form + // or is expected to match one of the languages used in the address' + // country/region, or their transliterated equivalents. This can affect + // formatting in certain countries, but is not critical to the + // correctness of the data and will never affect any validation or other + // non-formatting related operations. If this value is not known, it + // should be omitted (rather than specifying a possibly incorrect + // default). Examples: "zh-Hant", "ja", "ja-Latn", "en". + LanguageCode string `json:"languageCode,omitempty"` + + // Locality: Optional. Generally refers to the city/town portion of the + // address. Examples: US city, IT comune, UK post town. In regions of + // the world where localities are not well defined or do not fit into + // this structure well, leave locality empty and use address_lines. + Locality string `json:"locality,omitempty"` + + // Organization: Optional. The name of the organization at the address. + Organization string `json:"organization,omitempty"` + + // PostalCode: Optional. Postal code of the address. Not all countries + // use or require postal codes to be present, but where they are used, + // they may trigger additional validation with other parts of the + // address (e.g. state/zip validation in the U.S.A.). + PostalCode string `json:"postalCode,omitempty"` + + // Recipients: Optional. The recipient at the address. This field may, + // under certain circumstances, contain multiline information. For + // example, it might contain "care of" information. + Recipients []string `json:"recipients,omitempty"` + + // RegionCode: Required. CLDR region code of the country/region of the + // address. This is never inferred and it is up to the user to ensure + // the value is correct. See https://cldr.unicode.org/ and + // https://www.unicode.org/cldr/charts/30/supplemental/territory_information.html + // for details. Example: "CH" for Switzerland. + RegionCode string `json:"regionCode,omitempty"` + + // Revision: The schema revision of the `PostalAddress`. This must be + // set to 0, which is the latest revision. All new revisions **must** be + // backward compatible with old revisions. + Revision int64 `json:"revision,omitempty"` + + // SortingCode: Optional. Additional, country-specific, sorting code. + // This is not used in most regions. Where it is used, the value is + // either a string like "CEDEX", optionally followed by a number (e.g. + // "CEDEX 7"), or just a number alone, representing the "sector code" + // (Jamaica), "delivery area indicator" (Malawi) or "post office + // indicator" (e.g. Côte d'Ivoire). + SortingCode string `json:"sortingCode,omitempty"` + + // Sublocality: Optional. Sublocality of the address. For example, this + // can be neighborhoods, boroughs, districts. + Sublocality string `json:"sublocality,omitempty"` + + // ForceSendFields is a list of field names (e.g. "AddressLines") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "AddressLines") to include + // in API requests with the JSON null value. By default, fields with + // empty values are omitted from API requests. However, any field with + // an empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GoogleTypePostalAddress) MarshalJSON() ([]byte, error) { + type NoMethod GoogleTypePostalAddress + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// method id "addressvalidation.provideValidationFeedback": + +type V1ProvideValidationFeedbackCall struct { + s *Service + googlemapsaddressvalidationv1providevalidationfeedbackrequest *GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest + urlParams_ gensupport.URLParams + ctx_ context.Context + header_ http.Header +} + +// ProvideValidationFeedback: Feedback about the outcome of the sequence +// of validation attempts. This should be the last call made after a +// sequence of validation calls for the same address, and should be +// called once the transaction is concluded. This should only be sent +// once for the sequence of `ValidateAddress` requests needed to +// validate an address fully. +func (r *V1Service) ProvideValidationFeedback(googlemapsaddressvalidationv1providevalidationfeedbackrequest *GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest) *V1ProvideValidationFeedbackCall { + c := &V1ProvideValidationFeedbackCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.googlemapsaddressvalidationv1providevalidationfeedbackrequest = googlemapsaddressvalidationv1providevalidationfeedbackrequest + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *V1ProvideValidationFeedbackCall) Fields(s ...googleapi.Field) *V1ProvideValidationFeedbackCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *V1ProvideValidationFeedbackCall) Context(ctx context.Context) *V1ProvideValidationFeedbackCall { + c.ctx_ = ctx + return c +} + +// Header returns an http.Header that can be modified by the caller to +// add HTTP headers to the request. +func (c *V1ProvideValidationFeedbackCall) Header() http.Header { + if c.header_ == nil { + c.header_ = make(http.Header) + } + return c.header_ +} + +func (c *V1ProvideValidationFeedbackCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version) + for k, v := range c.header_ { + reqHeaders[k] = v + } + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlemapsaddressvalidationv1providevalidationfeedbackrequest) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + c.urlParams_.Set("prettyPrint", "false") + urls := googleapi.ResolveRelative(c.s.BasePath, "v1:provideValidationFeedback") + urls += "?" + c.urlParams_.Encode() + req, err := http.NewRequest("POST", urls, body) + if err != nil { + return nil, err + } + req.Header = reqHeaders + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "addressvalidation.provideValidationFeedback" call. +// Exactly one of +// *GoogleMapsAddressvalidationV1ProvideValidationFeedbackResponse or +// error will be non-nil. Any non-2xx status code is an error. Response +// headers are in either +// *GoogleMapsAddressvalidationV1ProvideValidationFeedbackResponse.Server +// Response.Header or (if a response was returned at all) in +// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check +// whether the returned error was because http.StatusNotModified was +// returned. +func (c *V1ProvideValidationFeedbackCall) Do(opts ...googleapi.CallOption) (*GoogleMapsAddressvalidationV1ProvideValidationFeedbackResponse, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, gensupport.WrapError(&googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + }) + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, gensupport.WrapError(err) + } + ret := &GoogleMapsAddressvalidationV1ProvideValidationFeedbackResponse{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := gensupport.DecodeResponse(target, res); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Feedback about the outcome of the sequence of validation attempts. This should be the last call made after a sequence of validation calls for the same address, and should be called once the transaction is concluded. This should only be sent once for the sequence of `ValidateAddress` requests needed to validate an address fully.", + // "flatPath": "v1:provideValidationFeedback", + // "httpMethod": "POST", + // "id": "addressvalidation.provideValidationFeedback", + // "parameterOrder": [], + // "parameters": {}, + // "path": "v1:provideValidationFeedback", + // "request": { + // "$ref": "GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest" + // }, + // "response": { + // "$ref": "GoogleMapsAddressvalidationV1ProvideValidationFeedbackResponse" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/maps-platform.addressvalidation" + // ] + // } + +} + +// method id "addressvalidation.validateAddress": + +type V1ValidateAddressCall struct { + s *Service + googlemapsaddressvalidationv1validateaddressrequest *GoogleMapsAddressvalidationV1ValidateAddressRequest + urlParams_ gensupport.URLParams + ctx_ context.Context + header_ http.Header +} + +// ValidateAddress: Validates an address. +func (r *V1Service) ValidateAddress(googlemapsaddressvalidationv1validateaddressrequest *GoogleMapsAddressvalidationV1ValidateAddressRequest) *V1ValidateAddressCall { + c := &V1ValidateAddressCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.googlemapsaddressvalidationv1validateaddressrequest = googlemapsaddressvalidationv1validateaddressrequest + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *V1ValidateAddressCall) Fields(s ...googleapi.Field) *V1ValidateAddressCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *V1ValidateAddressCall) Context(ctx context.Context) *V1ValidateAddressCall { + c.ctx_ = ctx + return c +} + +// Header returns an http.Header that can be modified by the caller to +// add HTTP headers to the request. +func (c *V1ValidateAddressCall) Header() http.Header { + if c.header_ == nil { + c.header_ = make(http.Header) + } + return c.header_ +} + +func (c *V1ValidateAddressCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version) + for k, v := range c.header_ { + reqHeaders[k] = v + } + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlemapsaddressvalidationv1validateaddressrequest) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + c.urlParams_.Set("prettyPrint", "false") + urls := googleapi.ResolveRelative(c.s.BasePath, "v1:validateAddress") + urls += "?" + c.urlParams_.Encode() + req, err := http.NewRequest("POST", urls, body) + if err != nil { + return nil, err + } + req.Header = reqHeaders + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "addressvalidation.validateAddress" call. +// Exactly one of *GoogleMapsAddressvalidationV1ValidateAddressResponse +// or error will be non-nil. Any non-2xx status code is an error. +// Response headers are in either +// *GoogleMapsAddressvalidationV1ValidateAddressResponse.ServerResponse.H +// eader or (if a response was returned at all) in +// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check +// whether the returned error was because http.StatusNotModified was +// returned. +func (c *V1ValidateAddressCall) Do(opts ...googleapi.CallOption) (*GoogleMapsAddressvalidationV1ValidateAddressResponse, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, gensupport.WrapError(&googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + }) + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, gensupport.WrapError(err) + } + ret := &GoogleMapsAddressvalidationV1ValidateAddressResponse{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := gensupport.DecodeResponse(target, res); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Validates an address.", + // "flatPath": "v1:validateAddress", + // "httpMethod": "POST", + // "id": "addressvalidation.validateAddress", + // "parameterOrder": [], + // "parameters": {}, + // "path": "v1:validateAddress", + // "request": { + // "$ref": "GoogleMapsAddressvalidationV1ValidateAddressRequest" + // }, + // "response": { + // "$ref": "GoogleMapsAddressvalidationV1ValidateAddressResponse" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/maps-platform.addressvalidation" + // ] + // } + +} diff --git a/api-list.json b/api-list.json index 31f1c9adcf..73c70aae81 100644 --- a/api-list.json +++ b/api-list.json @@ -77,6 +77,21 @@ "documentationLink": "https://developers.google.com/domains/acme-dns/", "preferred": true }, + { + "kind": "discovery#directoryItem", + "id": "addressvalidation:v1", + "name": "addressvalidation", + "version": "v1", + "title": "Address Validation API", + "description": "The Address Validation API allows developers to verify the accuracy of addresses. Given an address, it returns information about the correctness of the components of the parsed address, a geocode, and a verdict on the deliverability of the parsed address.", + "discoveryRestUrl": "https://addressvalidation.googleapis.com/$discovery/rest?version=v1", + "icons": { + "x16": "https://www.gstatic.com/images/branding/product/1x/googleg_16dp.png", + "x32": "https://www.gstatic.com/images/branding/product/1x/googleg_32dp.png" + }, + "documentationLink": "https://developers.google.com/maps/documentation/addressvalidation", + "preferred": true + }, { "kind": "discovery#directoryItem", "id": "adexchangebuyer2:v2beta1", diff --git a/container/v1/container-api.json b/container/v1/container-api.json index eb6b473c4c..c18824eff5 100644 --- a/container/v1/container-api.json +++ b/container/v1/container-api.json @@ -2540,7 +2540,7 @@ } } }, - "revision": "20240313", + "revision": "20240327", "rootUrl": "https://container.googleapis.com/", "schemas": { "AcceleratorConfig": { @@ -3022,6 +3022,24 @@ }, "type": "object" }, + "CertificateAuthorityDomainConfig": { + "description": "CertificateAuthorityDomainConfig configures one or more fully qualified domain names (FQDN) to a specific certificate.", + "id": "CertificateAuthorityDomainConfig", + "properties": { + "fqdns": { + "description": "List of fully qualified domain names (FQDN). Specifying port is supported. Wilcards are NOT supported. Examples: - my.customdomain.com - 10.0.1.2:5000", + "items": { + "type": "string" + }, + "type": "array" + }, + "gcpSecretManagerCertificateConfig": { + "$ref": "GCPSecretManagerCertificateConfig", + "description": "Google Secret Manager (GCP) certificate configuration." + } + }, + "type": "object" + }, "CheckAutopilotCompatibilityResponse": { "description": "CheckAutopilotCompatibilityResponse has a list of compatibility issues.", "id": "CheckAutopilotCompatibilityResponse", @@ -3504,6 +3522,10 @@ "$ref": "ClusterAutoscaling", "description": "Cluster-level autoscaling configuration." }, + "desiredContainerdConfig": { + "$ref": "ContainerdConfig", + "description": "The desired containerd config for the cluster." + }, "desiredCostManagementConfig": { "$ref": "CostManagementConfig", "description": "The desired configuration for the fine-grained cost management feature." @@ -3669,7 +3691,7 @@ }, "desiredPrivateClusterConfig": { "$ref": "PrivateClusterConfig", - "description": "The desired private cluster configuration." + "description": "The desired private cluster configuration. master_global_access_config is the only field that can be changed via this field. See also ClusterUpdate.desired_enable_private_endpoint for modifying other fields within PrivateClusterConfig." }, "desiredPrivateIpv6GoogleAccess": { "description": "The desired state of IPv6 connectivity to Google Services.", @@ -3809,6 +3831,17 @@ }, "type": "object" }, + "ContainerdConfig": { + "description": "ContainerdConfig contains configuration to customize containerd.", + "id": "ContainerdConfig", + "properties": { + "privateRegistryAccessConfig": { + "$ref": "PrivateRegistryAccessConfig", + "description": "PrivateRegistryAccessConfig is used to configure access configuration for private container registries." + } + }, + "type": "object" + }, "CostManagementConfig": { "description": "Configuration for fine-grained cost management feature.", "id": "CostManagementConfig", @@ -3879,6 +3912,10 @@ "description": "DNSConfig contains the desired set of options for configuring clusterDNS.", "id": "DNSConfig", "properties": { + "additiveVpcScopeDnsDomain": { + "description": "Optional. The domain used in Additive VPC scope.", + "type": "string" + }, "clusterDns": { "description": "cluster_dns indicates which in-cluster DNS provider should be used.", "enum": [ @@ -4113,6 +4150,17 @@ }, "type": "object" }, + "GCPSecretManagerCertificateConfig": { + "description": "GCPSecretManagerCertificateConfig configures a secret from [Google Secret Manager](https://cloud.google.com/secret-manager).", + "id": "GCPSecretManagerCertificateConfig", + "properties": { + "secretUri": { + "description": "Secret URI, in the form \"projects/$PROJECT_ID/secrets/$SECRET_NAME/versions/$VERSION\". Version can be fixed (e.g. \"2\") or \"latest\"", + "type": "string" + } + }, + "type": "object" + }, "GPUDriverInstallationConfig": { "description": "GPUDriverInstallationConfig specifies the version of GPU driver to be auto installed.", "id": "GPUDriverInstallationConfig", @@ -4144,11 +4192,13 @@ "description": "The type of GPU sharing strategy to enable on the GPU node.", "enum": [ "GPU_SHARING_STRATEGY_UNSPECIFIED", - "TIME_SHARING" + "TIME_SHARING", + "MPS" ], "enumDescriptions": [ "Default value.", - "GPUs are time-shared between containers." + "GPUs are time-shared between containers.", + "GPUs are shared between containers with NVIDIA MPS." ], "type": "string" }, @@ -4352,6 +4402,23 @@ }, "type": "object" }, + "HugepagesConfig": { + "description": "Hugepages amount in both 2m and 1g size", + "id": "HugepagesConfig", + "properties": { + "hugepageSize1g": { + "description": "Optional. Amount of 1G hugepages", + "format": "int32", + "type": "integer" + }, + "hugepageSize2m": { + "description": "Optional. Amount of 2M hugepages", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, "ILBSubsettingConfig": { "description": "ILBSubsettingConfig contains the desired config of L4 Internal LoadBalancer subsetting on this cluster.", "id": "ILBSubsettingConfig", @@ -4597,6 +4664,10 @@ ], "type": "string" }, + "hugepages": { + "$ref": "HugepagesConfig", + "description": "Optional. Amounts for 2M and 1G hugepages" + }, "sysctls": { "additionalProperties": { "type": "string" @@ -5207,6 +5278,10 @@ "$ref": "ConfidentialNodes", "description": "Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled." }, + "containerdConfig": { + "$ref": "ContainerdConfig", + "description": "Parameters for containerd customization." + }, "diskSizeGb": { "description": "Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. If unspecified, the default disk size is 100GB.", "format": "int32", @@ -5373,6 +5448,10 @@ "description": "Subset of NodeConfig message that has defaults.", "id": "NodeConfigDefaults", "properties": { + "containerdConfig": { + "$ref": "ContainerdConfig", + "description": "Parameters for containerd customization." + }, "gcfsConfig": { "$ref": "GcfsConfig", "description": "GCFS (Google Container File System, also known as Riptide) options." @@ -6085,6 +6164,24 @@ }, "type": "object" }, + "PrivateRegistryAccessConfig": { + "description": "PrivateRegistryAccessConfig contains access configuration for private container registries.", + "id": "PrivateRegistryAccessConfig", + "properties": { + "certificateAuthorityDomainConfig": { + "description": "Private registry access configuration.", + "items": { + "$ref": "CertificateAuthorityDomainConfig" + }, + "type": "array" + }, + "enabled": { + "description": "Private registry access is enabled.", + "type": "boolean" + } + }, + "type": "object" + }, "PubSub": { "description": "Pub/Sub specific notification config.", "id": "PubSub", @@ -7238,6 +7335,13 @@ "description": "UpdateNodePoolRequests update a node pool's image and/or version.", "id": "UpdateNodePoolRequest", "properties": { + "accelerators": { + "description": "A list of hardware accelerators to be attached to each node. See https://cloud.google.com/compute/docs/gpus for more information about support for GPUs.", + "items": { + "$ref": "AcceleratorConfig" + }, + "type": "array" + }, "clusterId": { "deprecated": true, "description": "Deprecated. The name of the cluster to upgrade. This field has been deprecated and replaced by the name field.", @@ -7247,6 +7351,10 @@ "$ref": "ConfidentialNodes", "description": "Confidential nodes config. All the nodes in the node pool will be Confidential VM once enabled." }, + "containerdConfig": { + "$ref": "ContainerdConfig", + "description": "The desired containerd config for nodes in the node pool. Initiates an upgrade operation that recreates the nodes with the new config." + }, "diskSizeGb": { "description": "Optional. The desired disk size for nodes in the node pool specified in GB. The smallest allowed disk size is 10GB. Initiates an upgrade operation that migrates the nodes in the node pool to the specified disk size.", "format": "int64", diff --git a/container/v1/container-gen.go b/container/v1/container-gen.go index db99255636..643a8184af 100644 --- a/container/v1/container-gen.go +++ b/container/v1/container-gen.go @@ -1105,6 +1105,42 @@ func (s *CancelOperationRequest) MarshalJSON() ([]byte, error) { return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } +// CertificateAuthorityDomainConfig: CertificateAuthorityDomainConfig +// configures one or more fully qualified domain names (FQDN) to a +// specific certificate. +type CertificateAuthorityDomainConfig struct { + // Fqdns: List of fully qualified domain names (FQDN). Specifying port + // is supported. Wilcards are NOT supported. Examples: - + // my.customdomain.com - 10.0.1.2:5000 + Fqdns []string `json:"fqdns,omitempty"` + + // GcpSecretManagerCertificateConfig: Google Secret Manager (GCP) + // certificate configuration. + GcpSecretManagerCertificateConfig *GCPSecretManagerCertificateConfig `json:"gcpSecretManagerCertificateConfig,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Fqdns") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "Fqdns") to include in API + // requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *CertificateAuthorityDomainConfig) MarshalJSON() ([]byte, error) { + type NoMethod CertificateAuthorityDomainConfig + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + // CheckAutopilotCompatibilityResponse: // CheckAutopilotCompatibilityResponse has a list of compatibility // issues. @@ -1752,6 +1788,10 @@ type ClusterUpdate struct { // DesiredClusterAutoscaling: Cluster-level autoscaling configuration. DesiredClusterAutoscaling *ClusterAutoscaling `json:"desiredClusterAutoscaling,omitempty"` + // DesiredContainerdConfig: The desired containerd config for the + // cluster. + DesiredContainerdConfig *ContainerdConfig `json:"desiredContainerdConfig,omitempty"` + // DesiredCostManagementConfig: The desired configuration for the // fine-grained cost management feature. DesiredCostManagementConfig *CostManagementConfig `json:"desiredCostManagementConfig,omitempty"` @@ -1938,7 +1978,10 @@ type ClusterUpdate struct { DesiredParentProductConfig *ParentProductConfig `json:"desiredParentProductConfig,omitempty"` // DesiredPrivateClusterConfig: The desired private cluster - // configuration. + // configuration. master_global_access_config is the only field that can + // be changed via this field. See also + // ClusterUpdate.desired_enable_private_endpoint for modifying other + // fields within PrivateClusterConfig. DesiredPrivateClusterConfig *PrivateClusterConfig `json:"desiredPrivateClusterConfig,omitempty"` // DesiredPrivateIpv6GoogleAccess: The desired state of IPv6 @@ -2174,6 +2217,38 @@ func (s *ConsumptionMeteringConfig) MarshalJSON() ([]byte, error) { return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } +// ContainerdConfig: ContainerdConfig contains configuration to +// customize containerd. +type ContainerdConfig struct { + // PrivateRegistryAccessConfig: PrivateRegistryAccessConfig is used to + // configure access configuration for private container registries. + PrivateRegistryAccessConfig *PrivateRegistryAccessConfig `json:"privateRegistryAccessConfig,omitempty"` + + // ForceSendFields is a list of field names (e.g. + // "PrivateRegistryAccessConfig") to unconditionally include in API + // requests. By default, fields with empty or default values are omitted + // from API requests. However, any non-pointer, non-interface field + // appearing in ForceSendFields will be sent to the server regardless of + // whether the field is empty or not. This may be used to include empty + // fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. + // "PrivateRegistryAccessConfig") to include in API requests with the + // JSON null value. By default, fields with empty values are omitted + // from API requests. However, any field with an empty value appearing + // in NullFields will be sent to the server as null. It is an error if a + // field in this list has a non-empty value. This may be used to include + // null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *ContainerdConfig) MarshalJSON() ([]byte, error) { + type NoMethod ContainerdConfig + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + // CostManagementConfig: Configuration for fine-grained cost management // feature. type CostManagementConfig struct { @@ -2301,6 +2376,10 @@ func (s *CreateNodePoolRequest) MarshalJSON() ([]byte, error) { // DNSConfig: DNSConfig contains the desired set of options for // configuring clusterDNS. type DNSConfig struct { + // AdditiveVpcScopeDnsDomain: Optional. The domain used in Additive VPC + // scope. + AdditiveVpcScopeDnsDomain string `json:"additiveVpcScopeDnsDomain,omitempty"` + // ClusterDns: cluster_dns indicates which in-cluster DNS provider // should be used. // @@ -2327,20 +2406,22 @@ type DNSConfig struct { // "VPC_SCOPE" - DNS records are accessible from within the VPC. ClusterDnsScope string `json:"clusterDnsScope,omitempty"` - // ForceSendFields is a list of field names (e.g. "ClusterDns") to - // unconditionally include in API requests. By default, fields with - // empty or default values are omitted from API requests. However, any - // non-pointer, non-interface field appearing in ForceSendFields will be - // sent to the server regardless of whether the field is empty or not. - // This may be used to include empty fields in Patch requests. + // ForceSendFields is a list of field names (e.g. + // "AdditiveVpcScopeDnsDomain") to unconditionally include in API + // requests. By default, fields with empty or default values are omitted + // from API requests. However, any non-pointer, non-interface field + // appearing in ForceSendFields will be sent to the server regardless of + // whether the field is empty or not. This may be used to include empty + // fields in Patch requests. ForceSendFields []string `json:"-"` - // NullFields is a list of field names (e.g. "ClusterDns") to include in - // API requests with the JSON null value. By default, fields with empty - // values are omitted from API requests. However, any field with an - // empty value appearing in NullFields will be sent to the server as - // null. It is an error if a field in this list has a non-empty value. - // This may be used to include null fields in Patch requests. + // NullFields is a list of field names (e.g. + // "AdditiveVpcScopeDnsDomain") to include in API requests with the JSON + // null value. By default, fields with empty values are omitted from API + // requests. However, any field with an empty value appearing in + // NullFields will be sent to the server as null. It is an error if a + // field in this list has a non-empty value. This may be used to include + // null fields in Patch requests. NullFields []string `json:"-"` } @@ -2711,6 +2792,38 @@ func (s *Fleet) MarshalJSON() ([]byte, error) { return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } +// GCPSecretManagerCertificateConfig: GCPSecretManagerCertificateConfig +// configures a secret from Google Secret Manager +// (https://cloud.google.com/secret-manager). +type GCPSecretManagerCertificateConfig struct { + // SecretUri: Secret URI, in the form + // "projects/$PROJECT_ID/secrets/$SECRET_NAME/versions/$VERSION". + // Version can be fixed (e.g. "2") or "latest" + SecretUri string `json:"secretUri,omitempty"` + + // ForceSendFields is a list of field names (e.g. "SecretUri") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "SecretUri") to include in + // API requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *GCPSecretManagerCertificateConfig) MarshalJSON() ([]byte, error) { + type NoMethod GCPSecretManagerCertificateConfig + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + // GPUDriverInstallationConfig: GPUDriverInstallationConfig specifies // the version of GPU driver to be auto installed. type GPUDriverInstallationConfig struct { @@ -2758,6 +2871,7 @@ type GPUSharingConfig struct { // Possible values: // "GPU_SHARING_STRATEGY_UNSPECIFIED" - Default value. // "TIME_SHARING" - GPUs are time-shared between containers. + // "MPS" - GPUs are shared between containers with NVIDIA MPS. GpuSharingStrategy string `json:"gpuSharingStrategy,omitempty"` // MaxSharedClientsPerGpu: The max number of containers that can share a @@ -3168,6 +3282,38 @@ func (s *HttpLoadBalancing) MarshalJSON() ([]byte, error) { return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } +// HugepagesConfig: Hugepages amount in both 2m and 1g size +type HugepagesConfig struct { + // HugepageSize1g: Optional. Amount of 1G hugepages + HugepageSize1g int64 `json:"hugepageSize1g,omitempty"` + + // HugepageSize2m: Optional. Amount of 2M hugepages + HugepageSize2m int64 `json:"hugepageSize2m,omitempty"` + + // ForceSendFields is a list of field names (e.g. "HugepageSize1g") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "HugepageSize1g") to + // include in API requests with the JSON null value. By default, fields + // with empty values are omitted from API requests. However, any field + // with an empty value appearing in NullFields will be sent to the + // server as null. It is an error if a field in this list has a + // non-empty value. This may be used to include null fields in Patch + // requests. + NullFields []string `json:"-"` +} + +func (s *HugepagesConfig) MarshalJSON() ([]byte, error) { + type NoMethod HugepagesConfig + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + // ILBSubsettingConfig: ILBSubsettingConfig contains the desired config // of L4 Internal LoadBalancer subsetting on this cluster. type ILBSubsettingConfig struct { @@ -3600,6 +3746,9 @@ type LinuxNodeConfig struct { // cgroup configuration on the node image. CgroupMode string `json:"cgroupMode,omitempty"` + // Hugepages: Optional. Amounts for 2M and 1G hugepages + Hugepages *HugepagesConfig `json:"hugepages,omitempty"` + // Sysctls: The Linux kernel parameters to be applied to the nodes and // all pods running on the nodes. The following parameters are // supported. net.core.busy_poll net.core.busy_read @@ -4697,6 +4846,9 @@ type NodeConfig struct { // node pool will be Confidential VM once enabled. ConfidentialNodes *ConfidentialNodes `json:"confidentialNodes,omitempty"` + // ContainerdConfig: Parameters for containerd customization. + ContainerdConfig *ContainerdConfig `json:"containerdConfig,omitempty"` + // DiskSizeGb: Size of the disk attached to each node, specified in GB. // The smallest allowed disk size is 10GB. If unspecified, the default // disk size is 100GB. @@ -4900,6 +5052,9 @@ func (s *NodeConfig) MarshalJSON() ([]byte, error) { // NodeConfigDefaults: Subset of NodeConfig message that has defaults. type NodeConfigDefaults struct { + // ContainerdConfig: Parameters for containerd customization. + ContainerdConfig *ContainerdConfig `json:"containerdConfig,omitempty"` + // GcfsConfig: GCFS (Google Container File System, also known as // Riptide) options. GcfsConfig *GcfsConfig `json:"gcfsConfig,omitempty"` @@ -4907,7 +5062,7 @@ type NodeConfigDefaults struct { // LoggingConfig: Logging configuration for node pools. LoggingConfig *NodePoolLoggingConfig `json:"loggingConfig,omitempty"` - // ForceSendFields is a list of field names (e.g. "GcfsConfig") to + // ForceSendFields is a list of field names (e.g. "ContainerdConfig") to // unconditionally include in API requests. By default, fields with // empty or default values are omitted from API requests. However, any // non-pointer, non-interface field appearing in ForceSendFields will be @@ -4915,12 +5070,13 @@ type NodeConfigDefaults struct { // This may be used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` - // NullFields is a list of field names (e.g. "GcfsConfig") to include in - // API requests with the JSON null value. By default, fields with empty - // values are omitted from API requests. However, any field with an - // empty value appearing in NullFields will be sent to the server as - // null. It is an error if a field in this list has a non-empty value. - // This may be used to include null fields in Patch requests. + // NullFields is a list of field names (e.g. "ContainerdConfig") to + // include in API requests with the JSON null value. By default, fields + // with empty values are omitted from API requests. However, any field + // with an empty value appearing in NullFields will be sent to the + // server as null. It is an error if a field in this list has a + // non-empty value. This may be used to include null fields in Patch + // requests. NullFields []string `json:"-"` } @@ -6050,6 +6206,41 @@ func (s *PrivateClusterMasterGlobalAccessConfig) MarshalJSON() ([]byte, error) { return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } +// PrivateRegistryAccessConfig: PrivateRegistryAccessConfig contains +// access configuration for private container registries. +type PrivateRegistryAccessConfig struct { + // CertificateAuthorityDomainConfig: Private registry access + // configuration. + CertificateAuthorityDomainConfig []*CertificateAuthorityDomainConfig `json:"certificateAuthorityDomainConfig,omitempty"` + + // Enabled: Private registry access is enabled. + Enabled bool `json:"enabled,omitempty"` + + // ForceSendFields is a list of field names (e.g. + // "CertificateAuthorityDomainConfig") to unconditionally include in API + // requests. By default, fields with empty or default values are omitted + // from API requests. However, any non-pointer, non-interface field + // appearing in ForceSendFields will be sent to the server regardless of + // whether the field is empty or not. This may be used to include empty + // fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. + // "CertificateAuthorityDomainConfig") to include in API requests with + // the JSON null value. By default, fields with empty values are omitted + // from API requests. However, any field with an empty value appearing + // in NullFields will be sent to the server as null. It is an error if a + // field in this list has a non-empty value. This may be used to include + // null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *PrivateRegistryAccessConfig) MarshalJSON() ([]byte, error) { + type NoMethod PrivateRegistryAccessConfig + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + // PubSub: Pub/Sub specific notification config. type PubSub struct { // Enabled: Enable notifications for Pub/Sub. @@ -8069,6 +8260,11 @@ func (s *UpdateMasterRequest) MarshalJSON() ([]byte, error) { // UpdateNodePoolRequest: UpdateNodePoolRequests update a node pool's // image and/or version. type UpdateNodePoolRequest struct { + // Accelerators: A list of hardware accelerators to be attached to each + // node. See https://cloud.google.com/compute/docs/gpus for more + // information about support for GPUs. + Accelerators []*AcceleratorConfig `json:"accelerators,omitempty"` + // ClusterId: Deprecated. The name of the cluster to upgrade. This field // has been deprecated and replaced by the name field. ClusterId string `json:"clusterId,omitempty"` @@ -8077,6 +8273,11 @@ type UpdateNodePoolRequest struct { // node pool will be Confidential VM once enabled. ConfidentialNodes *ConfidentialNodes `json:"confidentialNodes,omitempty"` + // ContainerdConfig: The desired containerd config for nodes in the node + // pool. Initiates an upgrade operation that recreates the nodes with + // the new config. + ContainerdConfig *ContainerdConfig `json:"containerdConfig,omitempty"` + // DiskSizeGb: Optional. The desired disk size for nodes in the node // pool specified in GB. The smallest allowed disk size is 10GB. // Initiates an upgrade operation that migrates the nodes in the node @@ -8210,7 +8411,7 @@ type UpdateNodePoolRequest struct { // name field. Zone string `json:"zone,omitempty"` - // ForceSendFields is a list of field names (e.g. "ClusterId") to + // ForceSendFields is a list of field names (e.g. "Accelerators") to // unconditionally include in API requests. By default, fields with // empty or default values are omitted from API requests. However, any // non-pointer, non-interface field appearing in ForceSendFields will be @@ -8218,10 +8419,10 @@ type UpdateNodePoolRequest struct { // This may be used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` - // NullFields is a list of field names (e.g. "ClusterId") to include in - // API requests with the JSON null value. By default, fields with empty - // values are omitted from API requests. However, any field with an - // empty value appearing in NullFields will be sent to the server as + // NullFields is a list of field names (e.g. "Accelerators") to include + // in API requests with the JSON null value. By default, fields with + // empty values are omitted from API requests. However, any field with + // an empty value appearing in NullFields will be sent to the server as // null. It is an error if a field in this list has a non-empty value. // This may be used to include null fields in Patch requests. NullFields []string `json:"-"` diff --git a/dataportability/v1/dataportability-api.json b/dataportability/v1/dataportability-api.json index a3787b60d2..c4c6f459b7 100644 --- a/dataportability/v1/dataportability-api.json +++ b/dataportability/v1/dataportability-api.json @@ -2,9 +2,6 @@ "auth": { "oauth2": { "scopes": { - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions": { - "description": "Move a copy of the Google Alerts subscriptions you created." - }, "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations": { "description": "Move a copy of messages between you and the businesses you have conversations with across Google services." }, @@ -318,7 +315,6 @@ "$ref": "PortabilityArchiveState" }, "scopes": [ - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", "https://www.googleapis.com/auth/dataportability.chrome.autofill", "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -409,7 +405,6 @@ "$ref": "RetryPortabilityArchiveResponse" }, "scopes": [ - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", "https://www.googleapis.com/auth/dataportability.chrome.autofill", "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -494,7 +489,6 @@ "$ref": "Empty" }, "scopes": [ - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", "https://www.googleapis.com/auth/dataportability.chrome.autofill", "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -579,7 +573,6 @@ "$ref": "InitiatePortabilityArchiveResponse" }, "scopes": [ - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", "https://www.googleapis.com/auth/dataportability.chrome.autofill", "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -648,7 +641,7 @@ } } }, - "revision": "20240403", + "revision": "20240410", "rootUrl": "https://dataportability.googleapis.com/", "schemas": { "Empty": { diff --git a/dataportability/v1/dataportability-gen.go b/dataportability/v1/dataportability-gen.go index de7924f550..f38edf7e4f 100644 --- a/dataportability/v1/dataportability-gen.go +++ b/dataportability/v1/dataportability-gen.go @@ -101,9 +101,6 @@ const defaultUniverseDomain = "googleapis.com" // OAuth2 scopes used by this API. const ( - // Move a copy of the Google Alerts subscriptions you created. - DataportabilityAlertsSubscriptionsScope = "https://www.googleapis.com/auth/dataportability.alerts.subscriptions" - // Move a copy of messages between you and the businesses you have // conversations with across Google services. DataportabilityBusinessmessagingConversationsScope = "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations" @@ -313,7 +310,6 @@ const ( // NewService creates a new Service. func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) { scopesOption := internaloption.WithDefaultScopes( - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", "https://www.googleapis.com/auth/dataportability.chrome.autofill", "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -772,7 +768,6 @@ func (c *ArchiveJobsGetPortabilityArchiveStateCall) Do(opts ...googleapi.CallOpt // "$ref": "PortabilityArchiveState" // }, // "scopes": [ - // "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", // "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", // "https://www.googleapis.com/auth/dataportability.chrome.autofill", // "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -979,7 +974,6 @@ func (c *ArchiveJobsRetryCall) Do(opts ...googleapi.CallOption) (*RetryPortabili // "$ref": "RetryPortabilityArchiveResponse" // }, // "scopes": [ - // "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", // "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", // "https://www.googleapis.com/auth/dataportability.chrome.autofill", // "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -1172,7 +1166,6 @@ func (c *AuthorizationResetCall) Do(opts ...googleapi.CallOption) (*Empty, error // "$ref": "Empty" // }, // "scopes": [ - // "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", // "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", // "https://www.googleapis.com/auth/dataportability.chrome.autofill", // "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -1361,7 +1354,6 @@ func (c *PortabilityArchiveInitiateCall) Do(opts ...googleapi.CallOption) (*Init // "$ref": "InitiatePortabilityArchiveResponse" // }, // "scopes": [ - // "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", // "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", // "https://www.googleapis.com/auth/dataportability.chrome.autofill", // "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", diff --git a/dataportability/v1beta/dataportability-api.json b/dataportability/v1beta/dataportability-api.json index 11508cd779..6736eee1de 100644 --- a/dataportability/v1beta/dataportability-api.json +++ b/dataportability/v1beta/dataportability-api.json @@ -2,9 +2,6 @@ "auth": { "oauth2": { "scopes": { - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions": { - "description": "Move a copy of the Google Alerts subscriptions you created." - }, "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations": { "description": "Move a copy of messages between you and the businesses you have conversations with across Google services." }, @@ -318,7 +315,6 @@ "$ref": "PortabilityArchiveState" }, "scopes": [ - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", "https://www.googleapis.com/auth/dataportability.chrome.autofill", "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -409,7 +405,6 @@ "$ref": "RetryPortabilityArchiveResponse" }, "scopes": [ - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", "https://www.googleapis.com/auth/dataportability.chrome.autofill", "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -494,7 +489,6 @@ "$ref": "Empty" }, "scopes": [ - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", "https://www.googleapis.com/auth/dataportability.chrome.autofill", "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -579,7 +573,6 @@ "$ref": "InitiatePortabilityArchiveResponse" }, "scopes": [ - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", "https://www.googleapis.com/auth/dataportability.chrome.autofill", "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -648,7 +641,7 @@ } } }, - "revision": "20240403", + "revision": "20240410", "rootUrl": "https://dataportability.googleapis.com/", "schemas": { "Empty": { diff --git a/dataportability/v1beta/dataportability-gen.go b/dataportability/v1beta/dataportability-gen.go index 2d0d004857..8f9e080664 100644 --- a/dataportability/v1beta/dataportability-gen.go +++ b/dataportability/v1beta/dataportability-gen.go @@ -101,9 +101,6 @@ const defaultUniverseDomain = "googleapis.com" // OAuth2 scopes used by this API. const ( - // Move a copy of the Google Alerts subscriptions you created. - DataportabilityAlertsSubscriptionsScope = "https://www.googleapis.com/auth/dataportability.alerts.subscriptions" - // Move a copy of messages between you and the businesses you have // conversations with across Google services. DataportabilityBusinessmessagingConversationsScope = "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations" @@ -313,7 +310,6 @@ const ( // NewService creates a new Service. func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) { scopesOption := internaloption.WithDefaultScopes( - "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", "https://www.googleapis.com/auth/dataportability.chrome.autofill", "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -772,7 +768,6 @@ func (c *ArchiveJobsGetPortabilityArchiveStateCall) Do(opts ...googleapi.CallOpt // "$ref": "PortabilityArchiveState" // }, // "scopes": [ - // "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", // "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", // "https://www.googleapis.com/auth/dataportability.chrome.autofill", // "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -979,7 +974,6 @@ func (c *ArchiveJobsRetryCall) Do(opts ...googleapi.CallOption) (*RetryPortabili // "$ref": "RetryPortabilityArchiveResponse" // }, // "scopes": [ - // "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", // "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", // "https://www.googleapis.com/auth/dataportability.chrome.autofill", // "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -1172,7 +1166,6 @@ func (c *AuthorizationResetCall) Do(opts ...googleapi.CallOption) (*Empty, error // "$ref": "Empty" // }, // "scopes": [ - // "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", // "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", // "https://www.googleapis.com/auth/dataportability.chrome.autofill", // "https://www.googleapis.com/auth/dataportability.chrome.bookmarks", @@ -1361,7 +1354,6 @@ func (c *PortabilityArchiveInitiateCall) Do(opts ...googleapi.CallOption) (*Init // "$ref": "InitiatePortabilityArchiveResponse" // }, // "scopes": [ - // "https://www.googleapis.com/auth/dataportability.alerts.subscriptions", // "https://www.googleapis.com/auth/dataportability.businessmessaging.conversations", // "https://www.googleapis.com/auth/dataportability.chrome.autofill", // "https://www.googleapis.com/auth/dataportability.chrome.bookmarks",