// @generated by protoc-gen-es v1.10.1 with parameter "target=ts"
// @generated from file geo-identifier/v1/models.proto (package geoidentifier.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";

/**
 * @generated from message geoidentifier.v1.Country
 */
export class Country extends Message<Country> {
  /**
   * @generated from field: string name = 1;
   */
  name = "";

  /**
   * @generated from field: string country_code = 2;
   */
  countryCode = "";

  constructor(data?: PartialMessage<Country>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.Country";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "country_code", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Country {
    return new Country().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Country {
    return new Country().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Country {
    return new Country().fromJsonString(jsonString, options);
  }

  static equals(a: Country | PlainMessage<Country> | undefined, b: Country | PlainMessage<Country> | undefined): boolean {
    return proto3.util.equals(Country, a, b);
  }
}

/**
 * @generated from message geoidentifier.v1.Region
 */
export class Region extends Message<Region> {
  /**
   * @generated from field: string name = 1;
   */
  name = "";

  /**
   * @generated from field: string code = 2;
   */
  code = "";

  /**
   * @generated from field: string country_code = 3;
   */
  countryCode = "";

  constructor(data?: PartialMessage<Region>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.Region";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "code", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "country_code", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Region {
    return new Region().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Region {
    return new Region().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Region {
    return new Region().fromJsonString(jsonString, options);
  }

  static equals(a: Region | PlainMessage<Region> | undefined, b: Region | PlainMessage<Region> | undefined): boolean {
    return proto3.util.equals(Region, a, b);
  }
}

/**
 * @generated from message geoidentifier.v1.GetCountriesRequest
 */
export class GetCountriesRequest extends Message<GetCountriesRequest> {
  constructor(data?: PartialMessage<GetCountriesRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.GetCountriesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetCountriesRequest {
    return new GetCountriesRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetCountriesRequest {
    return new GetCountriesRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetCountriesRequest {
    return new GetCountriesRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetCountriesRequest | PlainMessage<GetCountriesRequest> | undefined, b: GetCountriesRequest | PlainMessage<GetCountriesRequest> | undefined): boolean {
    return proto3.util.equals(GetCountriesRequest, a, b);
  }
}

/**
 * @generated from message geoidentifier.v1.GetCountriesResponse
 */
export class GetCountriesResponse extends Message<GetCountriesResponse> {
  /**
   * @generated from field: repeated geoidentifier.v1.Country countries = 1;
   */
  countries: Country[] = [];

  constructor(data?: PartialMessage<GetCountriesResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.GetCountriesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "countries", kind: "message", T: Country, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetCountriesResponse {
    return new GetCountriesResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetCountriesResponse {
    return new GetCountriesResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetCountriesResponse {
    return new GetCountriesResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetCountriesResponse | PlainMessage<GetCountriesResponse> | undefined, b: GetCountriesResponse | PlainMessage<GetCountriesResponse> | undefined): boolean {
    return proto3.util.equals(GetCountriesResponse, a, b);
  }
}

/**
 * @generated from message geoidentifier.v1.GetCountryRegionsRequest
 */
export class GetCountryRegionsRequest extends Message<GetCountryRegionsRequest> {
  /**
   * @generated from field: string country_code = 1;
   */
  countryCode = "";

  constructor(data?: PartialMessage<GetCountryRegionsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.GetCountryRegionsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "country_code", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetCountryRegionsRequest {
    return new GetCountryRegionsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetCountryRegionsRequest {
    return new GetCountryRegionsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetCountryRegionsRequest {
    return new GetCountryRegionsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetCountryRegionsRequest | PlainMessage<GetCountryRegionsRequest> | undefined, b: GetCountryRegionsRequest | PlainMessage<GetCountryRegionsRequest> | undefined): boolean {
    return proto3.util.equals(GetCountryRegionsRequest, a, b);
  }
}

/**
 * @generated from message geoidentifier.v1.GetCountryRegionsResponse
 */
export class GetCountryRegionsResponse extends Message<GetCountryRegionsResponse> {
  /**
   * @generated from field: repeated geoidentifier.v1.Region regions = 1;
   */
  regions: Region[] = [];

  constructor(data?: PartialMessage<GetCountryRegionsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.GetCountryRegionsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "regions", kind: "message", T: Region, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetCountryRegionsResponse {
    return new GetCountryRegionsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetCountryRegionsResponse {
    return new GetCountryRegionsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetCountryRegionsResponse {
    return new GetCountryRegionsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetCountryRegionsResponse | PlainMessage<GetCountryRegionsResponse> | undefined, b: GetCountryRegionsResponse | PlainMessage<GetCountryRegionsResponse> | undefined): boolean {
    return proto3.util.equals(GetCountryRegionsResponse, a, b);
  }
}

/**
 * @generated from message geoidentifier.v1.GetAvailableTimezonesRequest
 */
export class GetAvailableTimezonesRequest extends Message<GetAvailableTimezonesRequest> {
  constructor(data?: PartialMessage<GetAvailableTimezonesRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.GetAvailableTimezonesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAvailableTimezonesRequest {
    return new GetAvailableTimezonesRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAvailableTimezonesRequest {
    return new GetAvailableTimezonesRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAvailableTimezonesRequest {
    return new GetAvailableTimezonesRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetAvailableTimezonesRequest | PlainMessage<GetAvailableTimezonesRequest> | undefined, b: GetAvailableTimezonesRequest | PlainMessage<GetAvailableTimezonesRequest> | undefined): boolean {
    return proto3.util.equals(GetAvailableTimezonesRequest, a, b);
  }
}

/**
 * @generated from message geoidentifier.v1.GetAvailableTimezonesResponse
 */
export class GetAvailableTimezonesResponse extends Message<GetAvailableTimezonesResponse> {
  /**
   * @generated from field: repeated string timezones = 1;
   */
  timezones: string[] = [];

  constructor(data?: PartialMessage<GetAvailableTimezonesResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.GetAvailableTimezonesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "timezones", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAvailableTimezonesResponse {
    return new GetAvailableTimezonesResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAvailableTimezonesResponse {
    return new GetAvailableTimezonesResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAvailableTimezonesResponse {
    return new GetAvailableTimezonesResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetAvailableTimezonesResponse | PlainMessage<GetAvailableTimezonesResponse> | undefined, b: GetAvailableTimezonesResponse | PlainMessage<GetAvailableTimezonesResponse> | undefined): boolean {
    return proto3.util.equals(GetAvailableTimezonesResponse, a, b);
  }
}

/**
 * @generated from message geoidentifier.v1.GetAvailableTimezonesWithOffsetRequest
 */
export class GetAvailableTimezonesWithOffsetRequest extends Message<GetAvailableTimezonesWithOffsetRequest> {
  /**
   * @generated from field: int32 offset = 1;
   */
  offset = 0;

  constructor(data?: PartialMessage<GetAvailableTimezonesWithOffsetRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.GetAvailableTimezonesWithOffsetRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "offset", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAvailableTimezonesWithOffsetRequest {
    return new GetAvailableTimezonesWithOffsetRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAvailableTimezonesWithOffsetRequest {
    return new GetAvailableTimezonesWithOffsetRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAvailableTimezonesWithOffsetRequest {
    return new GetAvailableTimezonesWithOffsetRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetAvailableTimezonesWithOffsetRequest | PlainMessage<GetAvailableTimezonesWithOffsetRequest> | undefined, b: GetAvailableTimezonesWithOffsetRequest | PlainMessage<GetAvailableTimezonesWithOffsetRequest> | undefined): boolean {
    return proto3.util.equals(GetAvailableTimezonesWithOffsetRequest, a, b);
  }
}

/**
 * @generated from message geoidentifier.v1.GetAvailableTimezonesWithOffsetResponse
 */
export class GetAvailableTimezonesWithOffsetResponse extends Message<GetAvailableTimezonesWithOffsetResponse> {
  /**
   * @generated from field: repeated string timezones = 1;
   */
  timezones: string[] = [];

  constructor(data?: PartialMessage<GetAvailableTimezonesWithOffsetResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.GetAvailableTimezonesWithOffsetResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "timezones", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAvailableTimezonesWithOffsetResponse {
    return new GetAvailableTimezonesWithOffsetResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAvailableTimezonesWithOffsetResponse {
    return new GetAvailableTimezonesWithOffsetResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAvailableTimezonesWithOffsetResponse {
    return new GetAvailableTimezonesWithOffsetResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetAvailableTimezonesWithOffsetResponse | PlainMessage<GetAvailableTimezonesWithOffsetResponse> | undefined, b: GetAvailableTimezonesWithOffsetResponse | PlainMessage<GetAvailableTimezonesWithOffsetResponse> | undefined): boolean {
    return proto3.util.equals(GetAvailableTimezonesWithOffsetResponse, a, b);
  }
}

/**
 * @generated from message geoidentifier.v1.PredictTimezoneRequest
 */
export class PredictTimezoneRequest extends Message<PredictTimezoneRequest> {
  /**
   * @generated from field: string query = 1;
   */
  query = "";

  constructor(data?: PartialMessage<PredictTimezoneRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.PredictTimezoneRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "query", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PredictTimezoneRequest {
    return new PredictTimezoneRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PredictTimezoneRequest {
    return new PredictTimezoneRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PredictTimezoneRequest {
    return new PredictTimezoneRequest().fromJsonString(jsonString, options);
  }

  static equals(a: PredictTimezoneRequest | PlainMessage<PredictTimezoneRequest> | undefined, b: PredictTimezoneRequest | PlainMessage<PredictTimezoneRequest> | undefined): boolean {
    return proto3.util.equals(PredictTimezoneRequest, a, b);
  }
}

/**
 * @generated from message geoidentifier.v1.PredictTimezoneResponse
 */
export class PredictTimezoneResponse extends Message<PredictTimezoneResponse> {
  /**
   * @generated from field: string timezone = 1;
   */
  timezone = "";

  constructor(data?: PartialMessage<PredictTimezoneResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "geoidentifier.v1.PredictTimezoneResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "timezone", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PredictTimezoneResponse {
    return new PredictTimezoneResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PredictTimezoneResponse {
    return new PredictTimezoneResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PredictTimezoneResponse {
    return new PredictTimezoneResponse().fromJsonString(jsonString, options);
  }

  static equals(a: PredictTimezoneResponse | PlainMessage<PredictTimezoneResponse> | undefined, b: PredictTimezoneResponse | PlainMessage<PredictTimezoneResponse> | undefined): boolean {
    return proto3.util.equals(PredictTimezoneResponse, a, b);
  }
}