types

type Money struct {

	// The three-letter currency code defined in ISO 4217.
	CurrencyCode string `datastore:"currencyCode,omitempty" json:"currencyCode,omitempty"`

	// The whole units of the amount.
	// For example if `currencyCode` is `"USD"`, then 1 unit is one US dollar.
	Units int64 `datastore:"units,omitempty" json:"units,omitempty"`

	// Number of nano (10^-9) units of the amount.
	// The value must be between -999,999,999 and +999,999,999 inclusive.
	// If `units` is positive, `nanos` must be positive or zero.
	// If `units` is zero, `nanos` can be positive, zero, or negative.
	// If `units` is negative, `nanos` must be negative or zero.
	// For example $-1.75 is represented as `units`=-1 and `nanos`=-750,000,000.
	Nanos int32 `datastore:"nanos,omitempty" json:"nanos,omitempty"`
}

type Order struct {
	// A UUID ID in hexadecimal string form - a unique ID for this order.
	Id string `datastore:"id,noindex" json:"id,omitempty"`

	// SubmissionTime is the time at which cart checkout was completed and the order was submitted for payment
	SubmissionTime Timestamp `datastore:"submissionTime" json:"submissionTime"`

	// Status describes the overall status of the order, summarizing or
	// overriding the status of the individual order items.
	Status OrderStatus `datastore:"status" json:"status"`

	// OrderedBy identifies the person who submitted the order
	OrderedBy *Person `datastore:"orderedBy" json:"orderedBy"`

	// DeliveryAddress is the postal address to which any physical items in the order
	// are to be delivered.
	//
	// NOTE: delivery address is stored as a separate entity in the Google Datastore with
	// the order key as their key ancestor.
	DeliveryAddress *PostalAddress `datastore:"-" json:"deliveryAddress"`

	// OrderItems is the list of one to many items that make up the order.
	//
	// NOTE: order items are stored as separate entities in the Google Datastore with
	// the order key as their key ancestor.
	OrderItems []*OrderItem `datastore:"-" json:"orderItems"`
}

type OrderItem struct {
	// Id is a UUID ID in hexadecimal string form - a unique ID for this order item.
	Id string `datastore:"id,noindex" json:"id,omitempty"`

	// OrderId UUID ID in hexadecimal string form - a unique ID for this item's parent order
	OrderId string `datastore:"orderId,noindex" json:"orderId,omitempty"`

	// ProductCode is the equivalent of a SKU code identifying the type of
	// product or service being ordered.
	ProductCode string `datastore:"productCode" json:"productCode"`

	// Quantity is the number of this item type that is being ordered.
	Quantity int32 `datastore:"quantity" json:"quantity"`

	// UnitPrice is the price that the customer was shown for a single item
	// when they selected the item for their cart
	UnitPrice money.Money `datastore:"unitPrice" json:"unitPrice"`

	// The fulfillment state of the oder item as an enumerated value
	Status OrderItemStatus `datastore:"status" json:"status"`
}

type OrderItemStatus int

type OrderStatus int

type Person struct {
	Id               string `datastore:"id,omitempty" json:"id,omitempty"`
	FamilyName       string `datastore:"familyName,omitempty" json:"familyName,omitempty"`
	GivenName        string `datastore:"givenName,omitempty" json:"givenName,omitempty"`
	MiddleName       string `datastore:"middleName,omitempty" json:"middleName,omitempty"`
	DisplayName      string `datastore:"displayName,omitempty" json:"displayName,omitempty"`
	DisplayLastFirst string `datastore:"displayNameLastFirst,omitempty" json:"displayNameLastFirst,omitempty"`
}

type PostalAddress struct {
	// RegionCode (Required) id the  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 `datastore:"regionCode,omitempty" json:"regionCode,omitempty"`

	// LanguageCode (Optional) is 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 `datastore:"languageCode,omitempty" json:"languageCode,omitempty"`

	// PostalCode (Optional) is the 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 `datastore:"postalCode,omitempty" json:"postalCode,omitempty"`

	// SortingCode (Optional) is 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 `datastore:"sortingCode,omitempty" json:"sortingCode,omitempty"`

	// AdministrativeArea (Optional) is the 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 `datastore:"administrativeArea,omitempty" json:"administrativeArea,omitempty"`

	// Locality (Optional) generally refers to the city/town portion of the address.
	// Examples: US city, IT comune, UK post town.
	// In regions of the world where localities are not well defined or do not fit
	// into this structure well, leave locality empty and use address_lines.
	Locality string `datastore:"locality,omitempty" json:"locality,omitempty"`

	// Sublocality (Optional) is a subdivision of the locality of the address.
	// For example, this can be neighborhoods, boroughs, districts.
	Sublocality string `datastore:"sublocality,omitempty" json:"sublocality,omitempty"`

	// AddressLines (Optional) are 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 `datastore:"addressLines,omitempty" json:"addressLines,omitempty"`

	// Recipients (Optional) are the recipients at the address.
	// This field may, under certain circumstances, contain multiline information.
	// For example, it might contain "care of" information.
	Recipients []string `datastore:"recipients,omitempty" json:"recipients,omitempty"`

	// Organization (Optional) is the name of the organization (e.g. business) at
	// the address.
	Organization string `datastore:"organization,omitempty" json:"organization,omitempty"`

	// MailboxId (Optional) is the identifier of a mailbox at this address. Used in the
	// case where multiple entities may be registered at the same address, divided
	// by per entity delivery boxes.
	//
	// Some address values might specify the mailbox as an address line but this field
	// allows for a mailbox to be explicitly labeled in the data.
	MailboxId string `datastore:"mailboxId,omitempty" json:"mailboxId,omitempty"`
}

type Timestamp interface {

	// GetTime returns the underlying time.Time value.
	GetTime() time.Time

	// GetPBTimestamp returns the time value as a google.protobuf.Timestamp protocol
	// buffer value.
	GetPBTimestamp() *timestamppb.Timestamp

	// String returns the time value as an RFC 3339 UTC string value to nanosecond accuracy.
	String() string
}