@pfdev/api-types 3.0.6 → 3.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pfdev/api-types",
-  "version": "3.0.6",
+  "version": "3.0.10",
   "description": "TypeScript types for PF API V3",
   "main": "index.ts",
   "types": "index.ts",

package/v3.ts

@@ -7,10 +7,9 @@ import { Static, Type } from '@sinclair/typebox';
 // ============= CARDS =============
 
 
-const VariantPriceSchema = Type.Object(
+const PriceStatsSchema = Type.Object(
   {
-    variant: Type.String({ description: 'Variant name' }),
-    current_price: Type.Optional(Type.Number({ description: 'Current price for this variant' })),
+    current_price: Type.Optional(Type.Number({ description: 'Current price' })),
     change_1d: Type.Optional(Type.Number({ description: '1-day price change as a percentage' })),
     change_7d: Type.Optional(Type.Number({ description: '7-day price change as a percentage' })),
     change_1m: Type.Optional(Type.Number({ description: '30-day price change as a percentage' })),
@@ -18,7 +17,7 @@ const VariantPriceSchema = Type.Object(
     change_6m: Type.Optional(Type.Number({ description: '180-day price change as a percentage' })),
     change_1y: Type.Optional(Type.Number({ description: '1-year price change as a percentage' }))
   },
-  { title: 'VariantPrice' }
+  { title: 'PriceStats' }
 );
 
 const CardImagesSchema = Type.Object(
@@ -77,6 +76,33 @@ export const CardListQuerySchema = Type.Object(
 
 export type CardListQuery = Static<typeof CardListQuerySchema>;
 
+export const CardSearchSortSchema = Type.Union([
+  Type.Literal('number_asc'),
+  Type.Literal('number_desc'),
+  Type.Literal('name_asc'),
+  Type.Literal('name_desc'),
+  Type.Literal('price_asc'),
+  Type.Literal('price_desc')
+]);
+
+export type CardSearchSort = Static<typeof CardSearchSortSchema>;
+
+export const CardSearchQuerySchema = Type.Object({
+  q: Type.String({ minLength: 1, description: 'Search query. Tokens with digits match card number; other tokens match card name.' }),
+  sort: Type.Optional(Type.Union([
+    Type.Literal('number_asc'),
+    Type.Literal('number_desc'),
+    Type.Literal('name_asc'),
+    Type.Literal('name_desc'),
+    Type.Literal('price_asc'),
+    Type.Literal('price_desc')
+  ], { default: 'number_asc', description: 'Sort order. Defaults to number_asc.' })),
+  limit: Type.Optional(Type.Number({ minimum: 1, maximum: 100, default: 25, description: 'Max results to return' })),
+  offset: Type.Optional(Type.Number({ minimum: 0, default: 0, description: 'Pagination offset' }))
+});
+
+export type CardSearchQuery = Static<typeof CardSearchQuerySchema>;
+
 export const CardDetailSchema = Type.Object(
   {
     cardid: Type.String({ description: 'Unique card identifier' }),
@@ -109,7 +135,16 @@ export const CardDetailSchema = Type.Object(
     change_1d: Type.Optional(Type.Number({ description: '1-day price change as a percentage' })),
     change_1d_value: Type.Optional(Type.Number({ description: '1-day price change in dollars' })),
     variants: Type.Optional(Type.Array(Type.String(), { description: 'Available variants for this card' })),
-    variant_prices: Type.Optional(Type.Array(VariantPriceSchema, { description: 'Per-variant prices with extended period changes' }))
+    variant_prices: Type.Optional(
+      Type.Record(Type.String(), PriceStatsSchema, { description: 'Prices and period changes keyed by variant name' })
+    ),
+    graded_variants_prices: Type.Optional(
+      Type.Record(
+        Type.String(),
+        Type.Record(Type.String(), PriceStatsSchema),
+        { description: 'Graded prices and period changes keyed by variant then grade' }
+      )
+    )
   },
   {
     title: 'CardDetail',
@@ -125,6 +160,184 @@ export const CardDetailParamSchema = Type.Object({
 
 export type CardDetailParam = Static<typeof CardDetailParamSchema>;
 
+const PricePointSchema = Type.Object(
+  {
+    date: Type.String({ description: 'Date of the price point' }),
+    price: Type.Number({ description: 'Price on this date' }),
+    variant: Type.String({ description: 'Card variant' }),
+    grade: Type.Optional(Type.String({ description: 'Grade (graded cards only)' }))
+  },
+  { title: 'PricePoint' }
+);
+
+export const CardPricesQuerySchema = Type.Object({
+  interval: Type.Number({ minimum: 1, maximum: 1825, default: 30, description: 'Number of days of price history to return' }),
+  variant: Type.Optional(Type.String({ description: 'Variant name. If omitted, returns all variants.' })),
+  grade: Type.Optional(Type.String({ description: 'Grade (e.g. "PSA 10", "BGS 9.5"). Omit or use "RAW" for ungraded.' })),
+  source: Type.Optional(Type.Union(
+    [Type.Literal('tcgplayer'), Type.Literal('ebay')],
+    { description: 'Price source. Inferred from grade if omitted: RAW → tcgplayer, graded → ebay.' }
+  ))
+});
+
+export type CardPricesQuery = Static<typeof CardPricesQuerySchema>;
+
+export const CardPricesResponseSchema = Type.Object(
+  {
+    cardid: Type.String({ description: 'Card ID' }),
+    variant: Type.Optional(Type.String({ description: 'Filtered variant, if specified' })),
+    grade: Type.String({ description: 'Resolved grade used for the query' }),
+    source: Type.String({ description: 'Resolved price source used for the query' }),
+    interval: Type.Number({ description: 'Number of days of history returned' }),
+    data: Type.Array(PricePointSchema, { description: 'Price history data points, ordered by date ascending' })
+  },
+  {
+    title: 'CardPricesResponse',
+    description: 'Price history for a card, suitable for charting'
+  }
+);
+
+export type CardPricesResponse = Static<typeof CardPricesResponseSchema>;
+
+const SaleRecordSchema = Type.Object(
+  {
+    sold_date: Type.String({ description: 'Date the card was sold' }),
+    price: Type.Number({ description: 'Sale price' }),
+    grade: Type.String({ description: 'Grade at time of sale' }),
+    variant: Type.String({ description: 'Card variant' }),
+    title: Type.Optional(Type.String({ description: 'eBay listing title' })),
+    url: Type.Optional(Type.String({ description: 'eBay listing URL' })),
+    image_url: Type.Optional(Type.String({ description: 'Listing image URL' })),
+    seller_username: Type.Optional(Type.String({ description: 'eBay seller username' }))
+  },
+  { title: 'SaleRecord' }
+);
+
+export const CardSalesQuerySchema = Type.Object({
+  grade: Type.Optional(Type.String({ description: 'Filter by grade (e.g. "PSA 10"). Returns all grades if omitted.' })),
+  variant: Type.Optional(Type.String({ description: 'Filter by variant. Returns all variants if omitted.' })),
+  limit: Type.Optional(Type.Number({ minimum: 1, maximum: 100, default: 25, description: 'Max results to return' })),
+  offset: Type.Optional(Type.Number({ minimum: 0, default: 0, description: 'Pagination offset' }))
+});
+
+export type CardSalesQuery = Static<typeof CardSalesQuerySchema>;
+
+export const CardSalesResponseSchema = Type.Object(
+  {
+    cardid: Type.String({ description: 'Card ID' }),
+    grade: Type.Optional(Type.String({ description: 'Filtered grade, if specified' })),
+    variant: Type.Optional(Type.String({ description: 'Filtered variant, if specified' })),
+    data: Type.Array(SaleRecordSchema, { description: 'Individual eBay sold listings, most recent first' }),
+    total: Type.Number({ description: 'Total matching sales records' }),
+    count: Type.Number({ description: 'Records returned in this response' })
+  },
+  {
+    title: 'CardSalesResponse',
+    description: 'Individual eBay sold listings for a graded card'
+  }
+);
+
+export type CardSalesResponse = Static<typeof CardSalesResponseSchema>;
+
+// ============= SEALED =============
+
+
+export const SealedItemSchema = Type.Object(
+  {
+    sealedid: Type.String({ format: 'uuid', description: 'Unique sealed product identifier' }),
+    name: Type.String({ description: 'Product name' }),
+    setid: Type.String({ description: 'Set this product belongs to' }),
+    set_name: Type.Optional(Type.String({ description: 'Name of the set' })),
+    product_slug: Type.Optional(Type.String({ description: 'Product URL slug' })),
+    set_slug: Type.Optional(Type.String({ description: 'Set URL slug' })),
+    image: Type.Optional(Type.String({ description: 'Product image URL' })),
+    tcgp_id: Type.Optional(Type.Number({ description: 'TCGPlayer product ID' })),
+    language: Type.Optional(Type.String({ description: 'Product language' })),
+    price: Type.Optional(Type.Number({ description: 'Current market price' })),
+    change_1d: Type.Optional(Type.Number({ description: '1-day price change %' })),
+    change_7d: Type.Optional(Type.Number({ description: '7-day price change %' })),
+    change_1m: Type.Optional(Type.Number({ description: '30-day price change %' })),
+    change_3m: Type.Optional(Type.Number({ description: '90-day price change %' })),
+    change_6m: Type.Optional(Type.Number({ description: '180-day price change %' })),
+    change_1y: Type.Optional(Type.Number({ description: '1-year price change %' })),
+    change_1d_value: Type.Optional(Type.Number({ description: '1-day price change in dollars' })),
+    change_7d_value: Type.Optional(Type.Number({ description: '7-day price change in dollars' })),
+    change_1m_value: Type.Optional(Type.Number({ description: '30-day price change in dollars' })),
+    change_3m_value: Type.Optional(Type.Number({ description: '90-day price change in dollars' })),
+    change_6m_value: Type.Optional(Type.Number({ description: '180-day price change in dollars' })),
+    change_1y_value: Type.Optional(Type.Number({ description: '1-year price change in dollars' })),
+    price_updated: Type.Optional(Type.String({ description: 'Timestamp of last price update' }))
+  },
+  {
+    title: 'SealedItem',
+    description: 'A sealed Pokemon product'
+  }
+);
+
+export type SealedItem = Static<typeof SealedItemSchema>;
+
+export const SealedListResponseSchema = Type.Object(
+  {
+    data: Type.Array(SealedItemSchema, { description: 'Array of sealed products' }),
+    total: Type.Number({ description: 'Total number of products matching query' }),
+    count: Type.Number({ description: 'Number of products returned in this response' })
+  },
+  {
+    title: 'SealedListResponse',
+    description: 'Paginated list of sealed Pokemon products'
+  }
+);
+
+export type SealedListResponse = Static<typeof SealedListResponseSchema>;
+
+export const SealedListQuerySchema = Type.Object(
+  {
+    setid: Type.Optional(Type.String({ description: 'Filter by set ID' })),
+    name: Type.Optional(Type.String({ description: 'Search by product name' })),
+    limit: Type.Optional(Type.Number({ minimum: 1, maximum: 250, default: 50, description: 'Max results to return' })),
+    offset: Type.Optional(Type.Number({ minimum: 0, default: 0, description: 'Pagination offset' }))
+  },
+  { description: 'At least one of setid or name must be provided' }
+);
+
+export type SealedListQuery = Static<typeof SealedListQuerySchema>;
+
+// Path parameters
+export const SealedDetailParamSchema = Type.Object({
+  sealedid: Type.String({ format: 'uuid', description: 'Sealed product ID' })
+});
+
+export type SealedDetailParam = Static<typeof SealedDetailParamSchema>;
+
+// Prices endpoint
+const SealedPricePointSchema = Type.Object(
+  {
+    date: Type.String({ description: 'Date of the price point' }),
+    price: Type.Number({ description: 'Price on this date' })
+  },
+  { title: 'SealedPricePoint' }
+);
+
+export const SealedPricesQuerySchema = Type.Object({
+  interval: Type.Optional(Type.Number({ minimum: 1, maximum: 1825, default: 30, description: 'Number of days of price history to return' }))
+});
+
+export type SealedPricesQuery = Static<typeof SealedPricesQuerySchema>;
+
+export const SealedPricesResponseSchema = Type.Object(
+  {
+    sealedid: Type.String({ format: 'uuid', description: 'Sealed product ID' }),
+    interval: Type.Number({ description: 'Number of days of history returned' }),
+    data: Type.Array(SealedPricePointSchema, { description: 'Price history data points, ordered by date ascending' })
+  },
+  {
+    title: 'SealedPricesResponse',
+    description: 'Price history for a sealed product, suitable for charting'
+  }
+);
+
+export type SealedPricesResponse = Static<typeof SealedPricesResponseSchema>;
+
 // ============= SETS =============
 
 
@@ -219,3 +432,65 @@ export const SetDetailParamSchema = Type.Object({
 });
 
 export type SetDetailParam = Static<typeof SetDetailParamSchema>;
+
+// ============= VISION =============
+
+
+const VariantPriceSchema = Type.Object(
+  {
+    variant: Type.String(),
+    current_price: Type.Optional(Type.Number()),
+    change_1d: Type.Optional(Type.Number()),
+    change_7d: Type.Optional(Type.Number()),
+    change_1m: Type.Optional(Type.Number()),
+    change_3m: Type.Optional(Type.Number()),
+    change_6m: Type.Optional(Type.Number()),
+    change_1y: Type.Optional(Type.Number())
+  },
+  { title: 'VisionVariantPrice' }
+);
+
+const DetectedCardSchema = Type.Object(
+  {
+    name: Type.String({ description: 'Card name from image recognition' }),
+    number: Type.Optional(Type.String({ description: 'Card number from image recognition' })),
+    releaseName: Type.Optional(Type.String({ description: 'Set/release name from image recognition' })),
+    setName: Type.Optional(Type.String({ description: 'Sub-set name from image recognition' })),
+    year: Type.Optional(Type.String({ description: 'Release year from image recognition' })),
+    manufacturer: Type.Optional(Type.String({ description: 'Card manufacturer' }))
+  },
+  { title: 'DetectedCard' }
+);
+
+const MatchedCardSchema = Type.Intersect(
+  [
+    CardSchema,
+    Type.Object({
+      score: Type.Number({ description: 'Fuzzy match score — higher is a better match' }),
+      variant_prices: Type.Array(VariantPriceSchema, { description: 'Per-variant prices with extended period changes' })
+    })
+  ],
+  { title: 'MatchedCard' }
+);
+
+export const VisionBodySchema = Type.Object(
+  {
+    file: Type.Any({ description: 'Card image file to identify', format: 'binary' })
+  },
+  { title: 'VisionBody' }
+);
+
+export type VisionBody = Static<typeof VisionBodySchema>;
+
+export const VisionResponseSchema = Type.Object(
+  {
+    detection: Type.Union([DetectedCardSchema, Type.Null()], { description: 'Raw detection result from image recognition' }),
+    cards: Type.Optional(Type.Array(MatchedCardSchema, { description: 'Matched cards from database, ordered by score descending' }))
+  },
+  {
+    title: 'VisionResponse',
+    description: 'Card image recognition result with matched database cards'
+  }
+);
+
+export type VisionResponse = Static<typeof VisionResponseSchema>;