@0xkaleab/sdk-js 0.2.7

package/dist/types/codegen/google/type/phone_number.d.ts

@@ -0,0 +1,291 @@
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
+/**
+ * An object representing a phone number, suitable as an API wire format.
+ *
+ * This representation:
+ *
+ *  - should not be used for locale-specific formatting of a phone number, such
+ *    as "+1 (650) 253-0000 ext. 123"
+ *
+ *  - is not designed for efficient storage
+ *  - may not be suitable for dialing - specialized libraries (see references)
+ *    should be used to parse the number for that purpose
+ *
+ * To do something meaningful with this number, such as format it for various
+ * use-cases, convert it to an `i18n.phonenumbers.PhoneNumber` object first.
+ *
+ * For instance, in Java this would be:
+ *
+ *    com.google.type.PhoneNumber wireProto =
+ *        com.google.type.PhoneNumber.newBuilder().build();
+ *    com.google.i18n.phonenumbers.Phonenumber.PhoneNumber phoneNumber =
+ *        PhoneNumberUtil.getInstance().parse(wireProto.getE164Number(), "ZZ");
+ *    if (!wireProto.getExtension().isEmpty()) {
+ *      phoneNumber.setExtension(wireProto.getExtension());
+ *    }
+ *
+ *  Reference(s):
+ *   - https://github.com/google/libphonenumber
+ * @name PhoneNumber
+ * @package google.type
+ * @see proto type: google.type.PhoneNumber
+ */
+export interface PhoneNumber {
+    /**
+     * The phone number, represented as a leading plus sign ('+'), followed by a
+     * phone number that uses a relaxed ITU E.164 format consisting of the
+     * country calling code (1 to 3 digits) and the subscriber number, with no
+     * additional spaces or formatting, e.g.:
+     *  - correct: "+15552220123"
+     *  - incorrect: "+1 (555) 222-01234 x123".
+     *
+     * The ITU E.164 format limits the latter to 12 digits, but in practice not
+     * all countries respect that, so we relax that restriction here.
+     * National-only numbers are not allowed.
+     *
+     * References:
+     *  - https://www.itu.int/rec/T-REC-E.164-201011-I
+     *  - https://en.wikipedia.org/wiki/E.164.
+     *  - https://en.wikipedia.org/wiki/List_of_country_calling_codes
+     */
+    e164Number?: string;
+    /**
+     * A short code.
+     *
+     * Reference(s):
+     *  - https://en.wikipedia.org/wiki/Short_code
+     */
+    shortCode?: PhoneNumber_ShortCode;
+    /**
+     * The phone number's extension. The extension is not standardized in ITU
+     * recommendations, except for being defined as a series of numbers with a
+     * maximum length of 40 digits. Other than digits, some other dialing
+     * characters such as ',' (indicating a wait) or '#' may be stored here.
+     *
+     * Note that no regions currently use extensions with short codes, so this
+     * field is normally only set in conjunction with an E.164 number. It is held
+     * separately from the E.164 number to allow for short code extensions in the
+     * future.
+     */
+    extension: string;
+}
+export interface PhoneNumberProtoMsg {
+    typeUrl: "/google.type.PhoneNumber";
+    value: Uint8Array;
+}
+/**
+ * An object representing a phone number, suitable as an API wire format.
+ *
+ * This representation:
+ *
+ *  - should not be used for locale-specific formatting of a phone number, such
+ *    as "+1 (650) 253-0000 ext. 123"
+ *
+ *  - is not designed for efficient storage
+ *  - may not be suitable for dialing - specialized libraries (see references)
+ *    should be used to parse the number for that purpose
+ *
+ * To do something meaningful with this number, such as format it for various
+ * use-cases, convert it to an `i18n.phonenumbers.PhoneNumber` object first.
+ *
+ * For instance, in Java this would be:
+ *
+ *    com.google.type.PhoneNumber wireProto =
+ *        com.google.type.PhoneNumber.newBuilder().build();
+ *    com.google.i18n.phonenumbers.Phonenumber.PhoneNumber phoneNumber =
+ *        PhoneNumberUtil.getInstance().parse(wireProto.getE164Number(), "ZZ");
+ *    if (!wireProto.getExtension().isEmpty()) {
+ *      phoneNumber.setExtension(wireProto.getExtension());
+ *    }
+ *
+ *  Reference(s):
+ *   - https://github.com/google/libphonenumber
+ * @name PhoneNumberAmino
+ * @package google.type
+ * @see proto type: google.type.PhoneNumber
+ */
+export interface PhoneNumberAmino {
+    /**
+     * The phone number, represented as a leading plus sign ('+'), followed by a
+     * phone number that uses a relaxed ITU E.164 format consisting of the
+     * country calling code (1 to 3 digits) and the subscriber number, with no
+     * additional spaces or formatting, e.g.:
+     *  - correct: "+15552220123"
+     *  - incorrect: "+1 (555) 222-01234 x123".
+     *
+     * The ITU E.164 format limits the latter to 12 digits, but in practice not
+     * all countries respect that, so we relax that restriction here.
+     * National-only numbers are not allowed.
+     *
+     * References:
+     *  - https://www.itu.int/rec/T-REC-E.164-201011-I
+     *  - https://en.wikipedia.org/wiki/E.164.
+     *  - https://en.wikipedia.org/wiki/List_of_country_calling_codes
+     */
+    e164_number?: string;
+    /**
+     * A short code.
+     *
+     * Reference(s):
+     *  - https://en.wikipedia.org/wiki/Short_code
+     */
+    short_code?: PhoneNumber_ShortCodeAmino;
+    /**
+     * The phone number's extension. The extension is not standardized in ITU
+     * recommendations, except for being defined as a series of numbers with a
+     * maximum length of 40 digits. Other than digits, some other dialing
+     * characters such as ',' (indicating a wait) or '#' may be stored here.
+     *
+     * Note that no regions currently use extensions with short codes, so this
+     * field is normally only set in conjunction with an E.164 number. It is held
+     * separately from the E.164 number to allow for short code extensions in the
+     * future.
+     */
+    extension: string;
+}
+export interface PhoneNumberAminoMsg {
+    type: "/google.type.PhoneNumber";
+    value: PhoneNumberAmino;
+}
+/**
+ * An object representing a short code, which is a phone number that is
+ * typically much shorter than regular phone numbers and can be used to
+ * address messages in MMS and SMS systems, as well as for abbreviated dialing
+ * (e.g. "Text 611 to see how many minutes you have remaining on your plan.").
+ *
+ * Short codes are restricted to a region and are not internationally
+ * dialable, which means the same short code can exist in different regions,
+ * with different usage and pricing, even if those regions share the same
+ * country calling code (e.g. US and CA).
+ * @name PhoneNumber_ShortCode
+ * @package google.type
+ * @see proto type: google.type.ShortCode
+ */
+export interface PhoneNumber_ShortCode {
+    /**
+     * Required. The BCP-47 region code of the location where calls to this
+     * short code can be made, such as "US" and "BB".
+     *
+     * Reference(s):
+     *  - http://www.unicode.org/reports/tr35/#unicode_region_subtag
+     */
+    regionCode: string;
+    /**
+     * Required. The short code digits, without a leading plus ('+') or country
+     * calling code, e.g. "611".
+     */
+    number: string;
+}
+export interface PhoneNumber_ShortCodeProtoMsg {
+    typeUrl: "/google.type.ShortCode";
+    value: Uint8Array;
+}
+/**
+ * An object representing a short code, which is a phone number that is
+ * typically much shorter than regular phone numbers and can be used to
+ * address messages in MMS and SMS systems, as well as for abbreviated dialing
+ * (e.g. "Text 611 to see how many minutes you have remaining on your plan.").
+ *
+ * Short codes are restricted to a region and are not internationally
+ * dialable, which means the same short code can exist in different regions,
+ * with different usage and pricing, even if those regions share the same
+ * country calling code (e.g. US and CA).
+ * @name PhoneNumber_ShortCodeAmino
+ * @package google.type
+ * @see proto type: google.type.PhoneNumber_ShortCode
+ */
+export interface PhoneNumber_ShortCodeAmino {
+    /**
+     * Required. The BCP-47 region code of the location where calls to this
+     * short code can be made, such as "US" and "BB".
+     *
+     * Reference(s):
+     *  - http://www.unicode.org/reports/tr35/#unicode_region_subtag
+     */
+    region_code: string;
+    /**
+     * Required. The short code digits, without a leading plus ('+') or country
+     * calling code, e.g. "611".
+     */
+    number: string;
+}
+export interface PhoneNumber_ShortCodeAminoMsg {
+    type: "/google.type.ShortCode";
+    value: PhoneNumber_ShortCodeAmino;
+}
+/**
+ * An object representing a phone number, suitable as an API wire format.
+ *
+ * This representation:
+ *
+ *  - should not be used for locale-specific formatting of a phone number, such
+ *    as "+1 (650) 253-0000 ext. 123"
+ *
+ *  - is not designed for efficient storage
+ *  - may not be suitable for dialing - specialized libraries (see references)
+ *    should be used to parse the number for that purpose
+ *
+ * To do something meaningful with this number, such as format it for various
+ * use-cases, convert it to an `i18n.phonenumbers.PhoneNumber` object first.
+ *
+ * For instance, in Java this would be:
+ *
+ *    com.google.type.PhoneNumber wireProto =
+ *        com.google.type.PhoneNumber.newBuilder().build();
+ *    com.google.i18n.phonenumbers.Phonenumber.PhoneNumber phoneNumber =
+ *        PhoneNumberUtil.getInstance().parse(wireProto.getE164Number(), "ZZ");
+ *    if (!wireProto.getExtension().isEmpty()) {
+ *      phoneNumber.setExtension(wireProto.getExtension());
+ *    }
+ *
+ *  Reference(s):
+ *   - https://github.com/google/libphonenumber
+ * @name PhoneNumber
+ * @package google.type
+ * @see proto type: google.type.PhoneNumber
+ */
+export declare const PhoneNumber: {
+    typeUrl: string;
+    is(o: any): o is PhoneNumber;
+    isAmino(o: any): o is PhoneNumberAmino;
+    encode(message: PhoneNumber, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PhoneNumber;
+    fromPartial(object: DeepPartial<PhoneNumber>): PhoneNumber;
+    fromAmino(object: PhoneNumberAmino): PhoneNumber;
+    toAmino(message: PhoneNumber): PhoneNumberAmino;
+    fromAminoMsg(object: PhoneNumberAminoMsg): PhoneNumber;
+    fromProtoMsg(message: PhoneNumberProtoMsg): PhoneNumber;
+    toProto(message: PhoneNumber): Uint8Array;
+    toProtoMsg(message: PhoneNumber): PhoneNumberProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * An object representing a short code, which is a phone number that is
+ * typically much shorter than regular phone numbers and can be used to
+ * address messages in MMS and SMS systems, as well as for abbreviated dialing
+ * (e.g. "Text 611 to see how many minutes you have remaining on your plan.").
+ *
+ * Short codes are restricted to a region and are not internationally
+ * dialable, which means the same short code can exist in different regions,
+ * with different usage and pricing, even if those regions share the same
+ * country calling code (e.g. US and CA).
+ * @name PhoneNumber_ShortCode
+ * @package google.type
+ * @see proto type: google.type.ShortCode
+ */
+export declare const PhoneNumber_ShortCode: {
+    typeUrl: string;
+    is(o: any): o is PhoneNumber_ShortCode;
+    isAmino(o: any): o is PhoneNumber_ShortCodeAmino;
+    encode(message: PhoneNumber_ShortCode, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PhoneNumber_ShortCode;
+    fromPartial(object: DeepPartial<PhoneNumber_ShortCode>): PhoneNumber_ShortCode;
+    fromAmino(object: PhoneNumber_ShortCodeAmino): PhoneNumber_ShortCode;
+    toAmino(message: PhoneNumber_ShortCode): PhoneNumber_ShortCodeAmino;
+    fromAminoMsg(object: PhoneNumber_ShortCodeAminoMsg): PhoneNumber_ShortCode;
+    fromProtoMsg(message: PhoneNumber_ShortCodeProtoMsg): PhoneNumber_ShortCode;
+    toProto(message: PhoneNumber_ShortCode): Uint8Array;
+    toProtoMsg(message: PhoneNumber_ShortCode): PhoneNumber_ShortCodeProtoMsg;
+    registerTypeUrl(): void;
+};

package/dist/types/codegen/google/type/postal_address.d.ts

@@ -0,0 +1,299 @@
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
+/**
+ * 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 i18n-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
+ * @name PostalAddress
+ * @package google.type
+ * @see proto type: google.type.PostalAddress
+ */
+export interface PostalAddress {
+    /**
+     * 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: number;
+    /**
+     * 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 http://cldr.unicode.org/ and
+     * http://www.unicode.org/cldr/charts/30/supplemental/territory_information.html
+     * for details. Example: "CH" for Switzerland.
+     */
+    regionCode: string;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Optional. Sublocality of the address.
+     * For example, this can be neighborhoods, boroughs, districts.
+     */
+    sublocality: string;
+    /**
+     * 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[];
+    /**
+     * 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[];
+    /**
+     * Optional. The name of the organization at the address.
+     */
+    organization: string;
+}
+export interface PostalAddressProtoMsg {
+    typeUrl: "/google.type.PostalAddress";
+    value: Uint8Array;
+}
+/**
+ * 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 i18n-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
+ * @name PostalAddressAmino
+ * @package google.type
+ * @see proto type: google.type.PostalAddress
+ */
+export interface PostalAddressAmino {
+    /**
+     * 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: number;
+    /**
+     * 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 http://cldr.unicode.org/ and
+     * http://www.unicode.org/cldr/charts/30/supplemental/territory_information.html
+     * for details. Example: "CH" for Switzerland.
+     */
+    region_code: string;
+    /**
+     * 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".
+     */
+    language_code: string;
+    /**
+     * 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.).
+     */
+    postal_code: string;
+    /**
+     * 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).
+     */
+    sorting_code: string;
+    /**
+     * 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.
+     */
+    administrative_area: string;
+    /**
+     * 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;
+    /**
+     * Optional. Sublocality of the address.
+     * For example, this can be neighborhoods, boroughs, districts.
+     */
+    sublocality: string;
+    /**
+     * 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).
+     */
+    address_lines: string[];
+    /**
+     * 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[];
+    /**
+     * Optional. The name of the organization at the address.
+     */
+    organization: string;
+}
+export interface PostalAddressAminoMsg {
+    type: "/google.type.PostalAddress";
+    value: PostalAddressAmino;
+}
+/**
+ * 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 i18n-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
+ * @name PostalAddress
+ * @package google.type
+ * @see proto type: google.type.PostalAddress
+ */
+export declare const PostalAddress: {
+    typeUrl: string;
+    is(o: any): o is PostalAddress;
+    isAmino(o: any): o is PostalAddressAmino;
+    encode(message: PostalAddress, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PostalAddress;
+    fromPartial(object: DeepPartial<PostalAddress>): PostalAddress;
+    fromAmino(object: PostalAddressAmino): PostalAddress;
+    toAmino(message: PostalAddress): PostalAddressAmino;
+    fromAminoMsg(object: PostalAddressAminoMsg): PostalAddress;
+    fromProtoMsg(message: PostalAddressProtoMsg): PostalAddress;
+    toProto(message: PostalAddress): Uint8Array;
+    toProtoMsg(message: PostalAddress): PostalAddressProtoMsg;
+    registerTypeUrl(): void;
+};