zpan-cloud-sdk 1.0.0 → 1.0.1

package/README.md

@@ -7,7 +7,7 @@ import { createCloudClient } from 'zpan-cloud-sdk'
 import type { ZpanCloudEvent } from 'zpan-cloud-sdk'
 
 const cloud = createCloudClient({
-  baseUrl: 'https://cloud.example.com/api',
+  baseUrl: 'https://cloud.example.com',
   token: process.env.ZPAN_CLOUD_TOKEN,
 })
 ```

package/dist/chunk-YQNXMZK4.js

@@ -0,0 +1,572 @@
+// 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 pageSchema = (itemSchema) => z.object({
+  items: z.array(itemSchema),
+  total: z.number().int().min(0),
+  limit: z.number().int().min(0),
+  offset: z.number().int().min(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 pairingCreateResponseSchema = z.object({
+  code: z.string(),
+  pairingUrl: z.string(),
+  expiresAt: z.string()
+});
+var pairingPreviewSchema = z.object({
+  licenseId: z.string(),
+  licenseName: z.string(),
+  licenseHost: z.string()
+});
+var pairingPollResponseSchema = z.discriminatedUnion("status", [
+  z.object({ status: z.enum(["pending", "denied", "expired"]) }),
+  z.object({
+    status: z.literal("approved"),
+    refreshToken: z.string(),
+    certificate: z.string(),
+    binding: z.object({
+      id: z.string(),
+      instanceId: z.string(),
+      storeId: z.string(),
+      authorizedHosts: z.array(z.string())
+    }),
+    account: z.object({ id: z.string(), email: z.string() })
+  })
+]);
+var pairingActionSchema = z.object({
+  action: z.enum(["approve", "deny"])
+});
+var pairingActionResponseSchema = z.object({
+  status: z.enum(["approved", "denied"])
+});
+var entitlementRefreshResponseSchema = z.object({
+  certificate: z.string(),
+  refreshToken: z.string(),
+  nextRefreshAfter: z.string(),
+  binding: z.object({
+    id: z.string(),
+    instanceId: z.string(),
+    storeId: z.string(),
+    authorizedHosts: z.array(z.string())
+  }),
+  account: z.object({ id: z.string(), email: z.string() })
+});
+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 commerceStoreSchema = z.object({
+  id: z.string(),
+  type: z.enum(["cloud", "instance"]),
+  name: z.string(),
+  ownerAccountId: z.string().nullable(),
+  boundLicenseId: z.string().nullable(),
+  status: z.enum(["active", "disabled"]),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var commerceProductSchema = z.object({
+  id: z.string(),
+  storeId: z.string(),
+  type: z.literal("store_item"),
+  name: z.string(),
+  description: z.string().nullable(),
+  active: z.boolean(),
+  sortOrder: z.number().int(),
+  metadata: productMetadataSchema,
+  prices: z.array(productPriceSchema),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var productListResponseSchema = pageSchema(commerceProductSchema);
+var storeListResponseSchema = pageSchema(commerceStoreSchema);
+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 commerceOrderItemSchema = z.object({
+  id: z.string(),
+  orderId: z.string(),
+  productId: z.string(),
+  productType: z.string(),
+  name: z.string(),
+  description: z.string().nullable(),
+  quantity: z.number().int(),
+  unitAmount: z.number().int(),
+  totalAmount: z.number().int(),
+  fulfillmentPayload: z.record(z.string(), z.unknown())
+});
+var commercePaymentSchema = z.object({
+  id: z.string(),
+  orderId: z.string(),
+  provider: z.enum(["stripe", "gift_card", "wallet"]),
+  amount: z.number().int(),
+  currency: z.string(),
+  status: z.enum(["pending", "paid", "failed", "refunded", "canceled"]),
+  providerSessionId: z.string().nullable(),
+  providerPaymentIntentId: z.string().nullable(),
+  createdAt: z.string(),
+  paidAt: z.string().nullable()
+});
+var commerceOrderSchema = z.object({
+  id: z.string(),
+  storeId: z.string(),
+  buyerAccountId: z.string().nullable(),
+  target: z.record(z.string(), z.unknown()).nullable(),
+  status: z.enum(["pending", "paid", "fulfilled", "failed", "canceled", "refunded"]),
+  paymentStatus: z.enum(["unpaid", "pending", "paid", "failed", "refunded", "canceled"]),
+  fulfillmentStatus: z.enum(["pending", "fulfilled", "failed", "canceled"]),
+  subtotalAmount: z.number().int(),
+  discountAmount: z.number().int(),
+  totalAmount: z.number().int(),
+  currency: z.string(),
+  items: z.array(commerceOrderItemSchema),
+  payments: z.array(commercePaymentSchema).optional(),
+  createdAt: z.string(),
+  paidAt: z.string().nullable(),
+  fulfilledAt: z.string().nullable(),
+  canceledAt: z.string().nullable()
+});
+var orderListResponseSchema = pageSchema(commerceOrderSchema);
+var paymentSchema = z.object({
+  successUrl: z.string().optional(),
+  cancelUrl: z.string().optional()
+}).strict();
+var paymentCreateResponseSchema = z.discriminatedUnion("status", [
+  z.object({
+    status: z.literal("pending"),
+    paymentId: z.string(),
+    orderId: z.string(),
+    url: z.string(),
+    reused: z.boolean().optional()
+  }),
+  z.object({
+    status: z.literal("paid"),
+    paymentId: z.string().optional(),
+    orderId: z.string(),
+    url: z.string().nullable(),
+    reused: z.boolean().optional()
+  })
+]);
+var billingPortalSessionSchema = z.object({
+  customerId: z.string().min(1),
+  returnUrl: z.string().url()
+}).strict();
+var billingPortalSessionResponseSchema = z.object({
+  url: z.string(),
+  stripeSubscriptionId: z.string()
+});
+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 storeGiftCardSchema = z.object({
+  id: z.string(),
+  storeId: z.string(),
+  campaignId: z.string().nullable(),
+  code: z.string().nullable(),
+  codeLast4: z.string(),
+  amount: z.number().int(),
+  currency: z.string(),
+  status: z.enum(["active", "redeemed", "disabled", "expired", "revoked"]),
+  expiresAt: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  disabledAt: z.string().nullable(),
+  revokedAt: z.string().nullable(),
+  createdByAdmin: z.string()
+});
+var giftCardCampaignSchema = z.object({
+  id: z.string(),
+  storeId: z.string(),
+  name: z.string(),
+  status: z.enum(["active", "disabled", "ended"]),
+  startsAt: z.string().nullable(),
+  expiresAt: z.string().nullable(),
+  createdByAdmin: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var giftCardListResponseSchema = pageSchema(storeGiftCardSchema);
+var giftCardCampaignListResponseSchema = pageSchema(giftCardCampaignSchema);
+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 usageResourceSummarySchema = z.object({
+  used: z.number().int(),
+  included: z.number().int(),
+  overageBytes: z.number().int(),
+  overageGb: z.number()
+});
+var usageSummarySchema = z.object({
+  period: z.string(),
+  resources: z.object({
+    traffic_egress: usageResourceSummarySchema
+  }),
+  nextReset: z.string()
+});
+var usageEventCreateResponseSchema = z.object({
+  resource: z.literal("traffic_egress"),
+  quantity: z.number().int(),
+  duplicate: z.boolean()
+});
+var walletRedemptionSchema = z.object({
+  codes: z.array(z.string().trim().min(1)).min(1).max(10)
+});
+var walletBalanceSchema = z.object({
+  id: z.string(),
+  walletId: z.string().nullable(),
+  storeId: z.string(),
+  customerId: z.string().nullable(),
+  currency: z.string(),
+  availableAmount: z.number().int(),
+  pendingAmount: z.number().int(),
+  stripeCustomerId: z.string().nullable(),
+  updatedAt: z.string()
+});
+var walletLedgerEntrySchema = z.object({
+  id: z.string(),
+  walletId: z.string().nullable(),
+  storeId: z.string(),
+  customerId: z.string().nullable(),
+  currency: z.string(),
+  amount: z.number().int(),
+  direction: z.enum(["credit", "debit"]),
+  status: z.enum(["posted", "pending", "released", "refunded"]),
+  sourceType: z.enum(["gift_card_redemption", "order_payment", "stripe_invoice", "adjustment", "refund"]),
+  sourceId: z.string().nullable(),
+  orderId: z.string().nullable(),
+  paymentId: z.string().nullable(),
+  stripeCustomerBalanceTransactionId: z.string().nullable(),
+  createdAt: z.string()
+});
+var walletBalanceListResponseSchema = pageSchema(walletBalanceSchema);
+var walletLedgerResponseSchema = pageSchema(walletLedgerEntrySchema);
+var walletRedemptionResponseSchema = z.object({
+  redeemedAmount: z.number().int(),
+  currency: z.string().nullable(),
+  failures: z.array(z.object({ code: z.string(), error: z.string() }))
+});
+var accountWalletResponseSchema = pageSchema(walletLedgerEntrySchema).extend({
+  balances: z.array(walletBalanceSchema)
+});
+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 accountOverviewResponseSchema = z.object({
+  activeLicenses: z.number().int(),
+  membershipTier: z.enum(["none", "silver", "gold", "premier"]),
+  latestBillingDate: z.string().nullable()
+});
+var membershipStripeChannelSchema = z.object({
+  status: z.string(),
+  billingInterval: z.string().nullable(),
+  renewsAt: z.string().nullable(),
+  cancelAtPeriodEnd: z.boolean()
+});
+var accountMembershipResponseSchema = z.object({
+  state: z.enum(["inactive", "active", "renewal_due", "expired"]),
+  tier: z.enum(["none", "silver", "gold", "premier"]),
+  membershipStatus: z.enum(["inactive", "active", "expired"]),
+  expiresAt: z.string().nullable(),
+  cumulativeMonths: z.number().int(),
+  proIncluded: z.boolean(),
+  primaryAction: z.enum(["subscribe", "renew", "manage"]),
+  stripeSubscription: membershipStripeChannelSchema.nullable(),
+  channel: z.enum(["stripe", "gift"])
+});
+var billingRecordItemSchema = z.object({
+  name: z.string(),
+  productType: z.string(),
+  quantity: z.number().int(),
+  deliverable: z.record(z.string(), z.unknown()),
+  recurring: z.boolean()
+});
+var billingRecordSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  kind: z.enum(["store_item", "store_subscription", "mixed_order"]),
+  items: z.array(billingRecordItemSchema),
+  orderStatus: z.enum(["pending", "paid", "fulfilled", "failed", "canceled", "refunded"]),
+  paymentStatus: z.enum(["unpaid", "pending", "paid", "failed", "refunded", "canceled"]),
+  fulfillmentStatus: z.enum(["pending", "fulfilled", "failed", "canceled"]),
+  amountLabel: z.string().nullable(),
+  occurredAt: z.string(),
+  paidAt: z.string().nullable(),
+  fulfilledAt: z.string().nullable()
+});
+var billingSummarySchema = z.object({
+  totalRecords: z.number().int(),
+  stripeRecords: z.number().int(),
+  walletBalanceAmount: z.number().int(),
+  walletCurrency: z.string().nullable(),
+  latestAt: z.string().nullable()
+});
+var accountBillingResponseSchema = z.object({
+  summary: billingSummarySchema,
+  walletBalances: z.array(walletBalanceSchema),
+  walletLedger: pageSchema(walletLedgerEntrySchema),
+  items: z.array(billingRecordSchema),
+  total: z.number().int(),
+  limit: z.number().int(),
+  offset: z.number().int()
+});
+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()
+});
+var adminUserSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string(),
+  emailVerified: z.boolean(),
+  image: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  role: z.enum(["user", "admin"]),
+  membershipTier: z.enum(["none", "silver", "gold", "premier"]),
+  membershipStatus: z.enum(["active", "inactive", "expired"])
+});
+var adminUserListResponseSchema = pageSchema(adminUserSchema);
+var boundLicenseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  url: z.string(),
+  version: z.string().nullable(),
+  plan: z.string(),
+  lastSeenAt: z.string().nullable()
+});
+var licenseListResponseSchema = pageSchema(boundLicenseSchema);
+var licenseAssertionSchema = z.object({
+  type: z.literal("zpan.license"),
+  issuer: z.string(),
+  subject: z.string(),
+  accountId: z.string(),
+  instanceId: z.string(),
+  storeId: z.string(),
+  edition: z.literal("pro"),
+  authorizedHosts: z.array(z.string()),
+  licenseValidUntil: z.number().int(),
+  issuedAt: z.number().int(),
+  notBefore: z.number().int(),
+  expiresAt: z.number().int()
+});
+
+export {
+  paginationQuerySchema,
+  pageSchema,
+  createPairingSchema,
+  pairingCreateResponseSchema,
+  pairingPreviewSchema,
+  pairingPollResponseSchema,
+  pairingActionSchema,
+  pairingActionResponseSchema,
+  entitlementRefreshResponseSchema,
+  productPriceSchema,
+  deliverableSchema,
+  productMetadataSchema,
+  createProductSchema,
+  updateProductSchema,
+  productListQuerySchema,
+  commerceStoreSchema,
+  commerceProductSchema,
+  productListResponseSchema,
+  storeListResponseSchema,
+  createOrderSchema,
+  orderListQuerySchema,
+  commerceOrderItemSchema,
+  commercePaymentSchema,
+  commerceOrderSchema,
+  orderListResponseSchema,
+  paymentSchema,
+  paymentCreateResponseSchema,
+  billingPortalSessionSchema,
+  billingPortalSessionResponseSchema,
+  orderPatchSchema,
+  giftCardCreateSchema,
+  giftCardCampaignCreateSchema,
+  giftCardPatchSchema,
+  giftCardListQuerySchema,
+  giftCardCampaignListQuerySchema,
+  storeGiftCardSchema,
+  giftCardCampaignSchema,
+  giftCardListResponseSchema,
+  giftCardCampaignListResponseSchema,
+  usageEventCreateSchema,
+  accountUsagePeriodSchema,
+  accountUsageQuerySchema,
+  usageResourceSummarySchema,
+  usageSummarySchema,
+  usageEventCreateResponseSchema,
+  walletRedemptionSchema,
+  walletBalanceSchema,
+  walletLedgerEntrySchema,
+  walletBalanceListResponseSchema,
+  walletLedgerResponseSchema,
+  walletRedemptionResponseSchema,
+  accountWalletResponseSchema,
+  accountBillingQuerySchema,
+  accountOverviewResponseSchema,
+  membershipStripeChannelSchema,
+  accountMembershipResponseSchema,
+  billingRecordItemSchema,
+  billingRecordSchema,
+  billingSummarySchema,
+  accountBillingResponseSchema,
+  storePatchSchema,
+  adminUserPatchSchema,
+  adminUserListQuerySchema,
+  adminUserSchema,
+  adminUserListResponseSchema,
+  boundLicenseSchema,
+  licenseListResponseSchema,
+  licenseAssertionSchema
+};