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 shopperSession = session.access_token; // from client.authentication.login(...)

const order = await client.marketplace.marketplaceCheckout({
  xAuthToken: shopperSession,   // omit for a guest checkout
  idempotencyKey: checkoutAttemptId, // e.g. crypto.randomUUID(), made once when the shopper presses Pay
  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@example.com',
    customer_name: 'John Doe',
    currency: 'USD',
    shipping_address: { line1: '1 Market St', city: 'San Francisco', state: 'CA', postal_code: '94105', country: 'US' },
    billing_address:  { line1: '1 Market St', city: 'San Francisco', state: 'CA', postal_code: '94105', country: 'US' },
    // Optional: a carrier option chosen from a quote, per merchant.
    shipping_selections: [
      { merchant_store_id: 'merchant-b-uuid', rate_id: 'rate_8f2c1d', rate_source: 'shippo' },
    ],
    // 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' },
    ],
    // Optional: spend the signed-in shopper's marketplace wallet.
    use_wallet: true,
  },
});

// The wallet spend, shipping, and what the shopper is charged:
console.log(`wallet ${order.wallet_applied}, shipping ${order.shipping_total}, charged ${order.total_amount}`);

// 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}, shipping ${m.shipping_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' },
});

const quote = await client.marketplace.marketplaceCheckoutQuote({
  requestBody: {
    items: [
      { variant_id: 'v1', merchant_store_id: 'merchant-a-uuid', quantity: 1 },
      { variant_id: 'v2', merchant_store_id: 'merchant-b-uuid', quantity: 2 },
    ],
    currency: 'USD',
    shipping_address: { line1: '1 Market St', city: 'San Francisco', state: 'CA', postal_code: '94105', country: 'US' },
  },
});

quote.sellers.forEach(s =>
  console.log(`${s.merchant_store_id}: items ${s.merchandise_total}, shipping ${s.shipping.amount} (${s.shipping.description})`)
);
console.log(`shipping ${quote.shipping_total}, total ${quote.total_amount}`);

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

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

console.log(profile.customer.email, profile.customer.email_verified);
console.log(`${profile.stores.length} merchants bought from`);
console.log(`${profile.orders.length} orders across all merchants`);

const wallet = await client.marketplace.getMarketplaceWallet({
  xAuthToken: session.access_token,
});

console.log(`${wallet.data.balance} ${wallet.data.currency} available`);

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 at that merchant
const { data: mine } = await market.returns.listReturns({ storeId, xAuthToken: shopperSession });

// marketplace credit lives in the wallet, not at the merchant
const wallet = await market.marketplace.getMarketplaceWallet({ 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 === 409) {/* provider_not_live — the marketplace cannot take payment yet */}
    if (err.status === 502) {/* payment provider unavailable — ask the shopper to retry */}
  }
  throw err;
}