// Copyright 2025 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Generated code. DO NOT EDIT! namespace Google.Apis.AddressValidation.v1 { /// The AddressValidation Service. public class AddressValidationService : Google.Apis.Services.BaseClientService { /// The API version. public const string Version = "v1"; /// The discovery version used to generate this service. public static Google.Apis.Discovery.DiscoveryVersion DiscoveryVersionUsed = Google.Apis.Discovery.DiscoveryVersion.Version_1_0; /// Constructs a new service. public AddressValidationService() : this(new Google.Apis.Services.BaseClientService.Initializer()) { } /// Constructs a new service. /// The service initializer. public AddressValidationService(Google.Apis.Services.BaseClientService.Initializer initializer) : base(initializer) { V1 = new V1Resource(this); BaseUri = GetEffectiveUri(BaseUriOverride, "https://addressvalidation.googleapis.com/"); BatchUri = GetEffectiveUri(null, "https://addressvalidation.googleapis.com/batch"); } /// Gets the service supported features. public override System.Collections.Generic.IList Features => new string[0]; /// Gets the service name. public override string Name => "addressvalidation"; /// Gets the service base URI. public override string BaseUri { get; } /// Gets the service base path. public override string BasePath => ""; /// Gets the batch base URI; null if unspecified. public override string BatchUri { get; } /// Gets the batch base path; null if unspecified. public override string BatchPath => "batch"; /// Available OAuth 2.0 scopes for use with the Address Validation API. public class Scope { /// /// See, edit, configure, and delete your Google Cloud data and see the email address for your Google /// Account. /// public static string CloudPlatform = "https://www.googleapis.com/auth/cloud-platform"; /// Private Service: https://www.googleapis.com/auth/maps-platform.addressvalidation public static string MapsPlatformAddressvalidation = "https://www.googleapis.com/auth/maps-platform.addressvalidation"; } /// Available OAuth 2.0 scope constants for use with the Address Validation API. public static class ScopeConstants { /// /// See, edit, configure, and delete your Google Cloud data and see the email address for your Google /// Account. /// public const string CloudPlatform = "https://www.googleapis.com/auth/cloud-platform"; /// Private Service: https://www.googleapis.com/auth/maps-platform.addressvalidation public const string MapsPlatformAddressvalidation = "https://www.googleapis.com/auth/maps-platform.addressvalidation"; } /// Gets the V1 resource. public virtual V1Resource V1 { get; } } /// A base abstract class for AddressValidation requests. public abstract class AddressValidationBaseServiceRequest : Google.Apis.Requests.ClientServiceRequest { /// Constructs a new AddressValidationBaseServiceRequest instance. protected AddressValidationBaseServiceRequest(Google.Apis.Services.IClientService service) : base(service) { } /// V1 error format. [Google.Apis.Util.RequestParameterAttribute("$.xgafv", Google.Apis.Util.RequestParameterType.Query)] public virtual System.Nullable Xgafv { get; set; } /// V1 error format. public enum XgafvEnum { /// v1 error format [Google.Apis.Util.StringValueAttribute("1")] Value1 = 0, /// v2 error format [Google.Apis.Util.StringValueAttribute("2")] Value2 = 1, } /// OAuth access token. [Google.Apis.Util.RequestParameterAttribute("access_token", Google.Apis.Util.RequestParameterType.Query)] public virtual string AccessToken { get; set; } /// Data format for response. [Google.Apis.Util.RequestParameterAttribute("alt", Google.Apis.Util.RequestParameterType.Query)] public virtual System.Nullable Alt { get; set; } /// Data format for response. public enum AltEnum { /// Responses with Content-Type of application/json [Google.Apis.Util.StringValueAttribute("json")] Json = 0, /// Media download with context-dependent Content-Type [Google.Apis.Util.StringValueAttribute("media")] Media = 1, /// Responses with Content-Type of application/x-protobuf [Google.Apis.Util.StringValueAttribute("proto")] Proto = 2, } /// JSONP [Google.Apis.Util.RequestParameterAttribute("callback", Google.Apis.Util.RequestParameterType.Query)] public virtual string Callback { get; set; } /// Selector specifying which fields to include in a partial response. [Google.Apis.Util.RequestParameterAttribute("fields", Google.Apis.Util.RequestParameterType.Query)] public virtual string Fields { get; set; } /// /// 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. /// [Google.Apis.Util.RequestParameterAttribute("key", Google.Apis.Util.RequestParameterType.Query)] public virtual string Key { get; set; } /// OAuth 2.0 token for the current user. [Google.Apis.Util.RequestParameterAttribute("oauth_token", Google.Apis.Util.RequestParameterType.Query)] public virtual string OauthToken { get; set; } /// Returns response with indentations and line breaks. [Google.Apis.Util.RequestParameterAttribute("prettyPrint", Google.Apis.Util.RequestParameterType.Query)] public virtual System.Nullable PrettyPrint { get; set; } /// /// 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. /// [Google.Apis.Util.RequestParameterAttribute("quotaUser", Google.Apis.Util.RequestParameterType.Query)] public virtual string QuotaUser { get; set; } /// Legacy upload protocol for media (e.g. "media", "multipart"). [Google.Apis.Util.RequestParameterAttribute("uploadType", Google.Apis.Util.RequestParameterType.Query)] public virtual string UploadType { get; set; } /// Upload protocol for media (e.g. "raw", "multipart"). [Google.Apis.Util.RequestParameterAttribute("upload_protocol", Google.Apis.Util.RequestParameterType.Query)] public virtual string UploadProtocol { get; set; } /// Initializes AddressValidation parameter list. protected override void InitParameters() { base.InitParameters(); RequestParameters.Add("$.xgafv", new Google.Apis.Discovery.Parameter { Name = "$.xgafv", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("access_token", new Google.Apis.Discovery.Parameter { Name = "access_token", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("alt", new Google.Apis.Discovery.Parameter { Name = "alt", IsRequired = false, ParameterType = "query", DefaultValue = "json", Pattern = null, }); RequestParameters.Add("callback", new Google.Apis.Discovery.Parameter { Name = "callback", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("fields", new Google.Apis.Discovery.Parameter { Name = "fields", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("key", new Google.Apis.Discovery.Parameter { Name = "key", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("oauth_token", new Google.Apis.Discovery.Parameter { Name = "oauth_token", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("prettyPrint", new Google.Apis.Discovery.Parameter { Name = "prettyPrint", IsRequired = false, ParameterType = "query", DefaultValue = "true", Pattern = null, }); RequestParameters.Add("quotaUser", new Google.Apis.Discovery.Parameter { Name = "quotaUser", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("uploadType", new Google.Apis.Discovery.Parameter { Name = "uploadType", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("upload_protocol", new Google.Apis.Discovery.Parameter { Name = "upload_protocol", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); } } /// The "v1" collection of methods. public class V1Resource { private const string Resource = "v1"; /// The service which this resource belongs to. private readonly Google.Apis.Services.IClientService service; /// Constructs a new resource. public V1Resource(Google.Apis.Services.IClientService service) { this.service = service; } /// /// 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. /// /// The body of the request. public virtual ProvideValidationFeedbackRequest ProvideValidationFeedback(Google.Apis.AddressValidation.v1.Data.GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest body) { return new ProvideValidationFeedbackRequest(this.service, body); } /// /// 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. /// public class ProvideValidationFeedbackRequest : AddressValidationBaseServiceRequest { /// Constructs a new ProvideValidationFeedback request. public ProvideValidationFeedbackRequest(Google.Apis.Services.IClientService service, Google.Apis.AddressValidation.v1.Data.GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest body) : base(service) { Body = body; InitParameters(); } /// Gets or sets the body of this request. Google.Apis.AddressValidation.v1.Data.GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest Body { get; set; } /// Returns the body of the request. protected override object GetBody() => Body; /// Gets the method name. public override string MethodName => "provideValidationFeedback"; /// Gets the HTTP method. public override string HttpMethod => "POST"; /// Gets the REST path. public override string RestPath => "v1:provideValidationFeedback"; /// Initializes ProvideValidationFeedback parameter list. protected override void InitParameters() { base.InitParameters(); } } /// Validates an address. /// The body of the request. public virtual ValidateAddressRequest ValidateAddress(Google.Apis.AddressValidation.v1.Data.GoogleMapsAddressvalidationV1ValidateAddressRequest body) { return new ValidateAddressRequest(this.service, body); } /// Validates an address. public class ValidateAddressRequest : AddressValidationBaseServiceRequest { /// Constructs a new ValidateAddress request. public ValidateAddressRequest(Google.Apis.Services.IClientService service, Google.Apis.AddressValidation.v1.Data.GoogleMapsAddressvalidationV1ValidateAddressRequest body) : base(service) { Body = body; InitParameters(); } /// Gets or sets the body of this request. Google.Apis.AddressValidation.v1.Data.GoogleMapsAddressvalidationV1ValidateAddressRequest Body { get; set; } /// Returns the body of the request. protected override object GetBody() => Body; /// Gets the method name. public override string MethodName => "validateAddress"; /// Gets the HTTP method. public override string HttpMethod => "POST"; /// Gets the REST path. public override string RestPath => "v1:validateAddress"; /// Initializes ValidateAddress parameter list. protected override void InitParameters() { base.InitParameters(); } } } } namespace Google.Apis.AddressValidation.v1.Data { /// /// 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 } } /// public class GoogleGeoTypeViewport : Google.Apis.Requests.IDirectResponseSchema { /// Required. The high point of the viewport. [Newtonsoft.Json.JsonPropertyAttribute("high")] public virtual GoogleTypeLatLng High { get; set; } /// Required. The low point of the viewport. [Newtonsoft.Json.JsonPropertyAttribute("low")] public virtual GoogleTypeLatLng Low { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// Details of the post-processed address. Post-processing includes correcting misspelled parts of the address, /// replacing incorrect parts, and inferring missing parts. /// public class GoogleMapsAddressvalidationV1Address : Google.Apis.Requests.IDirectResponseSchema { /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("addressComponents")] public virtual System.Collections.Generic.IList AddressComponents { get; set; } /// /// The post-processed address, formatted as a single-line address following the address formatting rules of the /// region where the address is located. Note: the format of this address may not match the format of the /// address in the `postal_address` field. For example, the `postal_address` always represents the country as a /// 2 letter `region_code`, such as "US" or "NZ". By contrast, this field uses a longer form of the country /// name, such as "USA" or "New Zealand". /// [Newtonsoft.Json.JsonPropertyAttribute("formattedAddress")] public virtual string FormattedAddress { get; set; } /// /// 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. 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). **Note: you /// might see a missing component type when you think you've already supplied the missing component.** For /// example, this can happen when the input address contains the building name, but not the premise number. In /// the address "渋谷区渋谷３丁目　Shibuya Stream", the building name "Shibuya Stream" has the component type `premise`, /// but the premise number is missing, so `missing_component_types` will contain `premise`. /// [Newtonsoft.Json.JsonPropertyAttribute("missingComponentTypes")] public virtual System.Collections.Generic.IList MissingComponentTypes { get; set; } /// The post-processed address represented as a postal address. [Newtonsoft.Json.JsonPropertyAttribute("postalAddress")] public virtual GoogleTypePostalAddress PostalAddress { get; set; } /// /// 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). /// [Newtonsoft.Json.JsonPropertyAttribute("unconfirmedComponentTypes")] public virtual System.Collections.Generic.IList UnconfirmedComponentTypes { get; set; } /// /// 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, for an input such as "Parcel 0000123123 & 0000456456 Str # /// Guthrie Center IA 50115 US", the unresolved tokens might look like `["Parcel", "0000123123", "&", /// "0000456456"]`. /// [Newtonsoft.Json.JsonPropertyAttribute("unresolvedTokens")] public virtual System.Collections.Generic.IList UnresolvedTokens { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Represents an address component, such as a street, city, or state. public class GoogleMapsAddressvalidationV1AddressComponent : Google.Apis.Requests.IDirectResponseSchema { /// The name for this component. [Newtonsoft.Json.JsonPropertyAttribute("componentName")] public virtual GoogleMapsAddressvalidationV1ComponentName ComponentName { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("componentType")] public virtual string ComponentType { get; set; } /// Indicates the level of certainty that we have that the component is correct. [Newtonsoft.Json.JsonPropertyAttribute("confirmationLevel")] public virtual string ConfirmationLevel { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("inferred")] public virtual System.Nullable Inferred { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("replaced")] public virtual System.Nullable Replaced { get; set; } /// /// 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". /// [Newtonsoft.Json.JsonPropertyAttribute("spellCorrected")] public virtual System.Nullable SpellCorrected { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("unexpected")] public virtual System.Nullable Unexpected { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// The metadata for the post-processed address. `metadata` is not guaranteed to be fully populated for every /// address sent to the Address Validation API. /// public class GoogleMapsAddressvalidationV1AddressMetadata : Google.Apis.Requests.IDirectResponseSchema { /// /// Indicates that this is the address of a business. If unset, indicates that the value is unknown. /// [Newtonsoft.Json.JsonPropertyAttribute("business")] public virtual System.Nullable Business { get; set; } /// Indicates that the address of a PO box. If unset, indicates that the value is unknown. [Newtonsoft.Json.JsonPropertyAttribute("poBox")] public virtual System.Nullable PoBox { get; set; } /// /// Indicates that this is the address of a residence. If unset, indicates that the value is unknown. /// [Newtonsoft.Json.JsonPropertyAttribute("residential")] public virtual System.Nullable Residential { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// A wrapper for the name of the component. public class GoogleMapsAddressvalidationV1ComponentName : Google.Apis.Requests.IDirectResponseSchema { /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("languageCode")] public virtual string LanguageCode { get; set; } /// The name text. For example, "5th Avenue" for a street name or "1253" for a street number. [Newtonsoft.Json.JsonPropertyAttribute("text")] public virtual string Text { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Contains information about the place the input was geocoded to. public class GoogleMapsAddressvalidationV1Geocode : Google.Apis.Requests.IDirectResponseSchema { /// The bounds of the geocoded place. [Newtonsoft.Json.JsonPropertyAttribute("bounds")] public virtual GoogleGeoTypeViewport Bounds { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("featureSizeMeters")] public virtual System.Nullable FeatureSizeMeters { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("location")] public virtual GoogleTypeLatLng Location { get; set; } /// /// 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). /// [Newtonsoft.Json.JsonPropertyAttribute("placeId")] public virtual string PlaceId { get; set; } /// /// 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). /// [Newtonsoft.Json.JsonPropertyAttribute("placeTypes")] public virtual System.Collections.Generic.IList PlaceTypes { get; set; } /// The plus code corresponding to the `location`. [Newtonsoft.Json.JsonPropertyAttribute("plusCode")] public virtual GoogleMapsAddressvalidationV1PlusCode PlusCode { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// 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. /// public class GoogleMapsAddressvalidationV1LanguageOptions : Google.Apis.Requests.IDirectResponseSchema { /// /// Preview: Return a [google.maps.addressvalidation.v1.Address] in English. See /// [google.maps.addressvalidation.v1.ValidationResult.english_latin_address] for details. /// [Newtonsoft.Json.JsonPropertyAttribute("returnEnglishLatinAddress")] public virtual System.Nullable ReturnEnglishLatinAddress { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// 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. /// public class GoogleMapsAddressvalidationV1PlusCode : Google.Apis.Requests.IDirectResponseSchema { /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("compoundCode")] public virtual string CompoundCode { get; set; } /// /// Place's global (full) code, such as "9FWM33GV+HQ", representing an 1/8000 by 1/8000 degree area (~14 by 14 /// meters). /// [Newtonsoft.Json.JsonPropertyAttribute("globalCode")] public virtual string GlobalCode { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The request for sending validation feedback. public class GoogleMapsAddressvalidationV1ProvideValidationFeedbackRequest : Google.Apis.Requests.IDirectResponseSchema { /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("conclusion")] public virtual string Conclusion { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("responseId")] public virtual string ResponseId { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// The response for validation feedback. The response is empty if the feedback is sent successfully. /// public class GoogleMapsAddressvalidationV1ProvideValidationFeedbackResponse : Google.Apis.Requests.IDirectResponseSchema { /// The ETag of the item. public virtual string ETag { get; set; } } /// USPS representation of a US address. public class GoogleMapsAddressvalidationV1UspsAddress : Google.Apis.Requests.IDirectResponseSchema { /// City name. [Newtonsoft.Json.JsonPropertyAttribute("city")] public virtual string City { get; set; } /// City + state + postal code. [Newtonsoft.Json.JsonPropertyAttribute("cityStateZipAddressLine")] public virtual string CityStateZipAddressLine { get; set; } /// Firm name. [Newtonsoft.Json.JsonPropertyAttribute("firm")] public virtual string Firm { get; set; } /// First address line. [Newtonsoft.Json.JsonPropertyAttribute("firstAddressLine")] public virtual string FirstAddressLine { get; set; } /// Second address line. [Newtonsoft.Json.JsonPropertyAttribute("secondAddressLine")] public virtual string SecondAddressLine { get; set; } /// 2 letter state code. [Newtonsoft.Json.JsonPropertyAttribute("state")] public virtual string State { get; set; } /// Puerto Rican urbanization name. [Newtonsoft.Json.JsonPropertyAttribute("urbanization")] public virtual string Urbanization { get; set; } /// Postal code e.g. 10009. [Newtonsoft.Json.JsonPropertyAttribute("zipCode")] public virtual string ZipCode { get; set; } /// 4-digit postal code extension e.g. 5023. [Newtonsoft.Json.JsonPropertyAttribute("zipCodeExtension")] public virtual string ZipCodeExtension { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// 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. /// public class GoogleMapsAddressvalidationV1UspsData : Google.Apis.Requests.IDirectResponseSchema { /// Abbreviated city. [Newtonsoft.Json.JsonPropertyAttribute("abbreviatedCity")] public virtual string AbbreviatedCity { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("addressRecordType")] public virtual string AddressRecordType { get; set; } /// /// 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 /// [Newtonsoft.Json.JsonPropertyAttribute("carrierRoute")] public virtual string CarrierRoute { get; set; } /// Carrier route rate sort indicator. [Newtonsoft.Json.JsonPropertyAttribute("carrierRouteIndicator")] public virtual string CarrierRouteIndicator { get; set; } /// Indicator that the request has been CASS processed. [Newtonsoft.Json.JsonPropertyAttribute("cassProcessed")] public virtual System.Nullable CassProcessed { get; set; } /// County name. [Newtonsoft.Json.JsonPropertyAttribute("county")] public virtual string County { get; set; } /// Indicator that a default address was found, but more specific addresses exists. [Newtonsoft.Json.JsonPropertyAttribute("defaultAddress")] public virtual System.Nullable DefaultAddress { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("deliveryPointCheckDigit")] public virtual string DeliveryPointCheckDigit { get; set; } /// 2 digit delivery point code [Newtonsoft.Json.JsonPropertyAttribute("deliveryPointCode")] public virtual string DeliveryPointCode { get; set; } /// /// 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 /// [Newtonsoft.Json.JsonPropertyAttribute("dpvCmra")] public virtual string DpvCmra { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("dpvConfirmation")] public virtual string DpvConfirmation { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("dpvDoorNotAccessible")] public virtual string DpvDoorNotAccessible { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("dpvDrop")] public virtual string DpvDrop { get; set; } /// /// 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 but 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. /// [Newtonsoft.Json.JsonPropertyAttribute("dpvEnhancedDeliveryCode")] public virtual string DpvEnhancedDeliveryCode { get; set; } /// /// 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 /// [Newtonsoft.Json.JsonPropertyAttribute("dpvFootnote")] public virtual string DpvFootnote { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("dpvNoSecureLocation")] public virtual string DpvNoSecureLocation { get; set; } /// /// 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 /// [Newtonsoft.Json.JsonPropertyAttribute("dpvNoStat")] public virtual string DpvNoStat { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("dpvNoStatReasonCode")] public virtual System.Nullable DpvNoStatReasonCode { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("dpvNonDeliveryDays")] public virtual string DpvNonDeliveryDays { get; set; } /// /// 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 /// [Newtonsoft.Json.JsonPropertyAttribute("dpvNonDeliveryDaysValues")] public virtual System.Nullable DpvNonDeliveryDaysValues { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("dpvPbsa")] public virtual string DpvPbsa { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("dpvThrowback")] public virtual string DpvThrowback { get; set; } /// /// Is this place vacant? Returns a single character. * `Y`: The address is vacant * `N`: The address is not /// vacant /// [Newtonsoft.Json.JsonPropertyAttribute("dpvVacant")] public virtual string DpvVacant { get; set; } /// eLOT Ascending/Descending Flag (A/D). [Newtonsoft.Json.JsonPropertyAttribute("elotFlag")] public virtual string ElotFlag { get; set; } /// Enhanced Line of Travel (eLOT) number. [Newtonsoft.Json.JsonPropertyAttribute("elotNumber")] public virtual string ElotNumber { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("errorMessage")] public virtual string ErrorMessage { get; set; } /// /// The delivery address is matchable, but the EWS file indicates that an exact match will be available soon. /// [Newtonsoft.Json.JsonPropertyAttribute("ewsNoMatch")] public virtual System.Nullable EwsNoMatch { get; set; } /// FIPS county code. [Newtonsoft.Json.JsonPropertyAttribute("fipsCountyCode")] public virtual string FipsCountyCode { get; set; } /// LACSLink indicator. [Newtonsoft.Json.JsonPropertyAttribute("lacsLinkIndicator")] public virtual string LacsLinkIndicator { get; set; } /// LACSLink return code. [Newtonsoft.Json.JsonPropertyAttribute("lacsLinkReturnCode")] public virtual string LacsLinkReturnCode { get; set; } /// PMB (Private Mail Box) unit designator. [Newtonsoft.Json.JsonPropertyAttribute("pmbDesignator")] public virtual string PmbDesignator { get; set; } /// PMB (Private Mail Box) number; [Newtonsoft.Json.JsonPropertyAttribute("pmbNumber")] public virtual string PmbNumber { get; set; } /// PO Box only postal code. [Newtonsoft.Json.JsonPropertyAttribute("poBoxOnlyPostalCode")] public virtual System.Nullable PoBoxOnlyPostalCode { get; set; } /// Main post office city. [Newtonsoft.Json.JsonPropertyAttribute("postOfficeCity")] public virtual string PostOfficeCity { get; set; } /// Main post office state. [Newtonsoft.Json.JsonPropertyAttribute("postOfficeState")] public virtual string PostOfficeState { get; set; } /// USPS standardized address. [Newtonsoft.Json.JsonPropertyAttribute("standardizedAddress")] public virtual GoogleMapsAddressvalidationV1UspsAddress StandardizedAddress { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("suitelinkFootnote")] public virtual string SuitelinkFootnote { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The request for validating an address. public class GoogleMapsAddressvalidationV1ValidateAddressRequest : Google.Apis.Requests.IDirectResponseSchema { /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("address")] public virtual GoogleTypePostalAddress Address { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("enableUspsCass")] public virtual System.Nullable EnableUspsCass { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("languageOptions")] public virtual GoogleMapsAddressvalidationV1LanguageOptions LanguageOptions { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("previousResponseId")] public virtual string PreviousResponseId { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("sessionToken")] public virtual string SessionToken { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The response to an address validation request. public class GoogleMapsAddressvalidationV1ValidateAddressResponse : Google.Apis.Requests.IDirectResponseSchema { /// /// The UUID that identifies this response. If the address needs to be re-validated, this UUID *must* accompany /// the new request. /// [Newtonsoft.Json.JsonPropertyAttribute("responseId")] public virtual string ResponseId { get; set; } /// The result of the address validation. [Newtonsoft.Json.JsonPropertyAttribute("result")] public virtual GoogleMapsAddressvalidationV1ValidationResult Result { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The result of validating an address. public class GoogleMapsAddressvalidationV1ValidationResult : Google.Apis.Requests.IDirectResponseSchema { /// Information about the address itself as opposed to the geocode. [Newtonsoft.Json.JsonPropertyAttribute("address")] public virtual GoogleMapsAddressvalidationV1Address Address { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("englishLatinAddress")] public virtual GoogleMapsAddressvalidationV1Address EnglishLatinAddress { get; set; } /// Information about the location and place that the address geocoded to. [Newtonsoft.Json.JsonPropertyAttribute("geocode")] public virtual GoogleMapsAddressvalidationV1Geocode Geocode { get; set; } /// /// Other information relevant to deliverability. `metadata` is not guaranteed to be fully populated for every /// address sent to the Address Validation API. /// [Newtonsoft.Json.JsonPropertyAttribute("metadata")] public virtual GoogleMapsAddressvalidationV1AddressMetadata Metadata { get; set; } /// Extra deliverability flags provided by USPS. Only provided in region `US` and `PR`. [Newtonsoft.Json.JsonPropertyAttribute("uspsData")] public virtual GoogleMapsAddressvalidationV1UspsData UspsData { get; set; } /// Overall verdict flags [Newtonsoft.Json.JsonPropertyAttribute("verdict")] public virtual GoogleMapsAddressvalidationV1Verdict Verdict { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// High level overview of the address validation result and geocode. public class GoogleMapsAddressvalidationV1Verdict : Google.Apis.Requests.IDirectResponseSchema { /// /// The post-processed 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. /// [Newtonsoft.Json.JsonPropertyAttribute("addressComplete")] public virtual System.Nullable AddressComplete { get; set; } /// /// 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`. /// [Newtonsoft.Json.JsonPropertyAttribute("geocodeGranularity")] public virtual string GeocodeGranularity { get; set; } /// /// At least one address component was inferred (added) that wasn't in the input, see /// [google.maps.addressvalidation.v1.Address.address_components] for details. /// [Newtonsoft.Json.JsonPropertyAttribute("hasInferredComponents")] public virtual System.Nullable HasInferredComponents { get; set; } /// /// At least one address component was replaced, see /// [google.maps.addressvalidation.v1.Address.address_components] for details. /// [Newtonsoft.Json.JsonPropertyAttribute("hasReplacedComponents")] public virtual System.Nullable HasReplacedComponents { get; set; } /// /// At least one address component was spell-corrected, see /// [google.maps.addressvalidation.v1.Address.address_components] for details. /// [Newtonsoft.Json.JsonPropertyAttribute("hasSpellCorrectedComponents")] public virtual System.Nullable HasSpellCorrectedComponents { get; set; } /// /// At least one address component cannot be categorized or validated, see /// [google.maps.addressvalidation.v1.Address.address_components] for details. /// [Newtonsoft.Json.JsonPropertyAttribute("hasUnconfirmedComponents")] public virtual System.Nullable HasUnconfirmedComponents { get; set; } /// /// 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 the address validation service cannot match the apartment number in the databases or the apartment number /// is invalid, the `validation_granularity` will likely be `PREMISE` or more coarse. /// [Newtonsoft.Json.JsonPropertyAttribute("inputGranularity")] public virtual string InputGranularity { get; set; } /// /// 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). Offers an interpretive /// summary of the API response, intended to assist in determining a potential subsequent action to take. This /// field is derived from other fields in the API response and should not be considered as a guarantee of /// address accuracy or deliverability. See [Build your validation /// logic](https://developers.google.com/maps/documentation/address-validation/build-validation-logic) for more /// details. /// [Newtonsoft.Json.JsonPropertyAttribute("possibleNextAction")] public virtual string PossibleNextAction { get; set; } /// /// The level of granularity for the post-processed address that the API can fully validate. For example, a /// `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]. /// [Newtonsoft.Json.JsonPropertyAttribute("validationGranularity")] public virtual string ValidationGranularity { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// 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. /// public class GoogleTypeLatLng : Google.Apis.Requests.IDirectResponseSchema { /// The latitude in degrees. It must be in the range [-90.0, +90.0]. [Newtonsoft.Json.JsonPropertyAttribute("latitude")] public virtual System.Nullable Latitude { get; set; } /// The longitude in degrees. It must be in the range [-180.0, +180.0]. [Newtonsoft.Json.JsonPropertyAttribute("longitude")] public virtual System.Nullable Longitude { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// Represents a postal address, such as for postal delivery or payments addresses. With a postal address, a postal /// service can deliver items to a premise, P.O. box, or similar. A postal address is not intended to model /// geographical locations like roads, towns, or mountains. In typical usage, an address would be created by user /// input or from importing existing data, depending on the type of process. Advice on address input or 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, see: https://support.google.com/business/answer/6397478. /// public class GoogleTypePostalAddress : Google.Apis.Requests.IDirectResponseSchema { /// /// 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 (for example, "Austin, /// TX"), it is important that the line order is clear. The order of address lines should be "envelope order" /// for the country or region of the address. In places where this can vary (for example, Japan), /// `address_language` is used to make it explicit (for example, "ja" for large-to-small ordering and "ja-Latn" /// or "en" for small-to-large). In 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). /// [Newtonsoft.Json.JsonPropertyAttribute("addressLines")] public virtual System.Collections.Generic.IList AddressLines { get; set; } /// /// 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. For Spain, this is the province and /// not the autonomous community (for example, "Barcelona" and not "Catalonia"). Many countries don't use an /// administrative area in postal addresses. For example, in Switzerland, this should be left unpopulated. /// [Newtonsoft.Json.JsonPropertyAttribute("administrativeArea")] public virtual string AdministrativeArea { get; set; } /// /// 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". /// [Newtonsoft.Json.JsonPropertyAttribute("languageCode")] public virtual string LanguageCode { get; set; } /// /// Optional. Generally refers to the city or 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`. /// [Newtonsoft.Json.JsonPropertyAttribute("locality")] public virtual string Locality { get; set; } /// Optional. The name of the organization at the address. [Newtonsoft.Json.JsonPropertyAttribute("organization")] public virtual string Organization { get; set; } /// /// 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 (for example, state or /// zip code validation in the United States). /// [Newtonsoft.Json.JsonPropertyAttribute("postalCode")] public virtual string PostalCode { get; set; } /// /// Optional. The recipient at the address. This field may, under certain circumstances, contain multiline /// information. For example, it might contain "care of" information. /// [Newtonsoft.Json.JsonPropertyAttribute("recipients")] public virtual System.Collections.Generic.IList Recipients { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("regionCode")] public virtual string RegionCode { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("revision")] public virtual System.Nullable Revision { get; set; } /// /// 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 (for example, "CEDEX 7"), or just /// a number alone, representing the "sector code" (Jamaica), "delivery area indicator" (Malawi) or "post office /// indicator" (Côte d'Ivoire). /// [Newtonsoft.Json.JsonPropertyAttribute("sortingCode")] public virtual string SortingCode { get; set; } /// /// Optional. Sublocality of the address. For example, this can be a neighborhood, borough, or district. /// [Newtonsoft.Json.JsonPropertyAttribute("sublocality")] public virtual string Sublocality { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } }