@hartl-services/medusa-storefront 0.2.0 → 0.3.0

package/README.md

@@ -83,6 +83,19 @@ wrapper (as in the `setup` item's `lib/storefront/actions.ts`) to use them:
 |---|---|---|
 | `registerCustomerWithProfile` | 0.2.0 | `usePasswordAuth().registerWithProfile` (name, phone, default address) |
 | `getOrder` | 0.2.0 | `useAccountOrderDetail` (order lines and totals in the account) |
+| `registerPartnerWithProfile` | 0.3.0 | `usePasswordAuth().registerPartner` (account, company address with optional UID, partner application) |
+
+## Partner views (e.g. therapists)
+
+A partner is an approved affiliate. For server rendering,
+`storefront.affiliate.isActivePartner()` answers whether the logged-in
+customer is one (`loadPartnerPortalState()` gives the full state, e.g.
+`pending` for a submitted application). Both are cached per request and fail
+closed: logged out, partner portal switched off or an unreachable backend all
+count as "not a partner". A partner registration (`registerPartner`) creates
+the account with the company address as default address and submits the
+application from it; while the e-mail is unconfirmed, both wait until the
+first login.
 
 ## Wiring rules
 

package/dist/browser/actions.d.ts

@@ -17,6 +17,8 @@ export interface StorefrontActions {
     registerCustomer: Server["customer"]["registerCustomer"];
     /** Optional (since 0.2.0): registration with name, phone and address. */
     registerCustomerWithProfile?: Server["customer"]["registerCustomerWithProfile"];
+    /** Optional (since 0.3.0): partner registration with company address and partner application. */
+    registerPartnerWithProfile?: Server["customer"]["registerPartnerWithProfile"];
     requestLoginCode: Server["customer"]["requestLoginCode"];
     loginWithCode: Server["customer"]["loginWithCode"];
     requestCustomerPasswordReset: Server["customer"]["requestCustomerPasswordReset"];

package/dist/core/catalog/partner-only.d.ts

@@ -0,0 +1,18 @@
+import type { HttpTypes } from "@medusajs/types";
+import type { CategoryTreeNode } from "./category-filter.js";
+/** A category tree node with the metadata that carries the partner-only flag. */
+export type PartnerCategoryTreeNode = CategoryTreeNode & {
+    category_children?: PartnerCategoryTreeNode[] | null;
+    metadata?: Record<string, unknown> | null;
+};
+/** Ids of every flagged category and all its descendants. */
+export declare function collectPartnerOnlyCategoryIds(trees: PartnerCategoryTreeNode[]): Set<string>;
+/** The trees without flagged categories (and their subcategories) - what a non-partner sees. */
+export declare function withoutPartnerOnlyCategories<T extends PartnerCategoryTreeNode>(trees: T[]): T[];
+/**
+ * A product only active partners may see and order: tagged
+ * `PARTNER_ONLY_PRODUCT_TAG` or in a partner-only category (see
+ * `collectPartnerOnlyCategoryIds`). The backend enforces the same rule when
+ * the cart is completed.
+ */
+export declare function isPartnerOnlyProduct(product: Pick<HttpTypes.StoreProduct, "categories" | "tags">, partnerOnlyCategoryIds: ReadonlySet<string>): boolean;

package/dist/core/catalog/partner-only.js

@@ -0,0 +1,31 @@
+import { PARTNER_ONLY_CATEGORY_METADATA_KEY, PARTNER_ONLY_PRODUCT_TAG } from "@hartl-services/medusa-contracts/paths/affiliate";
+import { collectCategoryIds } from "./category-filter.js";
+function isFlagged(category) {
+    return category.metadata?.[PARTNER_ONLY_CATEGORY_METADATA_KEY] === true;
+}
+/** Ids of every flagged category and all its descendants. */
+export function collectPartnerOnlyCategoryIds(trees) {
+    const ids = new Set();
+    const visit = (node) => {
+        if (isFlagged(node)) {
+            collectCategoryIds(node).forEach((id) => ids.add(id));
+            return;
+        }
+        node.category_children?.forEach(visit);
+    };
+    trees.forEach(visit);
+    return ids;
+}
+/** The trees without flagged categories (and their subcategories) - what a non-partner sees. */
+export function withoutPartnerOnlyCategories(trees) {
+    return trees.filter((node) => !isFlagged(node)).map((node) => (node.category_children ? { ...node, category_children: withoutPartnerOnlyCategories(node.category_children) } : node));
+}
+/**
+ * A product only active partners may see and order: tagged
+ * `PARTNER_ONLY_PRODUCT_TAG` or in a partner-only category (see
+ * `collectPartnerOnlyCategoryIds`). The backend enforces the same rule when
+ * the cart is completed.
+ */
+export function isPartnerOnlyProduct(product, partnerOnlyCategoryIds) {
+    return (product.tags ?? []).some((tag) => tag.value === PARTNER_ONLY_PRODUCT_TAG) || (product.categories ?? []).some((category) => partnerOnlyCategoryIds.has(category.id));
+}

package/dist/core/form-values.d.ts

@@ -14,8 +14,10 @@ export declare function createCustomerRegistrationSchema(t: Translate, policy: C
 export declare const registrationAddressSchema: z.ZodObject<{
     address_1: z.ZodString;
     city: z.ZodString;
+    company: z.ZodOptional<z.ZodString>;
     country_code: z.ZodString;
     postal_code: z.ZodString;
+    vat_number: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /** What the server takes for a registration with profile (and optional address). */
 export declare const customerRegistrationProfileSchema: z.ZodObject<{
@@ -24,13 +26,36 @@ export declare const customerRegistrationProfileSchema: z.ZodObject<{
     address: z.ZodOptional<z.ZodObject<{
         address_1: z.ZodString;
         city: z.ZodString;
+        company: z.ZodOptional<z.ZodString>;
         country_code: z.ZodString;
         postal_code: z.ZodString;
+        vat_number: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     first_name: z.ZodString;
     last_name: z.ZodString;
     phone: z.ZodString;
 }, z.core.$strip>;
+/**
+ * A partner (e.g. therapist) registration: the profile with a complete
+ * company address - with a UID, or with the confirmation that the company has
+ * none - from which the partner application is submitted.
+ */
+export declare const partnerRegistrationProfileSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    phone: z.ZodString;
+    address: z.ZodObject<{
+        address_1: z.ZodString;
+        city: z.ZodString;
+        country_code: z.ZodString;
+        postal_code: z.ZodString;
+        vat_number: z.ZodOptional<z.ZodString>;
+        company: z.ZodString;
+    }, z.core.$strip>;
+    confirmed_without_vat_number: z.ZodBoolean;
+}, z.core.$strip>;
 /**
  * The registration form with profile, address, a repeated password and the
  * accepted terms. Address fields are all-or-nothing: none or a complete
@@ -49,6 +74,28 @@ export declare function createCustomerRegistrationFormSchema(t: Translate, polic
     phone: z.ZodString;
     postal_code: z.ZodString;
 }, z.core.$strip>;
+/**
+ * The partner registration form: profile and a required company address,
+ * an optional UID, and without UID the confirmation that the company has none.
+ */
+export declare function createPartnerRegistrationFormSchema(t: Translate, policy: CustomerPasswordPolicy | null): z.ZodObject<{
+    address_1: z.ZodString;
+    city: z.ZodString;
+    company: z.ZodString;
+    confirmed_without_vat_number: z.ZodBoolean;
+    country_code: z.ZodString;
+    postal_code: z.ZodString;
+    vat_number: z.ZodString;
+    accept_terms: z.ZodBoolean;
+    confirmPassword: z.ZodString;
+    email: z.ZodString;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    password: z.ZodString;
+    phone: z.ZodString;
+}, z.core.$strip>;
+/** The partner registration form's values as the server takes them. */
+export declare function toPartnerRegistrationProfile(value: PartnerRegistrationFormValues): PartnerRegistrationProfileValues;
 /** The registration form's values as the server takes them. */
 export declare function toRegistrationProfile(value: CustomerRegistrationFormValues): CustomerRegistrationProfileValues;
 export declare function createPasswordResetSchema(t: Translate, policy: CustomerPasswordPolicy | null): z.ZodObject<{
@@ -127,25 +174,25 @@ export declare const createCheckoutAddressSchema: (t: Translate, merchantCountry
     shipping_address: z.ZodObject<{
         address_1: z.ZodString;
         city: z.ZodString;
+        company: z.ZodString;
         country_code: z.ZodString;
         postal_code: z.ZodString;
         first_name: z.ZodString;
         last_name: z.ZodString;
         phone: z.ZodString;
         address_2: z.ZodString;
-        company: z.ZodString;
         province: z.ZodString;
     }, z.core.$strip>;
     billing_address: z.ZodObject<{
         address_1: z.ZodString;
         city: z.ZodString;
+        company: z.ZodString;
         country_code: z.ZodString;
         postal_code: z.ZodString;
         first_name: z.ZodString;
         last_name: z.ZodString;
         phone: z.ZodString;
         address_2: z.ZodString;
-        company: z.ZodString;
         province: z.ZodString;
     }, z.core.$strip>;
     vat_number: z.ZodString;
@@ -153,6 +200,8 @@ export declare const createCheckoutAddressSchema: (t: Translate, merchantCountry
 export type CustomerAuthValues = z.infer<typeof customerAuthSchema>;
 export type CustomerRegistrationProfileValues = z.infer<typeof customerRegistrationProfileSchema>;
 export type CustomerRegistrationFormValues = z.infer<ReturnType<typeof createCustomerRegistrationFormSchema>>;
+export type PartnerRegistrationProfileValues = z.infer<typeof partnerRegistrationProfileSchema>;
+export type PartnerRegistrationFormValues = z.infer<ReturnType<typeof createPartnerRegistrationFormSchema>>;
 export type LoginCodeRequestValues = z.infer<ReturnType<typeof createLoginCodeRequestSchema>>;
 export type PasswordResetValues = z.infer<ReturnType<typeof createPasswordResetSchema>>;
 export type VerificationResendValues = z.infer<ReturnType<typeof createVerificationResendSchema>>;

package/dist/core/form-values.js

@@ -31,8 +31,11 @@ export function createCustomerRegistrationSchema(t, policy) {
 export const registrationAddressSchema = z.object({
     address_1: z.string().trim().min(1),
     city: z.string().trim().min(1),
+    company: z.string().trim().optional(),
     country_code: z.string().trim().min(1),
     postal_code: z.string().trim().min(1),
+    /** Stored in the address metadata, where the UID check reads it. */
+    vat_number: z.string().trim().optional(),
 });
 /** What the server takes for a registration with profile (and optional address). */
 export const customerRegistrationProfileSchema = customerAuthSchema.extend({
@@ -42,13 +45,18 @@ export const customerRegistrationProfileSchema = customerAuthSchema.extend({
     phone: z.string().trim(),
 });
 /**
- * The registration form with profile, address, a repeated password and the
- * accepted terms. Address fields are all-or-nothing: none or a complete
- * address.
+ * A partner (e.g. therapist) registration: the profile with a complete
+ * company address - with a UID, or with the confirmation that the company has
+ * none - from which the partner application is submitted.
  */
-export function createCustomerRegistrationFormSchema(t, policy) {
-    return z
-        .object({
+export const partnerRegistrationProfileSchema = customerRegistrationProfileSchema
+    .extend({
+    address: registrationAddressSchema.extend({ company: z.string().trim().min(1) }),
+    confirmed_without_vat_number: z.boolean(),
+})
+    .refine((value) => Boolean(value.address.vat_number) || value.confirmed_without_vat_number, { path: ["confirmed_without_vat_number"] });
+function registrationFormFields(t, policy) {
+    return {
         accept_terms: z.boolean().refine((accepted) => accepted, t("registration.terms_required")),
         address_1: z.string().trim(),
         city: z.string().trim(),
@@ -60,7 +68,16 @@ export function createCustomerRegistrationFormSchema(t, policy) {
         password: createNewPasswordSchema(t, policy),
         phone: z.string().trim(),
         postal_code: z.string().trim(),
-    })
+    };
+}
+/**
+ * The registration form with profile, address, a repeated password and the
+ * accepted terms. Address fields are all-or-nothing: none or a complete
+ * address.
+ */
+export function createCustomerRegistrationFormSchema(t, policy) {
+    return z
+        .object(registrationFormFields(t, policy))
         .superRefine((value, context) => {
         if (value.password !== value.confirmPassword) {
             context.addIssue({ code: "custom", message: t("form.passwords_mismatch"), path: ["confirmPassword"] });
@@ -80,6 +97,55 @@ export function createCustomerRegistrationFormSchema(t, policy) {
         }
     });
 }
+/**
+ * The partner registration form: profile and a required company address,
+ * an optional UID, and without UID the confirmation that the company has none.
+ */
+export function createPartnerRegistrationFormSchema(t, policy) {
+    return z
+        .object({
+        ...registrationFormFields(t, policy),
+        address_1: z.string().trim().min(1, t("address.address_1_required")),
+        city: z.string().trim().min(1, t("address.city_required")),
+        company: z.string().trim().min(1, t("company_address.company_required")),
+        confirmed_without_vat_number: z.boolean(),
+        country_code: z.string().trim().min(1, t("address.country_required")),
+        postal_code: z.string().trim().min(1, t("address.postal_code_required")),
+        vat_number: z.string().refine((value) => {
+            const vatNumber = value.replace(/\s+/g, "");
+            return !vatNumber || (vatNumber.length >= 4 && vatNumber.length <= 32);
+        }, t("company_address.vat_number_invalid")),
+    })
+        .superRefine((value, context) => {
+        if (value.password !== value.confirmPassword) {
+            context.addIssue({ code: "custom", message: t("form.passwords_mismatch"), path: ["confirmPassword"] });
+        }
+        if (!value.vat_number.trim() && !value.confirmed_without_vat_number) {
+            context.addIssue({ code: "custom", message: t("affiliate_application.confirm_without_vat_number"), path: ["confirmed_without_vat_number"] });
+        }
+    });
+}
+/** The partner registration form's values as the server takes them. */
+export function toPartnerRegistrationProfile(value) {
+    const vatNumber = value.vat_number.replace(/\s+/g, "").toUpperCase();
+    return {
+        address: {
+            address_1: value.address_1.trim(),
+            city: value.city.trim(),
+            company: value.company.trim(),
+            country_code: value.country_code.trim().toLowerCase(),
+            postal_code: value.postal_code.trim(),
+            ...(vatNumber ? { vat_number: vatNumber } : {}),
+        },
+        // Only meaningful without a UID; the backend ignores it otherwise.
+        confirmed_without_vat_number: !vatNumber && value.confirmed_without_vat_number,
+        email: value.email.trim(),
+        first_name: value.first_name.trim(),
+        last_name: value.last_name.trim(),
+        password: value.password,
+        phone: value.phone.trim(),
+    };
+}
 /** The registration form's values as the server takes them. */
 export function toRegistrationProfile(value) {
     const hasAddress = Boolean(value.address_1 && value.postal_code && value.city && value.country_code);

package/dist/core/index.d.ts

@@ -18,6 +18,7 @@ export * from "./cart/coupon-promotions.js";
 export * from "./cart/payment-session.js";
 export * from "./cart/refunded-cart.js";
 export * from "./catalog/category-filter.js";
+export * from "./catalog/partner-only.js";
 export * from "./catalog/inventory.js";
 export * from "./catalog/medusa-product-image.js";
 export * from "./catalog/product-price.js";

package/dist/core/index.js

@@ -19,6 +19,7 @@ export * from "./cart/coupon-promotions.js";
 export * from "./cart/payment-session.js";
 export * from "./cart/refunded-cart.js";
 export * from "./catalog/category-filter.js";
+export * from "./catalog/partner-only.js";
 export * from "./catalog/inventory.js";
 export * from "./catalog/medusa-product-image.js";
 export * from "./catalog/product-price.js";

package/dist/core/report-error.d.ts

@@ -1,5 +1,5 @@
 /** Where an error happened; the shop's error tracker files it under this area. */
-export type StorefrontErrorArea = "checkout" | "customer-auth" | "plugin-features" | "tax-compliance";
+export type StorefrontErrorArea = "affiliate" | "checkout" | "customer-auth" | "plugin-features" | "tax-compliance";
 export interface StorefrontErrorReport {
     area: StorefrontErrorArea;
     /** Extra data for tracing (cart id, status, ...); never addresses or payment details. */

package/dist/core/texts-de.d.ts

@@ -8,6 +8,8 @@ export declare const textsDe: {
     readonly "form.passwords_mismatch": "Die Passwörter stimmen nicht überein.";
     readonly "registration.terms_required": "Bitte akzeptiere die Nutzungsbedingungen und Datenschutzrichtlinien.";
     readonly "registration.address_not_saved": "Dein Konto wurde angelegt, die Adresse konnte aber nicht gespeichert werden. Du kannst sie in deinem Konto nachtragen.";
+    readonly "partner_registration.unavailable": "Die Registrierung als Partner ist derzeit nicht möglich.";
+    readonly "partner_registration.application_not_submitted": "Dein Konto wurde angelegt, die Bewerbung konnte aber nicht übermittelt werden. Bitte melde dich bei uns.";
     readonly "form.email_required": "Bitte gib deine E-Mail-Adresse ein.";
     readonly "form.email_invalid": "Bitte gib eine gültige E-Mail-Adresse ein.";
     readonly "form.login_code_invalid": "Bitte gib den {length}-stelligen Code ein.";

package/dist/core/texts-de.js

@@ -10,6 +10,8 @@ export const textsDe = {
     "form.passwords_mismatch": "Die Passwörter stimmen nicht überein.",
     "registration.terms_required": "Bitte akzeptiere die Nutzungsbedingungen und Datenschutzrichtlinien.",
     "registration.address_not_saved": "Dein Konto wurde angelegt, die Adresse konnte aber nicht gespeichert werden. Du kannst sie in deinem Konto nachtragen.",
+    "partner_registration.unavailable": "Die Registrierung als Partner ist derzeit nicht möglich.",
+    "partner_registration.application_not_submitted": "Dein Konto wurde angelegt, die Bewerbung konnte aber nicht übermittelt werden. Bitte melde dich bei uns.",
     "form.email_required": "Bitte gib deine E-Mail-Adresse ein.",
     "form.email_invalid": "Bitte gib eine gültige E-Mail-Adresse ein.",
     "form.login_code_invalid": "Bitte gib den {length}-stelligen Code ein.",

package/dist/react/use-auth.d.ts

@@ -1,5 +1,5 @@
 import type { StorefrontBrowser } from "../browser/index.js";
-import type { CustomerAuthValues, CustomerRegistrationProfileValues, PasswordResetValues, VerificationResendValues } from "../core/form-values.js";
+import type { CustomerAuthValues, CustomerRegistrationProfileValues, PartnerRegistrationProfileValues, PasswordResetValues, VerificationResendValues } from "../core/form-values.js";
 /**
  * Start of the backend's 400 for a registration with an address that already
  * has an account; the form then links to the password reset.
@@ -55,6 +55,14 @@ export declare function usePasswordAuth({ getValues, onSuccess }: PasswordAuthOp
      * `registerCustomerWithProfile` action. True once signed in.
      */
     registerWithProfile(value: CustomerRegistrationProfileValues): Promise<boolean>;
+    /** The partner registration did not submit its application; the account exists. */
+    isApplicationNotSubmitted: boolean;
+    /**
+     * Partner registration with company address; the application follows
+     * (after an e-mail confirmation: at the first login). Needs the shop's
+     * optional `registerPartnerWithProfile` action. True once signed in.
+     */
+    registerPartner(value: PartnerRegistrationProfileValues): Promise<boolean>;
     /** "I confirmed it": signs in again with the kept form values, also after a registration (the account exists by now). */
     continueAfterVerification(): Promise<void>;
 };

package/dist/react/use-auth.js

@@ -75,6 +75,8 @@ export function usePasswordAuth({ getValues, onSuccess }) {
     const [isContinuing, setIsContinuing] = useState(false);
     // A registration with profile succeeded but its address could not be stored.
     const [isAddressNotSaved, setIsAddressNotSaved] = useState(false);
+    // A partner registration succeeded but its application could not be submitted.
+    const [isApplicationNotSubmitted, setIsApplicationNotSubmitted] = useState(false);
     // The background check and the "continue" button must not sign in twice.
     const confirmationSignIn = useRef("idle");
     async function completeSignIn(sessionToken) {
@@ -162,6 +164,39 @@ export function usePasswordAuth({ getValues, onSuccess }) {
                 return false;
             }
         },
+        /** The partner registration did not submit its application; the account exists. */
+        isApplicationNotSubmitted,
+        /**
+         * Partner registration with company address; the application follows
+         * (after an e-mail confirmation: at the first login). Needs the shop's
+         * optional `registerPartnerWithProfile` action. True once signed in.
+         */
+        async registerPartner(value) {
+            const action = actions.registerPartnerWithProfile;
+            setErrorMessage(null);
+            setIsAddressNotSaved(false);
+            setIsApplicationNotSubmitted(false);
+            if (!action) {
+                setErrorMessage(t("partner_registration.unavailable"));
+                return false;
+            }
+            try {
+                const result = unwrapMedusaAction(await action(value));
+                if (result.state === "verification_required") {
+                    setVerification((current) => ({ email: value.email, stillUnverified: current !== null }));
+                    return false;
+                }
+                setIsAddressNotSaved(!result.addressSaved);
+                setIsApplicationNotSubmitted(!result.applicationSubmitted);
+                await completeSignIn(result.sessionToken);
+                return true;
+            }
+            catch (error) {
+                setVerification(null);
+                setErrorMessage(t.message(getErrorMessage(error, t("auth.sign_in_failed"))));
+                return false;
+            }
+        },
         /** "I confirmed it": signs in again with the kept form values, also after a registration (the account exists by now). */
         async continueAfterVerification() {
             setIsContinuing(true);

package/dist/react/use-checkout-address-form.d.ts

@@ -35,25 +35,25 @@ export declare function useCheckoutAddressForm({ countryCode, countryOptions, in
         shipping_address: {
             address_1: string;
             city: string;
+            company: string;
             country_code: string;
             postal_code: string;
             first_name: string;
             last_name: string;
             phone: string;
             address_2: string;
-            company: string;
             province: string;
         };
         billing_address: {
             address_1: string;
             city: string;
+            company: string;
             country_code: string;
             postal_code: string;
             first_name: string;
             last_name: string;
             phone: string;
             address_2: string;
-            company: string;
             province: string;
         };
         vat_number: string;
@@ -69,25 +69,25 @@ export declare function useCheckoutAddressForm({ countryCode, countryOptions, in
             shipping_address: {
                 address_1: string;
                 city: string;
+                company: string;
                 country_code: string;
                 postal_code: string;
                 first_name: string;
                 last_name: string;
                 phone: string;
                 address_2: string;
-                company: string;
                 province: string;
             };
             billing_address: {
                 address_1: string;
                 city: string;
+                company: string;
                 country_code: string;
                 postal_code: string;
                 first_name: string;
                 last_name: string;
                 phone: string;
                 address_2: string;
-                company: string;
                 province: string;
             };
             vat_number: string;
@@ -105,25 +105,25 @@ export declare function useCheckoutAddressForm({ countryCode, countryOptions, in
                 shipping_address: import("zod").ZodObject<{
                     address_1: import("zod").ZodString;
                     city: import("zod").ZodString;
+                    company: import("zod").ZodString;
                     country_code: import("zod").ZodString;
                     postal_code: import("zod").ZodString;
                     first_name: import("zod").ZodString;
                     last_name: import("zod").ZodString;
                     phone: import("zod").ZodString;
                     address_2: import("zod").ZodString;
-                    company: import("zod").ZodString;
                     province: import("zod").ZodString;
                 }, import("zod/v4/core").$strip>;
                 billing_address: import("zod").ZodObject<{
                     address_1: import("zod").ZodString;
                     city: import("zod").ZodString;
+                    company: import("zod").ZodString;
                     country_code: import("zod").ZodString;
                     postal_code: import("zod").ZodString;
                     first_name: import("zod").ZodString;
                     last_name: import("zod").ZodString;
                     phone: import("zod").ZodString;
                     address_2: import("zod").ZodString;
-                    company: import("zod").ZodString;
                     province: import("zod").ZodString;
                 }, import("zod/v4/core").$strip>;
                 vat_number: import("zod").ZodString;

package/dist/react/use-checkout.d.ts

@@ -29,25 +29,25 @@ export declare function useCheckout(countryCode: string): {
         shipping_address: {
             address_1: string;
             city: string;
+            company: string;
             country_code: string;
             postal_code: string;
             first_name: string;
             last_name: string;
             phone: string;
             address_2: string;
-            company: string;
             province: string;
         };
         billing_address: {
             address_1: string;
             city: string;
+            company: string;
             country_code: string;
             postal_code: string;
             first_name: string;
             last_name: string;
             phone: string;
             address_2: string;
-            company: string;
             province: string;
         };
         vat_number: string;
@@ -60,25 +60,25 @@ export declare function useCheckout(countryCode: string): {
         shipping_address: {
             address_1: string;
             city: string;
+            company: string;
             country_code: string;
             postal_code: string;
             first_name: string;
             last_name: string;
             phone: string;
             address_2: string;
-            company: string;
             province: string;
         };
         billing_address: {
             address_1: string;
             city: string;
+            company: string;
             country_code: string;
             postal_code: string;
             first_name: string;
             last_name: string;
             phone: string;
             address_2: string;
-            company: string;
             province: string;
         };
         vat_number: string;

package/dist/registry/account.json

@@ -4,8 +4,8 @@
   "title": "Customer account",
   "description": "Sign-in with password or e-mail code, password reset, account verification, address book with UID check, profile, orders, the account workspace layout and the document download route.",
   "dependencies": [
-    "@hartl-services/medusa-storefront@^0.2.0",
-    "@hartl-services/medusa-contracts@^1.1.0",
+    "@hartl-services/medusa-storefront@^0.3.0",
+    "@hartl-services/medusa-contracts@^1.2.0",
     "@medusajs/types@^2.19.0",
     "lucide-react"
   ],

package/dist/registry/affiliate.json

@@ -4,8 +4,8 @@
   "title": "Partner portal",
   "description": "Partner portal: gated registration with UID check, links, coupon codes, commissions with date filter, consignment reports, and its Route Handlers.",
   "dependencies": [
-    "@hartl-services/medusa-storefront@^0.2.0",
-    "@hartl-services/medusa-contracts@^1.1.0",
+    "@hartl-services/medusa-storefront@^0.3.0",
+    "@hartl-services/medusa-contracts@^1.2.0",
     "@medusajs/types@^2.19.0",
     "lucide-react",
     "react-day-picker"

package/dist/registry/cart.json

@@ -4,7 +4,7 @@
   "title": "Cart",
   "description": "Cart widget with popover, line items, totals, cart page, add-to-cart button, variant picker and product price.",
   "dependencies": [
-    "@hartl-services/medusa-storefront@^0.2.0",
+    "@hartl-services/medusa-storefront@^0.3.0",
     "@medusajs/types@^2.19.0",
     "lucide-react"
   ],

package/dist/registry/checkout.json

@@ -4,7 +4,7 @@
   "title": "Checkout",
   "description": "Checkout page (address, login prompt, shipping and Stripe payment, coupon, UID status) and the order confirmation page.",
   "dependencies": [
-    "@hartl-services/medusa-storefront@^0.2.0",
+    "@hartl-services/medusa-storefront@^0.3.0",
     "@medusajs/types@^2.19.0",
     "@stripe/react-stripe-js@^5.6.1",
     "@stripe/stripe-js@^8.11.0",

package/dist/registry/form.json

@@ -4,7 +4,7 @@
   "title": "Storefront form kit",
   "description": "The shop's TanStack form hook (useAppForm) with unstyled field components; the package's hooks hand their formOptions to it.",
   "dependencies": [
-    "@hartl-services/medusa-storefront@^0.2.0",
+    "@hartl-services/medusa-storefront@^0.3.0",
     "@tanstack/react-form@^1.33.5",
     "input-otp",
     "lucide-react"