@gem-sdk/adapter-common 1.0.0

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/types/types/cart.d.ts

@@ -0,0 +1,205 @@
+import type { Discount, Measurement, Image } from './common';
+export type SelectedOption = {
+    id?: string;
+    name: string;
+    value: string;
+};
+export type Attribute = {
+    key: string;
+    value?: string;
+};
+export type LineItem = {
+    id: string;
+    variantId: string;
+    productId: string;
+    productTitle: string;
+    name: string;
+    quantity: number;
+    discounts: Discount[];
+    path?: string;
+    variant: ProductVariant;
+    options?: SelectedOption[];
+    attributes?: Attribute[];
+};
+export type ProductVariant = {
+    id: string;
+    sku: string;
+    name: string;
+    requiresShipping: boolean;
+    price: number;
+    listPrice: number;
+    image?: Image;
+    isInStock?: boolean;
+    availableForSale?: boolean;
+    weight?: Measurement;
+    height?: Measurement;
+    width?: Measurement;
+    depth?: Measurement;
+};
+export type Cart = {
+    id: string;
+    customerId?: string;
+    email?: string;
+    createdAt: string;
+    currency: {
+        code?: string;
+    };
+    taxesIncluded: boolean;
+    lineItems: LineItem[];
+    lineItemsSubtotalPrice: number;
+    subtotalPrice: number;
+    totalPrice: number;
+    discounts?: Discount[];
+    checkoutUrl?: string;
+    /** Cart note */
+    note?: string;
+};
+/**
+ * Base cart item body used for cart mutations
+ */
+export type CartItemBody = {
+    variantId: string;
+    productId?: string;
+    quantity?: number;
+    attributes?: {
+        key: string;
+        value: string;
+    }[];
+};
+/**
+ * Hooks schema
+ */
+export type CartTypes = {
+    cart?: Cart;
+    item: LineItem;
+    itemBody: CartItemBody;
+};
+export type CartHooks<T extends CartTypes = CartTypes> = {
+    getCart: GetCartHook<T>;
+    addItem: AddItemHook<T>;
+    updateItem: UpdateItemHook<T>;
+    removeItem: RemoveItemHook<T>;
+};
+export type GetCartHook<T extends CartTypes = CartTypes> = {
+    data: T['cart'] | null;
+    input: {};
+    fetcherInput: {
+        cartId?: string;
+    };
+    swrState: {
+        isEmpty: boolean;
+    };
+};
+export type AddItemHook<T extends CartTypes = CartTypes> = {
+    data: T['cart'];
+    input?: T['itemBody'];
+    fetcherInput: T['itemBody'];
+    body: {
+        item: T['itemBody'];
+    };
+    actionInput: T['itemBody'];
+};
+export type UpdateItemHook<T extends CartTypes = CartTypes> = {
+    data: T['cart'] | null;
+    input: {
+        item?: T['item'];
+        wait?: number;
+    };
+    fetcherInput: {
+        itemId: string;
+        item: T['itemBody'];
+    };
+    body: {
+        itemId: string;
+        item: T['itemBody'];
+    };
+    actionInput: T['itemBody'] & {
+        id: string;
+    };
+};
+export type RemoveItemHook<T extends CartTypes = CartTypes> = {
+    data: T['cart'] | null;
+    input: {
+        item?: T['item'];
+    };
+    fetcherInput: {
+        itemId: string;
+    };
+    body: {
+        itemId: string;
+    };
+    actionInput: {
+        id: string;
+    };
+};
+/**
+ * API Schema
+ */
+export type CartSchema<T extends CartTypes = CartTypes> = {
+    endpoint: {
+        options: {};
+        handlers: CartHandlers<T>;
+    };
+};
+export type CartHandlers<T extends CartTypes = CartTypes> = {
+    getCart: GetCartHandler<T>;
+    addItem: AddItemHandler<T>;
+    updateItem: UpdateItemHandler<T>;
+    removeItem: RemoveItemHandler<T>;
+};
+export type GetCartHandler<T extends CartTypes = CartTypes> = GetCartHook<T> & {
+    body: {
+        cartId?: string;
+    };
+};
+export type AddItemHandler<T extends CartTypes = CartTypes> = AddItemHook<T> & {
+    body: {
+        cartId: string;
+    };
+};
+export type UpdateItemHandler<T extends CartTypes = CartTypes> = UpdateItemHook<T> & {
+    data: T['cart'];
+    body: {
+        cartId: string;
+    };
+};
+export type RemoveItemHandler<T extends CartTypes = CartTypes> = RemoveItemHook<T> & {
+    body: {
+        cartId: string;
+    };
+};
+export type RemoveCartLineInput = {
+    cartId: string;
+    lineId: string;
+};
+export type UpdateCartLineInput = {
+    cartId: string;
+    line: CartItemBody & {
+        id: string;
+    };
+};
+export type AddCartLineInput = {
+    cartId: string;
+    lines: CartItemBody[];
+};
+export type CreateCartInput = {
+    items: CartItemBody[];
+};
+export type GetCartParams = {
+    cartId: string;
+};
+export type CartNoteUpdateInput = {
+    cartId: string;
+    note?: string;
+};
+export type CartDiscountCodesUpdateInput = {
+    cartId: string;
+    discountCodes?: string[];
+};
+export type GetCartFunc = (variables: GetCartParams) => Promise<Cart | undefined>;
+export type CreateCartFunc = (variables: CreateCartInput) => Promise<Cart>;
+export type UpdateCartLineFunc = (variables: UpdateCartLineInput) => Promise<Cart>;
+export type RemoveCartLineFunc = (variables: RemoveCartLineInput) => Promise<Cart>;
+export type AddCartLineFunc = (variables: AddCartLineInput) => Promise<Cart>;
+export type CartNoteUpdateFunc = (variables: CartNoteUpdateInput) => Promise<Cart>;
+export type CartDiscountCodesUpdateFunc = (variables: CartDiscountCodesUpdateInput) => Promise<Cart>;

package/dist/types/types/checkout.d.ts

@@ -0,0 +1,53 @@
+import type { Address, AddressFields } from './customer/address';
+import type { Card, CardFields } from './customer/card';
+export type Checkout = any;
+export type CheckoutTypes = {
+    card?: Card | CardFields;
+    address?: Address | AddressFields;
+    checkout?: Checkout;
+    hasPayment?: boolean;
+    hasShipping?: boolean;
+};
+export type SubmitCheckoutHook<T extends CheckoutTypes = CheckoutTypes> = {
+    data: T;
+    input?: T;
+    fetcherInput: T;
+    body: {
+        item: T;
+    };
+    actionInput: T;
+};
+export type GetCheckoutHook<T extends CheckoutTypes = CheckoutTypes> = {
+    data: T['checkout'] | null;
+    input: {};
+    fetcherInput: {
+        cartId?: string;
+    };
+    swrState: {
+        isEmpty: boolean;
+    };
+};
+export type CheckoutHooks<T extends CheckoutTypes = CheckoutTypes> = {
+    submitCheckout?: SubmitCheckoutHook<T>;
+    getCheckout: GetCheckoutHook<T>;
+};
+export type GetCheckoutHandler<T extends CheckoutTypes = CheckoutTypes> = GetCheckoutHook<T> & {
+    body: {
+        cartId: string;
+    };
+};
+export type SubmitCheckoutHandler<T extends CheckoutTypes = CheckoutTypes> = SubmitCheckoutHook<T> & {
+    body: {
+        cartId: string;
+    };
+};
+export type CheckoutHandlers<T extends CheckoutTypes = CheckoutTypes> = {
+    getCheckout: GetCheckoutHandler<T>;
+    submitCheckout?: SubmitCheckoutHandler<T>;
+};
+export type CheckoutSchema<T extends CheckoutTypes = CheckoutTypes> = {
+    endpoint: {
+        options: {};
+        handlers: CheckoutHandlers<T>;
+    };
+};

package/dist/types/types/common.d.ts

@@ -0,0 +1,15 @@
+export type Discount = {
+    value?: number;
+    code: string;
+    applicable?: boolean;
+};
+export type Measurement = {
+    value: number;
+    unit: 'KILOGRAMS' | 'GRAMS' | 'POUNDS' | 'OUNCES';
+};
+export type Image = {
+    url: string;
+    altText?: string;
+    width?: number;
+    height?: number;
+};

package/dist/types/types/customer/address.d.ts

@@ -0,0 +1,110 @@
+export interface Address {
+    id: string;
+    mask: string;
+}
+export interface AddressFields {
+    type: string;
+    firstName: string;
+    lastName: string;
+    company: string;
+    streetNumber: string;
+    apartments: string;
+    zipCode: string;
+    city: string;
+    country: string;
+}
+export type CustomerAddressTypes = {
+    address?: Address;
+    fields: AddressFields;
+};
+export type GetAddressesHook<T extends CustomerAddressTypes = CustomerAddressTypes> = {
+    data: T['address'][] | null;
+    input: {};
+    fetcherInput: {
+        cartId?: string;
+    };
+    swrState: {
+        isEmpty: boolean;
+    };
+};
+export type AddItemHook<T extends CustomerAddressTypes = CustomerAddressTypes> = {
+    data: T['address'];
+    input?: T['fields'];
+    fetcherInput: T['fields'];
+    body: {
+        item: T['fields'];
+    };
+    actionInput: T['fields'];
+};
+export type UpdateItemHook<T extends CustomerAddressTypes = CustomerAddressTypes> = {
+    data: T['address'] | null;
+    input: {
+        item?: T['fields'];
+        wait?: number;
+    };
+    fetcherInput: {
+        itemId: string;
+        item: T['fields'];
+    };
+    body: {
+        itemId: string;
+        item: T['fields'];
+    };
+    actionInput: T['fields'] & {
+        id: string;
+    };
+};
+export type RemoveItemHook<T extends CustomerAddressTypes = CustomerAddressTypes> = {
+    data: T['address'] | null;
+    input: {
+        item?: T['address'];
+    };
+    fetcherInput: {
+        itemId: string;
+    };
+    body: {
+        itemId: string;
+    };
+    actionInput: {
+        id: string;
+    };
+};
+export type CustomerAddressHooks<T extends CustomerAddressTypes = CustomerAddressTypes> = {
+    getAddresses: GetAddressesHook<T>;
+    addItem: AddItemHook<T>;
+    updateItem: UpdateItemHook<T>;
+    removeItem: RemoveItemHook<T>;
+};
+export type AddressHandler<T extends CustomerAddressTypes = CustomerAddressTypes> = GetAddressesHook<T> & {
+    body: {
+        cartId?: string;
+    };
+};
+export type AddItemHandler<T extends CustomerAddressTypes = CustomerAddressTypes> = AddItemHook<T> & {
+    body: {
+        cartId: string;
+    };
+};
+export type UpdateItemHandler<T extends CustomerAddressTypes = CustomerAddressTypes> = UpdateItemHook<T> & {
+    data: T['address'];
+    body: {
+        cartId: string;
+    };
+};
+export type RemoveItemHandler<T extends CustomerAddressTypes = CustomerAddressTypes> = RemoveItemHook<T> & {
+    body: {
+        cartId: string;
+    };
+};
+export type CustomerAddressHandlers<T extends CustomerAddressTypes = CustomerAddressTypes> = {
+    getAddresses: GetAddressesHook<T>;
+    addItem: AddItemHandler<T>;
+    updateItem: UpdateItemHandler<T>;
+    removeItem: RemoveItemHandler<T>;
+};
+export type CustomerAddressSchema<T extends CustomerAddressTypes = CustomerAddressTypes> = {
+    endpoint: {
+        options: {};
+        handlers: CustomerAddressHandlers<T>;
+    };
+};

package/dist/types/types/customer/card.d.ts

@@ -0,0 +1,113 @@
+export interface Card {
+    id: string;
+    mask: string;
+    provider: string;
+}
+export interface CardFields {
+    cardHolder: string;
+    cardNumber: string;
+    cardExpireDate: string;
+    cardCvc: string;
+    firstName: string;
+    lastName: string;
+    company: string;
+    streetNumber: string;
+    zipCode: string;
+    city: string;
+    country: string;
+}
+export type CustomerCardTypes = {
+    card?: Card;
+    fields: CardFields;
+};
+export type GetCardsHook<T extends CustomerCardTypes = CustomerCardTypes> = {
+    data: T['card'][] | null;
+    input: {};
+    fetcherInput: {
+        cartId?: string;
+    };
+    swrState: {
+        isEmpty: boolean;
+    };
+};
+export type AddItemHook<T extends CustomerCardTypes = CustomerCardTypes> = {
+    data: T['card'];
+    input?: T['fields'];
+    fetcherInput: T['fields'];
+    body: {
+        item: T['fields'];
+    };
+    actionInput: T['fields'];
+};
+export type UpdateItemHook<T extends CustomerCardTypes = CustomerCardTypes> = {
+    data: T['card'] | null;
+    input: {
+        item?: T['fields'];
+        wait?: number;
+    };
+    fetcherInput: {
+        itemId: string;
+        item: T['fields'];
+    };
+    body: {
+        itemId: string;
+        item: T['fields'];
+    };
+    actionInput: T['fields'] & {
+        id: string;
+    };
+};
+export type RemoveItemHook<T extends CustomerCardTypes = CustomerCardTypes> = {
+    data: T['card'] | null;
+    input: {
+        item?: T['card'];
+    };
+    fetcherInput: {
+        itemId: string;
+    };
+    body: {
+        itemId: string;
+    };
+    actionInput: {
+        id: string;
+    };
+};
+export type CustomerCardHooks<T extends CustomerCardTypes = CustomerCardTypes> = {
+    getCards: GetCardsHook<T>;
+    addItem: AddItemHook<T>;
+    updateItem: UpdateItemHook<T>;
+    removeItem: RemoveItemHook<T>;
+};
+export type CardsHandler<T extends CustomerCardTypes = CustomerCardTypes> = GetCardsHook<T> & {
+    body: {
+        cartId?: string;
+    };
+};
+export type AddItemHandler<T extends CustomerCardTypes = CustomerCardTypes> = AddItemHook<T> & {
+    body: {
+        cartId: string;
+    };
+};
+export type UpdateItemHandler<T extends CustomerCardTypes = CustomerCardTypes> = UpdateItemHook<T> & {
+    data: T['card'];
+    body: {
+        cartId: string;
+    };
+};
+export type RemoveItemHandler<T extends CustomerCardTypes = CustomerCardTypes> = RemoveItemHook<T> & {
+    body: {
+        cartId: string;
+    };
+};
+export type CustomerCardHandlers<T extends CustomerCardTypes = CustomerCardTypes> = {
+    getCards: GetCardsHook<T>;
+    addItem: AddItemHandler<T>;
+    updateItem: UpdateItemHandler<T>;
+    removeItem: RemoveItemHandler<T>;
+};
+export type CustomerCardSchema<T extends CustomerCardTypes = CustomerCardTypes> = {
+    endpoint: {
+        options: {};
+        handlers: CustomerCardHandlers<T>;
+    };
+};

package/dist/types/types/customer/index.d.ts

@@ -0,0 +1,24 @@
+export * as Card from './card';
+export * as Address from './address';
+export type Customer = any;
+export type CustomerTypes = {
+    customer: Customer;
+};
+export type CustomerHook<T extends CustomerTypes = CustomerTypes> = {
+    data: T['customer'] | null;
+    fetchData: {
+        customer: T['customer'];
+    } | null;
+};
+export type CustomerSchema<T extends CustomerTypes = CustomerTypes> = {
+    endpoint: {
+        options: {};
+        handlers: {
+            getLoggedInCustomer: {
+                data: {
+                    customer: T['customer'];
+                } | null;
+            };
+        };
+    };
+};

package/dist/types/types/global-style.d.ts

@@ -0,0 +1,32 @@
+export type TypographyProps = {
+    fontSize?: string;
+    fontWeight?: string | number;
+    fontStyle?: string;
+    fontFamily?: string;
+    lineHeight?: string;
+    letterSpacing?: string;
+};
+type ColorType = 'brand' | 'text' | 'background' | 'line';
+type FuncColorObject = {
+    info: string;
+    warn: string;
+    success: string;
+    danger: string;
+};
+type TypographyType = 'heading-1' | 'heading-2' | 'heading-3' | 'subheading-1' | 'subheading-2' | 'subheading-3' | 'paragraph-1' | 'paragraph-2' | 'paragraph-3';
+type ObjectDeviceType<T> = {
+    desktop: T;
+    tablet?: T;
+    mobile?: T;
+};
+type SpacingType = 'xxs' | 'xs' | 's' | 'm' | 'l' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl';
+type RoundedSize = 'small' | 'medium' | 'large';
+export type GlobalStyleConfig = {
+    color: Record<ColorType, Record<string, string>> & {
+        func: FuncColorObject;
+    };
+    typography: Record<TypographyType, ObjectDeviceType<TypographyProps>>;
+    spacing: Record<SpacingType, ObjectDeviceType<string>>;
+    radius: Record<RoundedSize, string>;
+};
+export {};

package/dist/types/types/index.d.ts

@@ -0,0 +1,13 @@
+import type * as Cart from './cart';
+import type * as Checkout from './checkout';
+import type * as Common from './common';
+import type * as Customer from './customer';
+import type * as Login from './login';
+import type * as Logout from './logout';
+import type * as Page from './page';
+import type * as Product from './product';
+import type * as Signup from './signup';
+import type * as Site from './site';
+import type * as Wishlist from './wishlist';
+import type { GlobalStyleConfig, TypographyProps } from './global-style';
+export type { Cart, Checkout, Common, Customer, Login, Logout, Page, Product, Signup, Site, Wishlist, GlobalStyleConfig, TypographyProps, };

package/dist/types/types/login.d.ts

@@ -0,0 +1,27 @@
+export type LoginBody = {
+    email: string;
+    password: string;
+};
+export type LoginTypes = {
+    body: LoginBody;
+};
+export type LoginHook<T extends LoginTypes = LoginTypes> = {
+    data: null;
+    actionInput: LoginBody;
+    fetcherInput: LoginBody;
+    body: T['body'];
+};
+export type LoginSchema<T extends LoginTypes = LoginTypes> = {
+    endpoint: {
+        options: {};
+        handlers: {
+            login: LoginHook<T>;
+        };
+    };
+};
+export type LoginOperation = {
+    data: {
+        result?: string;
+    };
+    variables: unknown;
+};

package/dist/types/types/logout.d.ts

@@ -0,0 +1,17 @@
+export type LogoutTypes = {
+    body: {
+        redirectTo?: string;
+    };
+};
+export type LogoutHook<T extends LogoutTypes = LogoutTypes> = {
+    data: null;
+    body: T['body'];
+};
+export type LogoutSchema<T extends LogoutTypes = LogoutTypes> = {
+    endpoint: {
+        options: {};
+        handlers: {
+            logout: LogoutHook<T>;
+        };
+    };
+};

package/dist/types/types/page.d.ts

@@ -0,0 +1,24 @@
+export type Page = {
+    id: string;
+    name: string;
+    url?: string;
+    body: string;
+    is_visible?: boolean;
+    sort_order?: number;
+};
+export type PageTypes = {
+    page: Page;
+};
+export type GetAllPagesOperation<T extends PageTypes = PageTypes> = {
+    data: {
+        pages: T['page'][];
+    };
+};
+export type GetPageOperation<T extends PageTypes = PageTypes> = {
+    data: {
+        page?: T['page'];
+    };
+    variables: {
+        id: string;
+    };
+};

package/dist/types/types/product.d.ts

@@ -0,0 +1,100 @@
+export type ProductImage = {
+    url: string;
+    alt?: string;
+};
+export type ProductPrice = {
+    value: number;
+    currencyCode?: 'USD' | 'EUR' | 'ARS' | 'GBP' | string;
+    retailPrice?: number;
+    salePrice?: number;
+    listPrice?: number;
+    extendedSalePrice?: number;
+    extendedListPrice?: number;
+};
+export type ProductOption = {
+    __typename?: 'MultipleChoiceOption';
+    id: string;
+    displayName: string;
+    values: ProductOptionValues[];
+};
+export type ProductOptionValues = {
+    label: string;
+    hexColors?: string[];
+};
+export type ProductVariant = {
+    id: string | number;
+    options: ProductOption[];
+    availableForSale?: boolean;
+};
+export type Product = {
+    id: string;
+    name: string;
+    description: string;
+    descriptionHtml?: string;
+    sku?: string;
+    slug?: string;
+    path?: string;
+    images: ProductImage[];
+    variants: ProductVariant[];
+    price: ProductPrice;
+    options: ProductOption[];
+    vendor?: string;
+};
+export type SearchProductsBody = {
+    search?: string;
+    categoryId?: string | number;
+    brandId?: string | number;
+    sort?: string;
+    locale?: string;
+};
+export type ProductTypes = {
+    product: Product;
+    searchBody: SearchProductsBody;
+};
+export type SearchProductsHook<T extends ProductTypes = ProductTypes> = {
+    data: {
+        products: T['product'][];
+        found: boolean;
+    };
+    body: T['searchBody'];
+    input: T['searchBody'];
+    fetcherInput: T['searchBody'];
+};
+export type ProductsSchema<T extends ProductTypes = ProductTypes> = {
+    endpoint: {
+        options: {};
+        handlers: {
+            getProducts: SearchProductsHook<T>;
+        };
+    };
+};
+export type GetAllProductPathsOperation<T extends ProductTypes = ProductTypes> = {
+    data: {
+        products: Pick<T['product'], 'path'>[];
+    };
+    variables: {
+        first?: number;
+    };
+};
+export type GetAllProductsOperation<T extends ProductTypes = ProductTypes> = {
+    data: {
+        products: T['product'][];
+    };
+    variables: {
+        relevance?: 'featured' | 'best_selling' | 'newest';
+        ids?: string[];
+        first?: number;
+    };
+};
+export type GetProductOperation<T extends ProductTypes = ProductTypes> = {
+    data: {
+        product?: T['product'];
+    };
+    variables: {
+        path: string;
+        slug?: never;
+    } | {
+        path?: never;
+        slug: string;
+    };
+};

package/dist/types/types/signup.d.ts

@@ -0,0 +1,23 @@
+export type SignupBody = {
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+};
+export type SignupTypes = {
+    body: SignupBody;
+};
+export type SignupHook<T extends SignupTypes = SignupTypes> = {
+    data: null;
+    body: T['body'];
+    actionInput: T['body'];
+    fetcherInput: T['body'];
+};
+export type SignupSchema<T extends SignupTypes = SignupTypes> = {
+    endpoint: {
+        options: {};
+        handlers: {
+            signup: SignupHook<T>;
+        };
+    };
+};

package/dist/types/types/site.d.ts

@@ -0,0 +1,21 @@
+export type Category = {
+    id: string;
+    name: string;
+    slug: string;
+    path: string;
+};
+export type Brand = any;
+export type SiteTypes = {
+    category: Category;
+    brand: Brand;
+};
+export type GetSiteInfoOperation<T extends SiteTypes = SiteTypes> = {
+    data: {
+        categories: T['category'][];
+        brands: T['brand'][];
+    };
+};
+export type ProviderConfig = {
+    storefrontUrl?: string;
+    storefrontToken?: string;
+};

package/dist/types/types/wishlist.d.ts

@@ -0,0 +1,83 @@
+export type Wishlist = any;
+export type WishlistItemBody = {
+    variantId: string | number;
+    productId: string;
+};
+export type WishlistTypes = {
+    wishlist: Wishlist;
+    itemBody: WishlistItemBody;
+};
+export type GetWishlistHook<T extends WishlistTypes = WishlistTypes> = {
+    data: T['wishlist'] | null;
+    body: {
+        includeProducts?: boolean;
+    };
+    input: {
+        includeProducts?: boolean;
+    };
+    fetcherInput: {
+        customerId: string;
+        includeProducts?: boolean;
+    };
+    swrState: {
+        isEmpty: boolean;
+    };
+};
+export type AddItemHook<T extends WishlistTypes = WishlistTypes> = {
+    data: T['wishlist'];
+    body: {
+        item: T['itemBody'];
+    };
+    fetcherInput: {
+        item: T['itemBody'];
+    };
+    actionInput: T['itemBody'];
+};
+export type RemoveItemHook<T extends WishlistTypes = WishlistTypes> = {
+    data: T['wishlist'] | null;
+    body: {
+        itemId: string;
+    };
+    fetcherInput: {
+        itemId: string;
+    };
+    actionInput: {
+        id: string;
+    };
+    input: {
+        wishlist?: {
+            includeProducts?: boolean;
+        };
+    };
+};
+export type WishlistSchema<T extends WishlistTypes = WishlistTypes> = {
+    endpoint: {
+        options: {};
+        handlers: {
+            getWishlist: GetWishlistHook<T> & {
+                data: T['wishlist'] | null;
+                body: {
+                    customerToken?: string;
+                };
+            };
+            addItem: AddItemHook<T> & {
+                body: {
+                    customerToken?: string;
+                };
+            };
+            removeItem: RemoveItemHook<T> & {
+                body: {
+                    customerToken?: string;
+                };
+            };
+        };
+    };
+};
+export type GetCustomerWishlistOperation<T extends WishlistTypes = WishlistTypes> = {
+    data: {
+        wishlist?: T['wishlist'];
+    };
+    variables: {
+        customerId: string;
+    };
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@gem-sdk/adapter-common",
+  "version": "1.0.0",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "pre:publish": "node ./scripts/convert-publish.js -p",
+    "post:publish": "node ./scripts/convert-publish.js",
+    "cleanup": "rimraf es dist lib",
+    "prebuild": "yarn cleanup",
+    "ts-types": "tsc -p tsconfig.json --emitDeclarationOnly --noEmit false",
+    "build": "yarn ts-types",
+    "type-check": "yarn tsc --noEmit",
+    "lint": "eslint ./src --ext .tsx,.ts"
+  },
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/types/index.d.ts"
+    }
+  }
+}