Marketplace

const marketplace = await client.marketplace.getMarketplaceInfo({});

// {
//   marketplace: true,
//   mode: "marketplace",
//   name: "Acme Marketplace",
//   logo_url: "https://.../logo.png",
//   primary_color: "#3B82F6",
//   tagline: "Everything, from everyone",
//   support_email: "help@acme.market",
//   description: "...",
//   website: "https://acme.market",
//   phone: "+1 555 0100",
//   address: "...",
//   unified_checkout: true,      // is cross-merchant checkout enabled?
//   commission_enabled: true     // does the marketplace charge commission?
// }

document.title = marketplace.name;
applyTheme(marketplace.primary_color);

const merchant = await client.marketplace.getMarketplaceInfo({
  storeId: 'merchant-a-uuid',
  sections: 'catalog,shipping,features',   // optional: request only what you need
});

console.log(merchant.store.name, merchant.store.logo_url, merchant.store.description);
console.log(`${merchant.catalog?.products.total} products`);     // a COUNT, not the full list
console.log(merchant.catalog?.products.sample);                  // a thin sample (≤10) for context

const order = await client.marketplace.marketplaceCheckout({
  requestBody: {
    items: [
      { product_id: 'p1', variant_id: 'v1', merchant_store_id: 'merchant-a-uuid', quantity: 1 },
      { product_id: 'p2', variant_id: 'v2', merchant_store_id: 'merchant-b-uuid', quantity: 2 },
    ],
    customer_email: 'john.doe@tybritelabs.com',
    customer_name: 'John Doe',
    currency: 'USD',
    shipping_address: { line1: '1 Market St', city: 'San Francisco', country: 'US' },
    billing_address:  { line1: '1 Market St', city: 'San Francisco', country: 'US' },
    // Optional: apply a merchant's own promotion / gift card to that merchant's portion.
    discounts: [
      { merchant_store_id: 'merchant-a-uuid', promotion_id: 'promo-uuid', gift_card_code: 'GC-XXXX-YYYY' },
    ],
  },
});

// Show the shopper what each merchant receives (already computed for you):
order.merchant_breakdown.forEach(m =>
  console.log(`${m.merchant_store_id}: gross ${m.gross_amount}, discount ${m.discount_amount}, fee ${m.commission_amount}, net ${m.net_amount}`)
);

// Total savings on the basket (per-merchant discounts + any marketplace-wide promotion):
console.log(`saved ${order.discount_total} (${order.operator_funded_discount} funded by the marketplace)`);

// Complete the payment on the storefront with the returned client_secret:
const stripe = Stripe(STRIPE_PUBLISHABLE_KEY);
const { error } = await stripe.confirmPayment({
  clientSecret: order.client_secret,
  confirmParams: { return_url: 'https://shop.example.com/order/confirmation' },
});

{
  order_group_id: string,       // the unified order's id
  group_number: string,         // human-friendly reference, e.g. "MKT-2026-000123"
  payment_intent_id: string,    // the payment intent (pi_...)
  client_secret: string,        // pass to Stripe.js to collect payment
  currency: string,
  subtotal: number,
  total_amount: number,
  discount_total?: number,             // total discount across the basket
  operator_funded_discount?: number,   // the share funded by the marketplace operator
  discount_breakdown?: Array<{
    merchant_store_id: string,
    merchant_discount: number,         // funded by this merchant's own promotion
    gift_card_amount: number,          // redeemed from a gift card against this merchant
    operator_funded_discount: number,  // operator-funded portion for this merchant
  }>,
  merchant_breakdown: Array<{
    merchant_store_id: string,
    merchant_gross: number,            // before discount
    discount_amount: number,           // discount applied to this merchant's portion
    gross_amount: number,              // after discount, before commission
    commission_amount: number,
    net_amount: number,
    commission_rule_id: string | null,
  }>,
}

// 1. Sign the shopper in (operator key) to get a session token:
const { session } = await client.authentication.login({
  requestBody: { email: 'john.doe@tybritelabs.com', password: '...' },
});

// 2. Fetch their unified profile:
const profile = await client.marketplace.getMarketplaceCustomer({
  xCustomerToken: session.access_token,
});

console.log(profile.customer.email);
console.log(`${profile.stores.length} merchant relationships`);
console.log(`${profile.orders.length} orders across all merchants`);

{
  customer: { ids: string[], email, name, phone, ... },  // unified identity
  stores:   Array<{ store_id, ...affiliation }>,          // per-merchant relationships
  orders:   Array<{ ... }>,                               // cross-merchant order history
}

const market = new Tybrite({ apiKey: 'tybrite_pk_live_operator_...' });

// Combined catalog across all merchants (each product has merchant_store_id):
const { products } = await market.products.listProducts({ limit: 24 });

// Deduplicated taxonomy across merchants:
const { categories } = await market.taxonomy.listCategories();

// Cross-merchant search:
const results = await market.search.searchProducts({ q: 'headphones' });

const storeId = 'merchant-a-uuid';

const header        = await market.marketplace.getMarketplaceInfo({ storeId });   // shop-page header
const { products }  = await market.products.listProducts({ storeId });            // that merchant's catalog
const { categories} = await market.taxonomy.listCategories({ storeId });          // that merchant's categories
const results       = await market.search.searchProducts({ q: 'case', storeId }); // search within the merchant

const reviews = await market.reviews.listReviews({
  productId: 'product-uuid',
  storeId:   'merchant-a-uuid',   // required when using an operator key
});

const storeId = 'merchant-a-uuid';   // the merchant whose order this is

// lodge a return for the signed-in shopper at that merchant
const { data: lodged } = await market.returns.createReturn({
  storeId, xAuthToken: shopperSession,
  requestBody: { order_id, reason_code: 'damaged', items },
});

// the shopper's returns + store-credit at that merchant
const { data: mine }    = await market.returns.listReturns({ storeId, xAuthToken: shopperSession });
const { data: balance } = await market.returns.getStoreCredit({ storeId, xAuthToken: shopperSession });

const market = new Tybrite({ apiKey: 'tybrite_pk_live_operator_...' });

const { collections } = await market.marketplace.listMarketplaceCollections({
  placementKind: 'product',   // optional: 'product' | 'merchant' | 'promotion'
});

// Render each section in display order:
collections
  .sort((a, b) => (a.display_priority ?? 0) - (b.display_priority ?? 0))
  .filter((c) => c.show_on_homepage)
  .forEach((c) => {
    // c.slug, c.name, c.description, c.placement_kind
    renderSectionHeader(c.name, c.description);
  });

const section = await market.marketplace.getMarketplaceCollection({
  slug: 'trending-now',
  limit: 12,   // optional
});

// section.slug, section.name, section.description
// section.placement_kind — 'product' | 'merchant' | 'promotion'
// section.curated        — always true
for (const item of section.items) {
  // item.merchant_store_id — the merchant this member belongs to
  // item.product_id        — for 'product' sections (else null)
  // item.promotion_id      — for 'promotion' sections (else null)
}

const [{ collections }, { placements }, recs] = await Promise.all([
  market.marketplace.listMarketplaceCollections({}),
  market.marketplace.getAdSlot({ slotKey: 'home_hero', limit: 3 }),
  market.recommendations.getRecommendations({ type: 'trending', limit: 12 }),
]);

// Resolve the members of each curated section, then lay out the homepage:
const sections = await Promise.all(
  collections.map((c) => market.marketplace.getMarketplaceCollection({ slug: c.slug, limit: 12 })),
);

// e.g. hero (sponsored, labelled) → curated sections → organic "you might like" rail.

const market = new Tybrite({ apiKey: 'tybrite_pk_live_operator_...' });

const { slot, context, placements } = await market.marketplace.getAdSlot({
  slotKey: 'home_hero',     // the named slot you're filling
  context: 'electronics',   // optional: a category id or search term for context-scoped slots
  limit: 5,                 // optional
});

for (const p of placements) {
  // p.booking_id        — pass this back when logging beacons for this placement
  // p.merchant_store_id  — the merchant being promoted
  // p.placement_kind     — 'product' | 'merchant' | 'promotion'
  // p.product_ids        — products to feature
  // p.promotion_id       — for 'promotion' placements, the promotion to feature (else null)
  // p.creative           — headline / image / cta to render (shape varies by slot)
  // p.sponsored          — true for paid ads, false for operator-curated fallback fill
  // p.curated            — true when the operator hand-picked this fallback placement
  // p.disclosure_label   — render this only when p.sponsored is true
  if (p.sponsored) renderSponsored(p, { label: p.disclosure_label });
  else renderCurated(p);   // curated fallback — no "Sponsored" label
}

const [{ placements }, recs] = await Promise.all([
  market.marketplace.getAdSlot({ slotKey: 'home_hero', limit: 3 }),
  market.recommendations.getRecommendations({ type: 'trending', limit: 12 }),
]);

// Show sponsored placements first (labelled), then organic recommendations.
const feed = [
  ...placements.map((p) => ({ kind: 'sponsored', item: p })),
  ...recs.recommendations.map((r) => ({ kind: 'organic', item: r })),
];

// When a placement scrolls into view:
await market.marketplace.logAdEvent({
  requestBody: {
    booking_id: placement.booking_id,
    event_type: 'impression',
    session_id: storefrontSessionId,   // optional, helps de-duplicate
  },
});
// returns 202 { recorded: true, billable: true }

// When the shopper clicks it:
await market.marketplace.logAdEvent({
  requestBody: {
    booking_id: placement.booking_id,
    event_type: 'click',
    product_id: clickedProductId,      // optional
    session_id: storefrontSessionId,
  },
});
// returns 202 { recorded: true, billable: true }

import { Tybrite } from '@tybrite-labs/sdk';

const market = new Tybrite({ apiKey: 'tybrite_pk_live_operator_...' });

// 1. Chrome
const info = await market.marketplace.getMarketplaceInfo({});
renderHeader(info.name, info.logo_url, info.primary_color);

// 2. Aggregated catalog (each product stamped with its merchant)
const { products } = await market.products.listProducts({ limit: 24 });

// 3. Shopper builds a cross-merchant cart in the browser:
const cart = [
  { product_id: 'p1', variant_id: 'v1', merchant_store_id: products[0].merchant_store_id, quantity: 1 },
  { product_id: 'p2', variant_id: 'v2', merchant_store_id: products[5].merchant_store_id, quantity: 2 },
];

// 4. Sign in (or register) the shopper:
const { session } = await market.authentication.login({
  requestBody: { email: 'john.doe@tybritelabs.com', password: '...' },
});

// 5. Checkout → one payment, auto-split:
const order = await market.marketplace.marketplaceCheckout({
  requestBody: {
    items: cart,
    customer_email: 'john.doe@tybritelabs.com',
    currency: 'USD',
  },
});

// 6. Collect payment with the returned client_secret (Stripe.js), then you're done —
//    the order finalizes and each merchant is paid automatically on success.

import { ApiError } from '@tybrite-labs/sdk';

try {
  await market.marketplace.marketplaceCheckout({ requestBody: { items, customer_email } });
} catch (err) {
  if (err instanceof ApiError) {
    if (err.status === 404) {/* an item is no longer available — refresh the cart */}
    if (err.status === 403) {/* not an operator key, or unified checkout disabled */}
    if (err.status === 502) {/* payment provider unavailable — ask the shopper to retry */}
  }
  throw err;
}