@afosto/checkout-ui 0.0.1-alpha.1

package/dist/steps/paymentStep.js

@@ -0,0 +1,78 @@
+import { CheckoutPaymentStep as p } from "../CheckoutPaymentStep/CheckoutPaymentStep.js";
+import { camelize as u } from "@afosto/utils";
+import * as n from "yup";
+const y = {
+  key: "payment",
+  label: "Payment",
+  nextLabel: (t) => {
+    const { subStep: s, translations: e = {} } = t || {};
+    if (!s)
+      return e.nextSubStepLabel;
+  },
+  component: p,
+  reviewTargets: ["paymentMethod", "paymentOption"],
+  defaultValues: {
+    agreementId: "",
+    agreementType: "",
+    methodId: "",
+    hasIssuers: !1,
+    hasTerminals: !1,
+    issuerId: "",
+    terminalId: ""
+  },
+  initialize: (t, s, e) => {
+    const { step: r } = e || {}, { defaultValues: a } = r || {}, { billing: i, checkout: o } = t || {}, { payment: m } = i || {}, { agreement: l } = o || {}, { method: d } = m || {};
+    return {
+      ...a,
+      agreementId: l?.id || a.agreementId,
+      agreementType: l?.type || a.agreementType,
+      methodId: d?.id || a.methodId,
+      hasIssuers: (d?.issuers || []).length > 0,
+      hasTerminals: (d?.terminals || []).length > 0,
+      issuerId: m?.issuer?.id || a.issuerId,
+      terminalId: m?.terminal?.id || a.terminalId
+    };
+  },
+  isComplete: (t, s) => {
+    const { step: e } = s || {};
+    return e.validationSchema({
+      ...s,
+      subStep: "paymentMethods"
+    }).isValidSync(t);
+  },
+  getSubStepForReviewTarget: (t) => {
+    if (t === "paymentMethod")
+      return "paymentMethods";
+  },
+  submit: async (t, s, e) => {
+    const { setSubStep: r, subStep: a } = e || {}, { agreementType: i } = t || {}, o = u(i?.toLowerCase() || "");
+    return !a && !["cod", "postPaid"].includes(o) ? (r("paymentMethods"), Promise.reject()) : t;
+  },
+  validationSchema: (t) => {
+    const { subStep: s } = t || {};
+    return n.object().shape({
+      agreementId: n.string().required(),
+      agreementType: n.string().required(),
+      methodId: s === "paymentMethods" ? n.string().when(["agreementType"], {
+        is: (e) => ["downPayment", "default"].includes(
+          u(e?.toLowerCase() || "")
+        ),
+        then: (e) => e.required()
+      }) : n.string().nullable(),
+      hasIssuers: n.boolean(),
+      issuerId: n.string().nullable().when("hasIssuers", {
+        is: !0,
+        then: (e) => e.required()
+      }),
+      hasTerminals: n.boolean(),
+      subStep: n.string().nullable(),
+      terminalId: n.string().nullable().when("hasTerminals", {
+        is: !0,
+        then: (e) => e.required()
+      })
+    });
+  }
+};
+export {
+  y as paymentStep
+};

package/dist/steps/reviewStep.d.ts

@@ -0,0 +1,3 @@
+import { CheckoutStep as CheckoutStepType } from '../types';
+export declare const reviewStep: CheckoutStepType<Record<string, never>>;
+//# sourceMappingURL=reviewStep.d.ts.map

package/dist/steps/reviewStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviewStep.d.ts","sourceRoot":"","sources":["../../libs/checkout-ui/src/steps/reviewStep.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,YAAY,IAAI,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAGjE,eAAO,MAAM,UAAU,EAAE,gBAAgB,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAoB9D,CAAC"}

package/dist/steps/reviewStep.js

@@ -0,0 +1,22 @@
+import { CheckoutReviewStep as n } from "../CheckoutReviewStep/CheckoutReviewStep.js";
+import * as s from "yup";
+const l = {
+  key: "review",
+  label: "Checkout",
+  component: n,
+  defaultValues: {},
+  initialize: (a, e, t) => {
+    const { step: i } = t || {}, { defaultValues: o } = i || {};
+    return {
+      ...o
+    };
+  },
+  isComplete: (a, e) => {
+    const { step: t } = e || {};
+    return t.validationSchema(e).isValidSync(a);
+  },
+  validationSchema: () => s.object().shape({})
+};
+export {
+  l as reviewStep
+};

package/dist/steps/shippingStep.d.ts

@@ -0,0 +1,8 @@
+import { CheckoutStep as CheckoutStepType } from '../types';
+export interface CheckoutShippingStepValues {
+    methodId: string;
+    isPickupPoint: boolean;
+    pickupPointId: string;
+}
+export declare const shippingStep: CheckoutStepType<CheckoutShippingStepValues>;
+//# sourceMappingURL=shippingStep.d.ts.map

package/dist/steps/shippingStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shippingStep.d.ts","sourceRoot":"","sources":["../../libs/checkout-ui/src/steps/shippingStep.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,YAAY,IAAI,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAIjE,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,YAAY,EAAE,gBAAgB,CAAC,0BAA0B,CA8CrE,CAAC"}

package/dist/steps/shippingStep.js

@@ -0,0 +1,39 @@
+import { CheckoutShippingStep as c } from "../CheckoutShippingStep/CheckoutShippingStep.js";
+import { isDefined as u } from "@afosto/utils";
+import * as e from "yup";
+const l = {
+  key: "shipping",
+  label: "Shipping",
+  component: c,
+  reviewTargets: ["shippingMethod"],
+  defaultValues: {
+    methodId: "",
+    isPickupPoint: !1,
+    pickupPointId: ""
+  },
+  initialize: (i, n, o) => {
+    const { step: s } = o || {}, { defaultValues: t } = s || {}, { delivery: a } = i || {}, { method: p, pickupPoint: d } = a || {};
+    return {
+      ...t,
+      methodId: p?.id || t.methodId,
+      isPickupPoint: u(p?.isPickupPoint) ? p.isPickupPoint : t.isPickupPoint,
+      pickupPointId: d?.id || t.pickupPointId
+    };
+  },
+  isComplete: (i, n) => {
+    const { step: o } = n || {};
+    return o.validationSchema(n).isValidSync(i);
+  },
+  submit: async (i) => i,
+  validationSchema: () => e.object().shape({
+    methodId: e.string().required(),
+    isPickupPoint: e.boolean(),
+    pickupPointId: e.string().nullable().when("isPickupPoint", {
+      is: !0,
+      then: (i) => i.required()
+    })
+  })
+};
+export {
+  l as shippingStep
+};

package/dist/types.d.ts

@@ -0,0 +1,489 @@
+import { Account, AccountOrganisation, createStorefrontClient, User } from '@afosto/storefront';
+import { CheckoutSummaryDrawerProps } from './CheckoutSummaryDrawer/CheckoutSummaryDrawer';
+import { CheckoutSummaryProps } from './CheckoutSummary/CheckoutSummary';
+import { AnySchema, Maybe, ObjectSchema, AnyObject } from 'yup';
+import { CheckoutContactInformationSectionProps } from './CheckoutContactInformationSection/CheckoutContactInformationSection';
+import { CheckoutTypeSectionProps } from './CheckoutTypeSection/CheckoutTypeSection';
+import { CheckoutBusinessInformationSectionProps } from './CheckoutBusinessInformationSection/CheckoutBusinessInformationSection';
+import { AnchorHTMLAttributes, ElementType, FunctionComponent } from 'react';
+import { CheckoutExpressCheckoutSectionProps } from './CheckoutExpressCheckoutSection/CheckoutExpressCheckoutSection';
+import { CheckoutShippingAddressSectionProps } from './CheckoutShippingAddressSection/CheckoutShippingAddressSection';
+import { CheckoutBillingAddressSectionProps } from './CheckoutBillingAddressSection/CheckoutBillingAddressSection';
+import { CheckoutShippingMethodSectionProps } from './CheckoutShippingMethodSection/CheckoutShippingMethodSection';
+import { CheckoutPricingLabelProps } from './CheckoutPricingLabel/CheckoutPricingLabel';
+import { GetCartReviewCheckoutDataFormatterResponse } from './operations/cartOperations';
+import { CountryOption, SxProps, Theme } from '@afosto/components';
+import { Country } from '@afosto/utils';
+import { UseCheckoutAuthContext } from './hooks/useCheckoutAuth';
+import { UseCheckoutFormContext } from './hooks/useCheckoutForm';
+import { UseCheckoutSummaryContext } from './hooks/useCheckoutSummary';
+import { UseCheckoutAnalyticsContext } from './hooks/useCheckoutAnalytics';
+import { CheckoutAccountSelectionProps } from './CheckoutAccountSelection/CheckoutAccountSelection';
+import { CheckoutAddressSectionProps } from './CheckoutAddressSection/CheckoutAddressSection';
+import { CheckoutAgreementOptionConditionProps } from './CheckoutAgreementOptionCondition/CheckoutAgreementOptionCondition';
+import { CheckoutAgreementOptionsFieldProps } from './CheckoutAgreementOptionsField/CheckoutAgreementOptionsField';
+import { CheckoutAgreementOptionsSectionProps } from './CheckoutAgreementOptionsSection/CheckoutAgreementOptionsSection';
+import { CheckoutAgreementsTimelineProps } from './CheckoutAgreementsTimeline/CheckoutAgreementsTimeline';
+import { CheckoutAgreementSummaryCardProps } from './CheckoutAgreementSummaryCard/CheckoutAgreementSummaryCard';
+import { CheckoutBusinessDetailsCardProps } from './CheckoutBusinessDetailsCard/CheckoutBusinessDetailsCard';
+import { CheckoutCommentFieldProps } from './CheckoutCommentField/CheckoutCommentField';
+import { CheckoutContactDetailsCardProps } from './CheckoutContactDetailsCard/CheckoutContactDetailsCard';
+import { CheckoutDownPaymentAgreementsSummaryProps } from './CheckoutDownPaymentAgreementsSummary/CheckoutDownPaymentAgreementsSummary';
+import { CheckoutForgotPasswordProps } from './CheckoutForgotPassword/CheckoutForgotPassword';
+import { CheckoutFormProps } from './CheckoutForm/CheckoutForm';
+import { CheckoutIssuersFieldProps } from './CheckoutIssuersField/CheckoutIssuersField';
+import { CheckoutMethodSummaryCardProps } from './CheckoutMethodSummaryCard/CheckoutMethodSummaryCard';
+import { CheckoutNotFoundFeedbackProps } from './CheckoutNotFoundFeedback/CheckoutNotFoundFeedback';
+import { CheckoutPaymentMethodSectionProps } from './CheckoutPaymentMethodSection/CheckoutPaymentMethodSection';
+import { CheckoutPaymentMethodsFieldProps } from './CheckoutPaymentMethodsField/CheckoutPaymentMethodsField';
+import { CheckoutPhoneNumberCardProps } from './CheckoutPhoneNumberCard/CheckoutPhoneNumberCard';
+import { CheckoutPickupPointsFieldProps } from './CheckoutPickupPointsField/CheckoutPickupPointsField';
+import { CheckoutReviewCommentSectionProps } from './CheckoutReviewCommentSection/CheckoutReviewCommentSection';
+import { CheckoutReviewItemsSectionProps } from './CheckoutReviewItemsSection/CheckoutReviewItemsSection';
+import { CheckoutReviewOrderSectionProps } from './CheckoutReviewOrderSection/CheckoutReviewOrderSection';
+import { CheckoutReviewPaymentSectionProps } from './CheckoutReviewPaymentSection/CheckoutReviewPaymentSection';
+import { CheckoutReviewShippingSectionProps } from './CheckoutReviewShippingSection/CheckoutReviewShippingSection';
+import { CheckoutShippingMethodsFieldProps } from './CheckoutShippingMethodsField/CheckoutShippingMethodsField';
+import { CheckoutSignedInAsMessageProps } from './CheckoutSignedInAsMessage/CheckoutSignedInAsMessage';
+import { CheckoutSignInProps } from './CheckoutSignIn/CheckoutSignIn';
+import { CheckoutTerminalsFieldProps } from './CheckoutTerminalsField/CheckoutTerminalsField';
+import { CheckoutTermsAndPrivacyMessageProps } from './CheckoutTermsAndPrivacyMessage/CheckoutTermsAndPrivacyMessage';
+import { CheckoutAuthOperations } from './operations/authOperations';
+import { CheckoutContextType } from './CheckoutStateProvider/CheckoutStateProvider';
+import { CheckoutAnalytics } from './constants/analyticsEvents';
+export type DeepPartial<T> = T extends Array<infer U> ? Array<DeepPartial<U>> : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+export type SlotPropsFunc<Props, OwnerState = object> = (ownerState: OwnerState) => Partial<Props>;
+export type SlotProps<Props, OwnerState = object> = SlotPropsFunc<Props, OwnerState> | Partial<Props>;
+export type StorefrontClient = ReturnType<typeof createStorefrontClient>;
+export interface AdministrativeAreaOption {
+    label: string;
+    value: string;
+}
+export type OnChangeValidationSchema = (schema?: Record<string, AnySchema>) => void;
+export type LinkComponent = FunctionComponent<AnchorHTMLAttributes<HTMLAnchorElement>>;
+export interface AddressValues {
+    givenName: string;
+    additionalName: string;
+    familyName: string;
+    organisation: string;
+    country: CountryOption | null;
+    countryCode: string;
+    postalCode: string;
+    premiseNumber: string;
+    premiseNumberSuffix: string;
+    address_line_1: string;
+    address_line_2: string;
+    addressLine1: string;
+    addressLine2: string;
+    administrativeArea: AdministrativeAreaOption | null;
+    thoroughfare: string;
+    locality: string;
+    dependentLocality: string;
+    sortingCode: string;
+    isDirty: boolean;
+    errors: string[];
+}
+export interface ResponseError {
+    response?: {
+        data?: {
+            error?: {
+                details?: {
+                    pointers?: {
+                        message?: string;
+                    }[];
+                };
+                message?: string;
+            };
+            message?: string;
+        };
+        errors?: {
+            extensions?: {
+                pointers?: {
+                    message?: string;
+                }[];
+                reference?: string;
+            };
+            message?: string;
+        }[];
+        headers?: Record<string, string>;
+        status?: number;
+    };
+}
+export type CheckoutErrorMessage = {
+    title?: string;
+    description?: string;
+    action?: {
+        label: string;
+        onClick: () => void;
+        sx?: SxProps<Theme>;
+    };
+} | null;
+export type CheckoutValidationError = {
+    message?: string | {
+        key?: string;
+        values?: Record<string, unknown>;
+    };
+    type?: string;
+};
+export type CheckoutGetValidationErrorMessage = (error: CheckoutValidationError) => string | object;
+export interface CheckoutCurrentOrganisation {
+    id: string;
+}
+export type CheckoutExpressPaymentMethodsComponentMapping = Record<string, ElementType>;
+export interface CheckoutExpressPaymentMethod {
+    id: string;
+    code: string;
+    name: string;
+    description?: string;
+    instruction?: string;
+}
+export interface CheckoutPaymentMethodIssuer {
+    id: string;
+    label: string;
+}
+export interface CheckoutPaymentMethodTerminal {
+    id: string;
+    label: string;
+    isOnline: boolean;
+    currency: string;
+}
+export interface CheckoutPaymentMethodOptionType {
+    id: string;
+    code: string;
+    name: string;
+    description: string;
+    instruction: string;
+    issuers?: CheckoutPaymentMethodIssuer[];
+    terminals?: CheckoutPaymentMethodTerminal[];
+    pricing?: {
+        fixed: number;
+        percentage: number;
+    };
+}
+export interface CheckoutAgreementOptionConditionType {
+    type: string;
+    amount: number;
+    pastDueAfter: number;
+}
+export interface CheckoutAgreementOptionType {
+    id: string;
+    type: string;
+    name: string;
+    description: string;
+    instructions?: string;
+    conditions: CheckoutAgreementOptionConditionType[];
+}
+export interface CheckoutShippingMethodPickupPoint {
+    id: string;
+    name: string;
+    carrier: string;
+    distance: number;
+    address: {
+        countryCode: string;
+        administrativeArea: string;
+        locality: string;
+        postalCode: string;
+        addressLine1: string;
+        thoroughfare: string;
+        premiseNumber: number;
+        premiseNumberSuffix: string;
+    };
+}
+export interface CheckoutShippingMethodOptionType {
+    id: string;
+    name: string;
+    description: string;
+    instruction: string;
+    carrier: string;
+    isPickupPoint: boolean;
+    pickupPoints: CheckoutShippingMethodPickupPoint[];
+    pricing: {
+        fixed: number;
+        percentage: number;
+    };
+}
+export type CheckoutReviewData = Omit<GetCartReviewCheckoutDataFormatterResponse, 'cart'>;
+export interface CheckoutBranding {
+    colors: {
+        primary: string;
+        secondary: string;
+        success: string;
+        warning: string;
+        error: string;
+        info: string;
+        text: string;
+    };
+    style: 'STRAIGHT' | 'ROUNDED';
+}
+export interface CheckoutLinks {
+    checkout?: string;
+    myAccount?: string;
+    privacyAgreement?: string;
+    termsConditions?: string;
+    vendor?: string;
+}
+export interface CheckoutSettings {
+    branding?: CheckoutBranding;
+    channelLinks?: CheckoutLinks;
+    currency?: string;
+    isAccountEnabled?: boolean;
+    isB2bExcluded?: boolean;
+    isB2cExcluded?: boolean;
+    isPhoneNumberRequired?: boolean;
+    isCocNumberRequired?: boolean;
+    isSharedOrganisationRequired?: boolean;
+    isVatNumberRequired?: boolean;
+    links?: CheckoutLinks;
+    logo?: string;
+    storeName?: string;
+}
+export interface CheckoutEventMap {
+    accountSelected: {
+        account: Account;
+        user: User;
+    };
+    businessAccountSelected: {
+        account: Account;
+        organisation: AccountOrganisation;
+        user: User;
+    };
+    clearSession: {
+        sessionExpired?: boolean;
+        shouldCreateAccount?: boolean;
+    };
+    signedIn: {
+        user: User;
+        account: Account | null;
+    };
+}
+export type CheckoutEventName = keyof CheckoutEventMap;
+export type CheckoutAnalyticsContext = {
+    defaultAnalytics: CheckoutAnalytics;
+    settings: CheckoutSettings;
+};
+export type CheckoutAnalyticsEntry<TEventData, TEventFormattedData extends TEventData, TContext = CheckoutAnalyticsContext> = {
+    formatter?: (eventData: TEventData, context: TContext) => TEventFormattedData;
+    send: (eventData: TEventFormattedData, context: TContext) => void;
+};
+export type CheckoutCustomAnalyticsEntry = CheckoutAnalyticsEntry<any, any>;
+export type CheckoutContext = CheckoutContextType;
+export interface CheckoutStepInitializeContext<TValues = any> {
+    locale: string;
+    defaultCountry: Country;
+    formatCountryAsOption: (country: Country) => CountryOption;
+    getCountryByCode: (code: string) => Country | null;
+    settings: CheckoutSettings;
+    step: CheckoutStep<TValues>;
+}
+export interface CheckoutStepValidationSchemaContext {
+    billingAddressValidationSchema: Record<string, AnySchema>;
+    shippingAddressValidationSchema: Record<string, AnySchema>;
+    settings: CheckoutSettings;
+    subStep: string;
+}
+export interface CheckoutEventStepContext<TValues = any> {
+    step: CheckoutStep<TValues>;
+    stepIndex: number;
+}
+export interface CheckoutStepDefaultValuesContext<TValues = any> {
+    locale: string;
+    defaultCountry: Country;
+    formatCountryAsOption: (country: Country) => CountryOption;
+    getCountryByCode: (code: string) => Country | null;
+    settings: CheckoutSettings;
+    step: CheckoutStep<TValues>;
+}
+export interface CheckoutStepIsCompleteContext<TValues = any> {
+    settings: CheckoutSettings;
+    step: CheckoutStep<TValues>;
+}
+export interface CheckoutStep<TValues = unknown> {
+    key: string;
+    component: ElementType;
+    reviewTargets?: string[];
+    getSubStepForReviewTarget?: (target: string) => string | undefined;
+    label: string;
+    previousLabel?: string | ((context: CheckoutContext) => string);
+    nextLabel?: string | ((context: CheckoutContext) => string);
+    defaultValues: TValues | ((context: CheckoutStepDefaultValuesContext) => TValues);
+    initialize: <TData, TResponse>(data: TData, responseData: TResponse, context: CheckoutStepInitializeContext<TValues>) => TValues;
+    isComplete: (values: TValues, context: CheckoutStepIsCompleteContext) => boolean;
+    onEvent?: <E extends CheckoutEventName>(eventName: E, eventData: CheckoutEventMap[E], stepContext: CheckoutEventStepContext, context: unknown) => void;
+    validationSchema: (context: CheckoutStepValidationSchemaContext) => ObjectSchema<Maybe<AnyObject>>;
+}
+export type CheckoutSteps<TValues = any> = CheckoutStep<TValues>[];
+export interface CheckoutSummaryAdjustment {
+    id: string;
+    description: string;
+    amount: number;
+    isDiscount: boolean;
+    isPercentage: boolean;
+    outcome?: {
+        amount: number;
+    };
+}
+export interface CheckoutSummaryFee {
+    id: string;
+    description: string;
+    total: number;
+}
+export interface CheckoutSummaryCoupon {
+    id: string;
+    code: string;
+}
+export interface CheckoutSummaryVatItem {
+    rate: number;
+    amount: number;
+}
+export interface CheckoutBaseItem {
+    sku: string;
+    label?: string;
+    image?: string;
+    quantity: number;
+    subtotal: number;
+    total: number;
+    adjustments: CheckoutSummaryAdjustment[];
+}
+export type CheckoutAgreementType = 'DOWN_PAYMENT' | 'POST_PAID' | 'COD' | 'MARKETPLACE';
+export interface CheckoutSummaryAgreement {
+    type: CheckoutAgreementType;
+    originalPercentage: number;
+    amount: number;
+    dueAt: number;
+    dueAfter: number;
+}
+export interface CheckoutSummaryAgreementOptionCondition {
+    type: CheckoutAgreementType;
+    amount: number;
+    pastDueAfter: number;
+}
+export interface CheckoutSummaryAgreementOption {
+    id: string;
+    type: CheckoutAgreementType | 'DEFAULT';
+    name: string;
+    description: string;
+    instructions: string;
+    conditions: CheckoutSummaryAgreementOptionCondition[];
+}
+export interface CheckoutSummaryType {
+    adjustments: CheckoutSummaryAdjustment[];
+    agreements: CheckoutSummaryAgreement[];
+    agreementTemplate: CheckoutSummaryAgreementOption | null;
+    coupons: CheckoutSummaryCoupon[];
+    currency: string;
+    fees: {
+        shipping: CheckoutSummaryFee[];
+        payment: CheckoutSummaryFee[];
+    };
+    isIncludingVat: boolean;
+    isVatShifted: boolean;
+    items: CheckoutBaseItem[];
+    subtotal: number;
+    total: number;
+    totalExcludingVat: number;
+    vat: CheckoutSummaryVatItem[];
+}
+export interface CheckoutAuthOperationContext<TOperations = any> {
+    defaultOperations: CheckoutAuthOperations;
+    operations: TOperations;
+    settings: CheckoutSettings;
+    storefront: StorefrontClient;
+}
+export interface CheckoutOperationContext<TOperations = any, TDefaultOperations = any> extends UseCheckoutAuthContext, UseCheckoutFormContext, UseCheckoutSummaryContext, UseCheckoutAnalyticsContext {
+    defaultOperations: TDefaultOperations;
+    operations: TOperations;
+    storefront: StorefrontClient;
+    settings: CheckoutSettings;
+}
+export interface CheckoutOperationEntry<TParams, TResponse, TFormatterResponse = TResponse, TContext = CheckoutOperationContext> {
+    queryFn: (params: TParams, context: TContext) => Promise<TResponse>;
+    formatter: (response: TResponse, context: TContext) => TFormatterResponse | Promise<TFormatterResponse>;
+    success: (data: TFormatterResponse, context: TContext) => void | Promise<void>;
+    error: (error: Error | null) => void | Promise<void>;
+}
+export type CheckoutCustomOperationEntry = CheckoutOperationEntry<any, any, any>;
+export type TranslationMessage = string | Record<string, string>;
+export interface CheckoutAddressFieldsTranslations {
+    additionalName: string;
+    addressLine2: string;
+    country: string;
+    familyName: string;
+    givenName: string;
+    locality: string;
+    organisation: string;
+    postal: string;
+    postalCode: string;
+    postTown: string;
+    premiseNumber: string;
+    premiseNumberSuffix: string;
+    province: string;
+    state: string;
+    suburb: string;
+    thoroughfare: string;
+    zip: string;
+    [key: string]: string;
+}
+export interface CheckoutValidationTranslations {
+    booleanRequired: string;
+    email: string;
+    equalEmail: string;
+    equalPassword: string;
+    invalidFormat: string;
+    matches: string;
+    notEqualPassword: string;
+    numbersOnly: string;
+    maxLength: string;
+    phoneNumber: string;
+    required: string;
+    validEmail: string;
+    validVATNumber: string;
+    [key: string]: string;
+}
+export interface CheckoutTranslations {
+    accountSelection?: CheckoutAccountSelectionProps['translations'];
+    addressFields?: Partial<CheckoutAddressFieldsTranslations>;
+    addressSection?: CheckoutAddressSectionProps['translations'];
+    agreementOptionConditions?: CheckoutAgreementOptionConditionProps['translations'];
+    agreementOptionsField?: CheckoutAgreementOptionsFieldProps['translations'];
+    agreementOptionsSection?: CheckoutAgreementOptionsSectionProps['translations'];
+    agreementsTimeline?: CheckoutAgreementsTimelineProps['translations'];
+    agreementSummaryCard?: CheckoutAgreementSummaryCardProps['translations'];
+    billingAddressSection?: CheckoutBillingAddressSectionProps['translations'];
+    businessDetailsCard?: CheckoutBusinessDetailsCardProps['translations'];
+    businessInformationSection?: CheckoutBusinessInformationSectionProps['translations'];
+    checkoutForm?: CheckoutFormProps['translations'];
+    commentField?: CheckoutCommentFieldProps['translations'];
+    contactDetailsCard?: CheckoutContactDetailsCardProps['translations'];
+    contactInformationSection?: CheckoutContactInformationSectionProps['translations'];
+    downPaymentsSummary?: CheckoutDownPaymentAgreementsSummaryProps['translations'];
+    expressCheckoutSection?: CheckoutExpressCheckoutSectionProps['translations'];
+    forgotPassword?: CheckoutForgotPasswordProps['translations'];
+    issuersField?: CheckoutIssuersFieldProps['translations'];
+    methodSummaryCard?: CheckoutMethodSummaryCardProps['translations'];
+    notFound?: CheckoutNotFoundFeedbackProps['translations'];
+    paymentMethodSection?: CheckoutPaymentMethodSectionProps['translations'];
+    paymentMethodsField?: CheckoutPaymentMethodsFieldProps['translations'];
+    phoneNumberCard?: CheckoutPhoneNumberCardProps['translations'];
+    pickupPointsField?: CheckoutPickupPointsFieldProps['translations'];
+    pricingLabel?: CheckoutPricingLabelProps['translations'];
+    reviewCommentSection?: CheckoutReviewCommentSectionProps['translations'];
+    reviewItemsSection?: CheckoutReviewItemsSectionProps['translations'];
+    reviewOrderSection?: CheckoutReviewOrderSectionProps['translations'];
+    reviewPaymentSection?: CheckoutReviewPaymentSectionProps['translations'];
+    reviewShippingSection?: CheckoutReviewShippingSectionProps['translations'];
+    shippingAddressSection?: CheckoutShippingAddressSectionProps['translations'];
+    shippingMethodSection?: CheckoutShippingMethodSectionProps['translations'];
+    shippingMethodsField?: CheckoutShippingMethodsFieldProps['translations'];
+    signedInAsMessage?: CheckoutSignedInAsMessageProps['translations'];
+    signIn?: CheckoutSignInProps['translations'];
+    summary?: CheckoutSummaryProps['translations'];
+    summaryDrawer?: CheckoutSummaryDrawerProps['translations'];
+    terminalsField?: CheckoutTerminalsFieldProps['translations'];
+    termsAndPrivacyMessage?: CheckoutTermsAndPrivacyMessageProps['translations'];
+    typeSection?: CheckoutTypeSectionProps['translations'];
+    validation?: Partial<CheckoutValidationTranslations>;
+    [key: string]: unknown;
+}
+//# sourceMappingURL=types.d.ts.map