zpan-cloud-sdk 1.0.0

package/README.md

@@ -0,0 +1,13 @@
+# zpan-cloud-sdk
+
+Public TypeScript SDK and API contract for ZPan Cloud.
+
+```ts
+import { createCloudClient } from 'zpan-cloud-sdk'
+import type { ZpanCloudEvent } from 'zpan-cloud-sdk'
+
+const cloud = createCloudClient({
+  baseUrl: 'https://cloud.example.com/api',
+  token: process.env.ZPAN_CLOUD_TOKEN,
+})
+```

package/dist/chunk-VMYIHGPC.js

@@ -0,0 +1,218 @@
+// src/schemas.ts
+import { z } from "zod";
+var paginationQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+  offset: z.coerce.number().int().min(0).optional().default(0)
+});
+var createPairingSchema = z.object({
+  instanceId: z.string().min(1).max(255),
+  instanceName: z.string().min(1).max(255),
+  instanceHost: z.string().min(1).max(512)
+});
+var pairingActionSchema = z.object({
+  action: z.enum(["approve", "deny"])
+});
+var productPriceSchema = z.object({
+  id: z.string().min(1).optional(),
+  currency: z.string().min(1),
+  amount: z.number().int().positive(),
+  lookupKey: z.string().min(1).nullable().optional(),
+  nickname: z.string().nullable().optional(),
+  recurring: z.object({
+    interval: z.enum(["day", "week", "month", "year"]),
+    intervalCount: z.number().int().positive(),
+    usageType: z.enum(["licensed", "metered"]).optional()
+  }).nullable().optional(),
+  metadata: z.record(z.string(), z.string()).optional()
+});
+var deliverableSchema = z.record(z.string(), z.unknown());
+var productMetadataSchema = z.object({
+  deliverable: deliverableSchema
+});
+function isTrafficMeteredPrice(price) {
+  return price.recurring?.usageType === "metered" && price.metadata?.usageResource === "traffic_egress";
+}
+function validateTrafficMeteredPricePairs(prices, ctx) {
+  if (!prices) return;
+  for (const [index, price] of prices.entries()) {
+    if (price.recurring && (price.recurring.interval !== "month" || price.recurring.intervalCount !== 1)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["prices", index, "recurring"],
+        message: "Subscription prices must bill monthly"
+      });
+    }
+    if (price.recurring?.usageType === "metered" && price.metadata?.usageResource !== "traffic_egress") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["prices", index],
+        message: "Metered traffic prices must set usageResource to traffic_egress"
+      });
+    }
+    if (price.metadata?.usageResource === "traffic_egress" && price.recurring?.usageType !== "metered") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["prices", index],
+        message: "Traffic overage prices must use metered billing"
+      });
+    }
+  }
+  const recurringPrices = prices.filter((price) => price.recurring);
+  const currencies = new Set(recurringPrices.map((price) => price.currency));
+  for (const currency of currencies) {
+    const monthlyCount = recurringPrices.filter(
+      (price) => price.currency === currency && !isTrafficMeteredPrice(price)
+    ).length;
+    if (monthlyCount !== 1) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["prices"],
+        message: `Subscription prices for ${currency} must have exactly one monthly price`
+      });
+    }
+    const meteredCount = recurringPrices.filter(
+      (price) => price.currency === currency && isTrafficMeteredPrice(price)
+    ).length;
+    if (meteredCount === 1) continue;
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["prices"],
+      message: `Subscription prices for ${currency} must have exactly one metered traffic price`
+    });
+  }
+}
+var createProductSchema = z.object({
+  type: z.literal("store_item"),
+  name: z.string().min(1),
+  description: z.string().nullable().optional(),
+  active: z.boolean().optional(),
+  sortOrder: z.number().int().optional(),
+  metadata: productMetadataSchema,
+  prices: z.array(productPriceSchema).min(1)
+}).superRefine((input, ctx) => validateTrafficMeteredPricePairs(input.prices, ctx));
+var updateProductSchema = z.object({
+  type: z.literal("store_item").optional(),
+  name: z.string().min(1).optional(),
+  description: z.string().nullable().optional(),
+  active: z.boolean().optional(),
+  sortOrder: z.number().int().optional(),
+  metadata: productMetadataSchema.optional(),
+  prices: z.array(productPriceSchema).min(1).optional()
+}).superRefine((input, ctx) => validateTrafficMeteredPricePairs(input.prices, ctx));
+var productListQuerySchema = paginationQuerySchema.extend({
+  type: z.literal("store_item").optional(),
+  status: z.enum(["active", "inactive"]).optional()
+});
+var orderItemSchema = z.object({
+  productId: z.string().min(1),
+  priceId: z.string().min(1).optional(),
+  quantity: z.number().int().positive().optional().default(1)
+});
+var createOrderSchema = z.object({
+  items: z.array(orderItemSchema).min(1),
+  currency: z.string().min(1),
+  target: z.record(z.string(), z.unknown()).nullable().optional(),
+  deliveryCallbackUrl: z.string().url().optional(),
+  idempotencyKey: z.string().nullable().optional()
+});
+var orderListQuerySchema = paginationQuerySchema.extend({
+  paymentStatus: z.enum(["unpaid", "pending", "paid", "failed", "refunded", "canceled"]).optional(),
+  fulfillmentStatus: z.enum(["pending", "fulfilled", "failed", "canceled"]).optional(),
+  customerId: z.string().min(1).optional()
+});
+var paymentSchema = z.object({
+  successUrl: z.string().optional(),
+  cancelUrl: z.string().optional()
+}).strict();
+var billingPortalSessionSchema = z.object({
+  customerId: z.string().min(1),
+  returnUrl: z.string().url()
+}).strict();
+var orderPatchSchema = z.object({
+  status: z.enum(["canceled"])
+});
+var giftCardCreateSchema = z.object({
+  amount: z.number().int().positive(),
+  currency: z.string().min(1),
+  expiresAt: z.string().optional().nullable(),
+  campaignId: z.string().optional().nullable(),
+  count: z.number().int().min(1).max(100).optional().default(1)
+});
+var giftCardCampaignCreateSchema = z.object({
+  name: z.string().trim().min(1),
+  startsAt: z.string().optional().nullable(),
+  expiresAt: z.string().optional().nullable()
+});
+var giftCardPatchSchema = z.object({
+  disabled: z.boolean().optional(),
+  revoked: z.literal(true).optional()
+});
+var giftCardListQuerySchema = paginationQuerySchema.extend({
+  status: z.enum(["active", "redeemed", "disabled", "expired", "revoked"]).optional(),
+  campaignId: z.string().optional()
+});
+var giftCardCampaignListQuerySchema = paginationQuerySchema.extend({
+  status: z.enum(["active", "disabled", "ended"]).optional()
+});
+var usageEventCreateSchema = z.object({
+  resource: z.literal("traffic_egress"),
+  quantity: z.number().int().positive().optional(),
+  bytes: z.number().int().positive().optional(),
+  idempotencyKey: z.string().trim().min(1).max(200).optional(),
+  eventId: z.string().trim().min(1).max(200).optional(),
+  customerId: z.string().trim().min(1)
+}).strict().refine((value) => value.quantity !== void 0 || value.bytes !== void 0, "quantity_required").refine((value) => value.idempotencyKey !== void 0 || value.eventId !== void 0, "idempotency_key_required");
+var accountUsagePeriodSchema = z.string().regex(/^\d{4}-(0[1-9]|1[0-2])$/);
+var accountUsageQuerySchema = z.object({
+  customerId: z.string().trim().min(1)
+}).strict();
+var walletRedemptionSchema = z.object({
+  codes: z.array(z.string().trim().min(1)).min(1).max(10)
+});
+var accountBillingQuerySchema = paginationQuerySchema.extend({
+  ledgerLimit: z.coerce.number().int().min(1).max(100).optional().default(25),
+  ledgerOffset: z.coerce.number().int().min(0).optional().default(0)
+});
+var storePatchSchema = z.object({
+  name: z.string().min(1).optional(),
+  status: z.enum(["active", "disabled"]).optional()
+});
+var adminUserPatchSchema = z.object({
+  role: z.enum(["user", "admin"]).optional(),
+  membershipTier: z.enum(["none", "silver", "gold", "premier"]).optional(),
+  membershipStatus: z.enum(["active", "inactive", "expired"]).optional()
+}).refine((value) => Object.keys(value).length > 0, { message: "at least one field is required" });
+var adminUserListQuerySchema = paginationQuerySchema.extend({
+  search: z.string().trim().optional(),
+  membershipTier: z.enum(["none", "silver", "gold", "premier"]).optional()
+});
+
+export {
+  paginationQuerySchema,
+  createPairingSchema,
+  pairingActionSchema,
+  productPriceSchema,
+  deliverableSchema,
+  productMetadataSchema,
+  createProductSchema,
+  updateProductSchema,
+  productListQuerySchema,
+  createOrderSchema,
+  orderListQuerySchema,
+  paymentSchema,
+  billingPortalSessionSchema,
+  orderPatchSchema,
+  giftCardCreateSchema,
+  giftCardCampaignCreateSchema,
+  giftCardPatchSchema,
+  giftCardListQuerySchema,
+  giftCardCampaignListQuerySchema,
+  usageEventCreateSchema,
+  accountUsagePeriodSchema,
+  accountUsageQuerySchema,
+  walletRedemptionSchema,
+  accountBillingQuerySchema,
+  storePatchSchema,
+  adminUserPatchSchema,
+  adminUserListQuerySchema
+};