@pfdev/api-types 3.0.12 → 3.0.14

package/package.json

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

package/v3.ts

@@ -7,7 +7,7 @@ import { Static, Type } from '@sinclair/typebox';
 // ============= CARDS =============
 
 
-const PriceStatsSchema = Type.Object(
+export const PriceStatsSchema = Type.Object(
   {
     current_price: Type.Optional(Type.Number({ description: 'Current price' })),
     change_1d: Type.Optional(Type.Number({ description: '1-day price change as a percentage' })),
@@ -103,6 +103,15 @@ export const CardSearchQuerySchema = Type.Object({
 
 export type CardSearchQuery = Static<typeof CardSearchQuerySchema>;
 
+export const CardBatchQuerySchema = Type.Object({
+  ids: Type.String({
+    minLength: 1,
+    description: 'Comma-separated list of card IDs (e.g. "xy1-2,base1-4"). Duplicates are deduped. Max 200 IDs per request.'
+  })
+});
+
+export type CardBatchQuery = Static<typeof CardBatchQuerySchema>;
+
 export const CardDetailSchema = Type.Object(
   {
     cardid: Type.String({ description: 'Unique card identifier' }),
@@ -252,6 +261,62 @@ export const CurrencyResponseSchema = Type.Object({
 
 export type CurrencyResponse = Static<typeof CurrencyResponseSchema>;
 
+// ============= DEX =============
+
+
+export const DexPokemonParamSchema = Type.Object({
+  name: Type.String({ description: 'Pokémon name (exact match)' })
+});
+export type DexPokemonParam = Static<typeof DexPokemonParamSchema>;
+
+export const DexCardSchema = Type.Intersect(
+  [
+    CardSchema,
+    Type.Object({
+      variant_prices: Type.Record(Type.String(), PriceStatsSchema, {
+        description: 'Per-variant prices and period changes keyed by variant name'
+      })
+    })
+  ],
+  {
+    title: 'DexCard',
+    description: 'A card in a Pokémon dex view, with full per-variant price breakdown'
+  }
+);
+export type DexCard = Static<typeof DexCardSchema>;
+
+export const DexPokemonResponseSchema = Type.Object(
+  {
+    number: Type.Integer({ description: 'National Pokédex number' }),
+    name: Type.String({ description: 'Pokémon name' }),
+    sprite: Type.String({ description: 'Sprite GIF URL for this Pokémon' }),
+    cards: Type.Array(DexCardSchema)
+  },
+  { title: 'DexPokemon' }
+);
+
+export const DexEntrySchema = Type.Object(
+  {
+    id: Type.Integer({ description: 'Internal Pokémon id (ordering key)' }),
+    name: Type.String({ description: 'Pokémon name' }),
+    number: Type.Integer({ description: 'National Pokédex number' }),
+    sprite: Type.String({ description: 'Sprite GIF URL for this Pokémon' }),
+    card_count: Type.Integer({ description: 'Distinct cards tied to this Pokémon' }),
+    master_count: Type.Integer({ description: 'Count of priced variant rows across those cards' }),
+    cost: Type.Union([Type.Number(), Type.Null()], {
+      description: 'Sum of the cheapest priced variant per card. Null if no card has any priced variant.'
+    }),
+    master_cost: Type.Union([Type.Number(), Type.Null()], {
+      description: 'Sum of every priced ungraded variant across all cards. Null if nothing is priced.'
+    })
+  },
+  { title: 'DexEntry' }
+);
+
+export type DexEntry = Static<typeof DexEntrySchema>;
+
+export const DexListResponseSchema = Type.Array(DexEntrySchema);
+
 // ============= SEALED =============
 
 
@@ -490,6 +555,155 @@ export const ErrorResponseSchema = Type.Object({
 
 export type ErrorResponse = Static<typeof ErrorResponseSchema>;
 
+export const DexCollectionItemSchema = Type.Object(
+  {
+    id: Type.Integer({ description: 'Pokémon id (matches /dex/ response.id)' }),
+    collected: Type.Integer({ description: 'Distinct cardids the user owns for this Pokémon' }),
+    master_collected: Type.Integer({ description: 'Distinct (cardid, variant) pairs the user owns for this Pokémon' })
+  },
+  { title: 'DexCollectionItem' }
+);
+
+export type DexCollectionItem = Static<typeof DexCollectionItemSchema>;
+
+export const DexCollectionResponseSchema = Type.Array(DexCollectionItemSchema);
+
+export const InventorySummaryItemSchema = Type.Object(
+  {
+    uuid: Type.String({ description: 'Unique ID of this inventory row' }),
+    cardid: Type.String({ description: 'Card ID this inventory row belongs to' }),
+    variant: Type.String({ description: 'Card variant (e.g. Normal, Holofoil, Reverse Holofoil)' }),
+    status: Type.Union([Type.Number(), Type.Null()], {
+      description: 'Numeric status code. <100 = active, >=100 = sold/past. Null when no details row exists yet.'
+    })
+  },
+  { title: 'InventorySummaryItem' }
+);
+
+export type InventorySummaryItem = Static<typeof InventorySummaryItemSchema>;
+
+export const InventorySummaryResponseSchema = Type.Array(InventorySummaryItemSchema, {
+  title: 'InventorySummaryResponse',
+  description: 'Lightweight ownership rows for the authenticated user. One entry per physical card owned. Suitable for a global client store.'
+});
+
+export type InventorySummaryResponse = Static<typeof InventorySummaryResponseSchema>;
+
+export const InventoryAddRequestSchema = Type.Object(
+  {
+    cardid: Type.String({ minLength: 1, description: 'Card ID to add to inventory' }),
+    variant: Type.String({ minLength: 1, description: 'Card variant (e.g. Normal, Holofoil, Reverse Holofoil)' })
+  },
+  { title: 'InventoryAddRequest' }
+);
+
+export type InventoryAddRequest = Static<typeof InventoryAddRequestSchema>;
+
+export const InventoryDeleteParamSchema = Type.Object({
+  uuid: Type.String({ format: 'uuid', description: 'UUID of the inventory row to delete' })
+});
+
+export type InventoryDeleteParam = Static<typeof InventoryDeleteParamSchema>;
+
+export const InventoryTransactionSchema = Type.Object(
+  {
+    tx_uuid: Type.String({ format: 'uuid' }),
+    transaction_type: Type.Number({ description: '100-199 = cost, 200-299 = income' }),
+    transaction_date: Type.String({ description: 'ISO date string' }),
+    amount: Type.Number(),
+    currency: Type.String(),
+    amount_usd: Type.Union([Type.Number(), Type.Null()]),
+    rate: Type.Union([Type.Number(), Type.Null()]),
+    description: Type.Union([Type.String(), Type.Null()]),
+    source_platform: Type.Union([Type.String(), Type.Null()])
+  },
+  { title: 'InventoryTransaction' }
+);
+
+export type InventoryTransaction = Static<typeof InventoryTransactionSchema>;
+
+export const InventoryItemDetailSchema = Type.Object(
+  {
+    uuid: Type.String({ format: 'uuid' }),
+    cardid: Type.String(),
+    variant: Type.String(),
+    status: Type.Union([Type.Number(), Type.Null()]),
+    grade: Type.Union([Type.String(), Type.Null()]),
+    acquired: Type.Union([Type.String(), Type.Null()]),
+    sold_date: Type.Union([Type.String(), Type.Null()]),
+    notes: Type.Union([Type.String(), Type.Null()]),
+    total_cost_usd: Type.Number(),
+    total_income_usd: Type.Number(),
+    profit_loss_usd: Type.Number(),
+    transactions: Type.Array(InventoryTransactionSchema)
+  },
+  {
+    title: 'InventoryItemDetail',
+    description: 'Full detail of a single inventory row, including transactions and aggregated totals.'
+  }
+);
+
+export type InventoryItemDetail = Static<typeof InventoryItemDetailSchema>;
+
+export const InventoryItemsResponseSchema = Type.Array(InventoryItemDetailSchema, {
+  title: 'InventoryItemsResponse',
+  description: 'Full-detail inventory items for a specific cardid.'
+});
+
+export type InventoryItemsResponse = Static<typeof InventoryItemsResponseSchema>;
+
+export const InventoryItemsQuerySchema = Type.Object({
+  cardid: Type.String({ minLength: 1, description: 'Card ID to fetch inventory items for' })
+});
+
+export type InventoryItemsQuery = Static<typeof InventoryItemsQuerySchema>;
+
+export const InventoryItemParamSchema = Type.Object({
+  uuid: Type.String({ format: 'uuid', description: 'UUID of the inventory row' })
+});
+
+export type InventoryItemParam = Static<typeof InventoryItemParamSchema>;
+
+export const InventoryPatchTransactionSchema = Type.Object(
+  {
+    tx_uuid: Type.Optional(Type.String({ format: 'uuid', description: 'Present for updates, omitted for new transactions' })),
+    transaction_type: Type.Number(),
+    transaction_date: Type.String({ description: 'ISO date (YYYY-MM-DD)' }),
+    amount: Type.Number(),
+    currency: Type.Optional(Type.String({ minLength: 3, maxLength: 3, default: 'USD' })),
+    description: Type.Optional(Type.String()),
+    source_platform: Type.Optional(Type.String())
+  },
+  { title: 'InventoryPatchTransaction' }
+);
+
+export type InventoryPatchTransaction = Static<typeof InventoryPatchTransactionSchema>;
+
+export const InventoryPatchParamSchema = Type.Object({
+  uuid: Type.String({ format: 'uuid', description: 'UUID of the inventory row to update' })
+});
+
+export type InventoryPatchParam = Static<typeof InventoryPatchParamSchema>;
+
+export const InventoryPatchRequestSchema = Type.Object(
+  {
+    grade: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+    status: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    notes: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+    acquired: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+    sold_date: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+    transactions: Type.Optional(Type.Array(InventoryPatchTransactionSchema, {
+      description: 'Authoritative — any existing transaction not in this list is deleted.'
+    }))
+  },
+  {
+    title: 'InventoryPatchRequest',
+    description: 'Fields omitted from the body are left unchanged. Fields set to null are cleared.'
+  }
+);
+
+export type InventoryPatchRequest = Static<typeof InventoryPatchRequestSchema>;
+
 // ============= VISION =============