@wix/himalaya-cli 0.1576.0 → 0.1577.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/loyalty/src/index.d.ts

@@ -30,6 +30,20 @@ export interface WixCallOptions {
 /** The per-call header map for `opts`, or undefined when there is nothing to add — so
  *  the no-options path calls the bridge with exactly the 3 arguments it always did. */
 export declare function wixCall<T>(method: string, path: string, body?: unknown, readOptions?: WixCallOptions): Promise<T>;
+export interface WixLoyaltyImage {
+    id?: string;
+    url?: string;
+    height?: number;
+    width?: number;
+    altText?: string;
+    filename?: string;
+}
+export interface WixLoyaltyRewardConfig {
+    tierId?: string;
+    costInPoints?: number;
+    amount?: number;
+    percentage?: number;
+}
 export interface WixLoyaltyProgram {
     id?: string;
     name?: string;
@@ -37,14 +51,33 @@ export interface WixLoyaltyProgram {
     status?: string;
     pointDefinition?: {
         customName?: string;
-        icon?: string;
+        icon?: WixLoyaltyImage;
     };
 }
 export interface WixLoyaltyReward {
     id: string;
     name?: string;
     type?: string;
+    /** Legacy adapter field. REST costs live in the reward's tier configurations. */
     requiredPoints?: number;
+    discountAmount?: {
+        configsByTier?: {
+            tierId?: string;
+            costInPoints?: number;
+            amount?: string;
+        }[];
+    };
+    couponReward?: {
+        fixedAmount?: {
+            configsByTier?: WixLoyaltyRewardConfig[];
+        };
+        percentage?: {
+            configsByTier?: WixLoyaltyRewardConfig[];
+        };
+        freeShipping?: {
+            configsByTier?: WixLoyaltyRewardConfig[];
+        };
+    };
     active?: boolean;
 }
 export interface WixLoyaltyTier {
@@ -52,22 +85,47 @@ export interface WixLoyaltyTier {
     id?: string;
     tierDefinition?: {
         name?: string;
-        icon?: string;
+        icon?: WixLoyaltyImage;
     };
     requiredPoints?: number;
 }
-/** GET /loyalty/v1/program → { loyaltyProgram }. */
+export interface WixLoyaltyEarningRule {
+    id?: string;
+    title?: string;
+    status?: string;
+    triggerActivityType?: string;
+    fixedAmount?: {
+        configs?: {
+            tierId?: string;
+            points?: number;
+        }[];
+    };
+    conversionRate?: {
+        field?: string;
+        configs?: {
+            tierId?: string;
+            moneyAmount?: number;
+            points?: number;
+        }[];
+    };
+}
+/** GET /loyalty-programs/v1/program → { loyaltyProgram }. */
 export declare function getLoyaltyProgram(readOptions?: WixCallOptions): Promise<{
     loyaltyProgram?: WixLoyaltyProgram;
     program?: WixLoyaltyProgram;
 }>;
-/** GET /loyalty/v1/rewards → { rewards }. */
+/** GET /loyalty-rewards/v1/rewards → { rewards }. */
 export declare function listLoyaltyRewards(readOptions?: WixCallOptions): Promise<{
     rewards?: WixLoyaltyReward[];
 }>;
-/** GET /loyalty/v1/tiers → { tiers }. The PUBLIC program tier ladder
- * (wix.loyalty.v1.tier) — NOT the private per-customer tiers-program dashboard. */
+/** GET /loyalty-tiers/v1/tiers → { tiers }. The program tier ladder. */
 export declare function listLoyaltyTiers(readOptions?: WixCallOptions): Promise<{
     tiers?: WixLoyaltyTier[];
 }>;
+/** Active and inactive earning rules in their raw REST shape; callers choose visibility.
+ * @scope visitor
+ */
+export declare function listLoyaltyEarningRules(readOptions?: WixCallOptions): Promise<{
+    earningRules?: WixLoyaltyEarningRule[];
+}>;
 export * from "./extensions.js";

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/online-programs/src/index.d.ts

@@ -215,3 +215,90 @@ export declare function joinProgram(programId: string, options?: {
 }): Promise<WixJoinProgramResponse>;
 /** The cashier handle to settle, or "" when no payable order is available. */
 export declare function payableIdOf(participant?: WixJoinedParticipant): string;
+/** `Participant.enrollmentStatus` values the member list filters on. */
+export declare const MEMBER_ENROLLMENT_STATUSES: {
+    readonly joined: "JOINED";
+    readonly suspended: "SUSPENDED";
+    readonly unknown: "UNKNOWN_ENROLLMENT_STATUS";
+};
+/** `Participant.progressStatus` values that still count as a membership once the enrollment is over. */
+export declare const MEMBER_FINISHED_PROGRESS_STATUSES: readonly ["COMPLETED", "FAILED"];
+export interface WixMemberParticipantsQuery {
+    /** The signed-in member's id (`getMyMember().member.id`). Required: without it the query is the roster of everyone. */
+    memberId: string;
+    /** The `pagingMetadata.cursors.next` of the previous page; omit for the first page. */
+    cursor?: string;
+    /** Page size, default 100 (the upstream page cap for this query). */
+    limit?: number;
+}
+export interface WixQueryMemberParticipantsResponse extends WixQueryParticipantsResponse {
+    pagingMetadata?: WixQueryParticipantsResponse["pagingMetadata"] & {
+        cursors?: {
+            next?: string | null;
+        };
+    };
+}
+/**
+ * POST /online-programs/v3/participants/query — the MEMBER'S participations, cursor-paged, with
+ * progress. Joined and suspended enrollments, plus completed/failed ones whose enrollment has
+ * ended, so a finished program still shows its outcome; left, removed and auto-removed
+ * memberships are excluded. The query language has no `programId: {$in}` on this
+ * endpoint, so callers match memberships to displayed programs locally.
+ *
+ * @scope member — requires the signed-in site member; `memberId` must be that member's own id
+ * (`getMyMember().member.id`). An empty `participants` list means the member has no such
+ * membership, never that the read failed: a failure rejects.
+ */
+export declare function queryMemberParticipants(opts: WixMemberParticipantsQuery): Promise<WixQueryMemberParticipantsResponse>;
+export interface WixProgramParticipationStats {
+    programId?: string;
+    participantsCount?: number;
+    autoRemovedCount?: number;
+}
+export interface WixGetParticipationStatsResponse {
+    participationStats?: WixProgramParticipationStats[];
+}
+/** POST /online-programs/v3/participants/stats — participant counts for a batch of programs (one call per page).
+ *  `programIds` must be non-empty (an empty batch returns `{ participationStats: [] }` without a call);
+ *  a program missing from the answer has no count, not zero.
+ *  @scope visitor — counts are public; an anonymous visitor session is enough. */
+export declare function getParticipationStats(programIds: string[]): Promise<WixGetParticipationStatsResponse>;
+/** `JoinApplication.status` — the member's standing BEFORE a participant exists (a private or paid program). */
+export type WixJoinApplicationStatus = "INVITED" | "APPROVAL_PENDING" | "APPROVED" | "PAYMENT_PENDING" | "SUSPENDED" | "DECLINED" | "CANCELLED" | string;
+export interface WixJoinApplication {
+    id?: string;
+    programId?: string;
+    memberId?: string;
+    status?: WixJoinApplicationStatus;
+    paymentStatus?: string;
+    /** Set once the application became a participant. */
+    participantId?: string;
+    createdDate?: string;
+    updatedDate?: string;
+}
+export interface WixGetCurrentJoinApplicationResponse {
+    joinApplication?: WixJoinApplication;
+}
+/** GET /online-programs/participants/v3/join-applications/current/{programId} — the signed-in member's
+ *  own application to ONE program, or none. Used per card only where an application can exist
+ *  (a private or a priced program the member has not joined). An answer with no `joinApplication`
+ *  means the member never applied.
+ *  @scope member — requires the signed-in site member; a visitor session has no application to read. */
+export declare function getCurrentJoinApplication(programId: string): Promise<WixGetCurrentJoinApplicationResponse>;
+export interface WixProgramCategory {
+    id?: string;
+    label?: string;
+    /** Program ids the category is assigned to. */
+    assignedTo?: string[];
+}
+export interface WixListProgramCategoriesResponse {
+    categories?: WixProgramCategory[];
+}
+/** GET /_api/program-categories-service/v3/categories — every program category of the site (the
+ *  category filter's options). `/_api/…` paths ride the same bridge as the public ones (forms,
+ *  bookings-v2 and ecom already do). An empty `categories` list means the site has none.
+ *  @scope member — the One App member programs list calls it with the member's identity. NOT verified
+ *  live here: codegen/wix/auto/lock.json lists only the APP identity (ONLINE_PROGRAMS.CATEGORY_READ), so a
+ *  visitor or member token can get 403. A caller must treat a rejection as "no category filter", never
+ *  as an error screen. */
+export declare function listProgramCategories(): Promise<WixListProgramCategoriesResponse>;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/wix-loyalty.mjs

@@ -20,17 +20,29 @@ function wixCall(method, path, body, readOptions) {
   return readOptions?.site ? api.call(method, path, body, { "wix-site-id": readOptions.site }) : api.call(method, path, body);
 }
 function getLoyaltyProgram(readOptions) {
-  return wixCall("GET", "/loyalty/v1/program", void 0, readOptions);
+  return wixCall("GET", "/loyalty-programs/v1/program", void 0, readOptions);
+}
+function withLegacyRewardCost(reward) {
+  if (reward.requiredPoints !== void 0) return reward;
+  const configs = reward.discountAmount?.configsByTier ?? reward.couponReward?.fixedAmount?.configsByTier ?? reward.couponReward?.percentage?.configsByTier ?? reward.couponReward?.freeShipping?.configsByTier;
+  const base = configs?.filter((config) => !config.tierId);
+  if (base?.length !== 1) return reward;
+  const cost = base[0].costInPoints;
+  return typeof cost === "number" && Number.isFinite(cost) && cost >= 0 ? { ...reward, requiredPoints: cost } : reward;
 }
 function listLoyaltyRewards(readOptions) {
-  return wixCall("GET", "/loyalty/v1/rewards", void 0, readOptions);
+  return wixCall("GET", "/loyalty-rewards/v1/rewards", void 0, readOptions).then((response) => response.rewards ? { ...response, rewards: response.rewards.map(withLegacyRewardCost) } : response);
 }
 function listLoyaltyTiers(readOptions) {
-  return wixCall("GET", "/loyalty/v1/tiers", void 0, readOptions);
+  return wixCall("GET", "/loyalty-tiers/v1/tiers", void 0, readOptions);
+}
+function listLoyaltyEarningRules(readOptions) {
+  return wixCall("GET", "/_api/loyalty-earning-rules/v1/earning-rules/rules", void 0, readOptions);
 }
 export {
   getLoyaltyBffDashboard,
   getLoyaltyProgram,
+  listLoyaltyEarningRules,
   listLoyaltyRewards,
   listLoyaltyTiers,
   wixCall

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/wix-online-programs.mjs

@@ -81,10 +81,52 @@ function payableIdOf(participant) {
   const pending = participant?.paymentPendingOptions;
   return pending?.purchaseFlowId || pending?.snapshotId || pending?.orderId || "";
 }
+var MEMBER_ENROLLMENT_STATUSES = {
+  joined: "JOINED",
+  suspended: "SUSPENDED",
+  unknown: "UNKNOWN_ENROLLMENT_STATUS"
+};
+var MEMBER_FINISHED_PROGRESS_STATUSES = ["COMPLETED", "FAILED"];
+function queryMemberParticipants(opts) {
+  if (!opts?.memberId) throw new Error("queryMemberParticipants: memberId is required");
+  const limit = opts.limit ?? 100;
+  const query = opts.cursor ? { cursorPaging: { limit, cursor: opts.cursor } } : {
+    filter: {
+      memberId: opts.memberId,
+      $or: [
+        { enrollmentStatus: { $in: [MEMBER_ENROLLMENT_STATUSES.joined, MEMBER_ENROLLMENT_STATUSES.suspended] } },
+        { enrollmentStatus: MEMBER_ENROLLMENT_STATUSES.unknown, progressStatus: { $in: [...MEMBER_FINISHED_PROGRESS_STATUSES] } }
+      ]
+    },
+    cursorPaging: { limit }
+  };
+  return wixCall("POST", "/online-programs/v3/participants/query", { query, fields: ["PROGRESS"] });
+}
+function getParticipationStats(programIds) {
+  const ids = [...new Set((programIds ?? []).filter((id) => typeof id === "string" && id))];
+  if (!ids.length) return Promise.resolve({ participationStats: [] });
+  return wixCall("POST", "/online-programs/v3/participants/stats", { programIds: ids });
+}
+function getCurrentJoinApplication(programId) {
+  if (!programId) throw new Error("getCurrentJoinApplication: programId is required");
+  return wixCall(
+    "GET",
+    `/online-programs/participants/v3/join-applications/current/${encodeURIComponent(programId)}`
+  );
+}
+function listProgramCategories() {
+  return wixCall("GET", "/_api/program-categories-service/v3/categories");
+}
 export {
+  MEMBER_ENROLLMENT_STATUSES,
+  MEMBER_FINISHED_PROGRESS_STATUSES,
+  getCurrentJoinApplication,
+  getParticipationStats,
   getProgram,
   joinProgram,
+  listProgramCategories,
   payableIdOf,
+  queryMemberParticipants,
   queryParticipants,
   queryPrograms,
   searchMemberParticipation