@wix/auto_sdk_benefit-programs_pools 1.0.22 → 1.0.23

package/build/internal/index.js

@@ -0,0 +1,952 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  EligibilityCheckResultType: () => EligibilityCheckResultType,
+  IdentityType: () => IdentityType,
+  ListPoolsRequestType: () => ListPoolsRequestType,
+  PolicyExpressionType: () => PolicyExpressionType,
+  PoolOrigin: () => PoolOrigin,
+  PoolSelectorType: () => PoolSelectorType,
+  PoolStatus: () => PoolStatus,
+  ProvisionPoolsForProgramResponseType: () => ProvisionPoolsForProgramResponseType,
+  RateLimitedPolicyType: () => RateLimitedPolicyType,
+  SortOrder: () => SortOrder,
+  Type: () => Type,
+  WebhookIdentityType: () => WebhookIdentityType,
+  WeekDay: () => WeekDay,
+  bulkCheckBenefitEligibility: () => bulkCheckBenefitEligibility4,
+  bulkUpdatePools: () => bulkUpdatePools4,
+  checkBenefitEligibility: () => checkBenefitEligibility4,
+  getEligibleBenefits: () => getEligibleBenefits4,
+  getPool: () => getPool4,
+  queryPools: () => queryPools4,
+  redeemBenefit: () => redeemBenefit4,
+  updatePool: () => updatePool4
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/benefit-programs-v1-pool-pools.universal.ts
+var import_transform_error = require("@wix/sdk-runtime/transform-error");
+var import_query_builder = require("@wix/sdk-runtime/query-builder");
+var import_rename_all_nested_keys = require("@wix/sdk-runtime/rename-all-nested-keys");
+
+// src/benefit-programs-v1-pool-pools.http.ts
+var import_rest_modules = require("@wix/sdk-runtime/rest-modules");
+var import_timestamp = require("@wix/sdk-runtime/transformations/timestamp");
+var import_timestamp2 = require("@wix/sdk-runtime/transformations/timestamp");
+var import_field_mask = require("@wix/sdk-runtime/transformations/field-mask");
+var import_transform_paths = require("@wix/sdk-runtime/transformations/transform-paths");
+var import_rest_modules2 = require("@wix/sdk-runtime/rest-modules");
+function resolveWixBenefitProgramsV1PoolPoolServiceUrl(opts) {
+  const domainToMappings = {
+    "api._api_base_domain_": [
+      {
+        srcPath: "/pools",
+        destPath: ""
+      }
+    ],
+    _: [
+      {
+        srcPath: "/_api/benefit-programs-pools",
+        destPath: ""
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/benefits",
+        destPath: "/v1/bulk/benefits"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/pools",
+        destPath: "/v1/bulk/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/pools",
+        destPath: "/v1/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/benefits",
+        destPath: "/v1/benefits"
+      }
+    ],
+    "editor._base_domain_": [
+      {
+        srcPath: "/_api/benefit-programs-pools",
+        destPath: ""
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/benefits",
+        destPath: "/v1/bulk/benefits"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/pools",
+        destPath: "/v1/bulk/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/pools",
+        destPath: "/v1/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/benefits",
+        destPath: "/v1/benefits"
+      }
+    ],
+    "blocks._base_domain_": [
+      {
+        srcPath: "/_api/benefit-programs-pools",
+        destPath: ""
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/benefits",
+        destPath: "/v1/bulk/benefits"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/pools",
+        destPath: "/v1/bulk/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/pools",
+        destPath: "/v1/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/benefits",
+        destPath: "/v1/benefits"
+      }
+    ],
+    "create.editorx": [
+      {
+        srcPath: "/_api/benefit-programs-pools",
+        destPath: ""
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/benefits",
+        destPath: "/v1/bulk/benefits"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/pools",
+        destPath: "/v1/bulk/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/pools",
+        destPath: "/v1/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/benefits",
+        destPath: "/v1/benefits"
+      }
+    ],
+    "editor.wixapps.net": [
+      {
+        srcPath: "/_api/benefit-programs-pools",
+        destPath: ""
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/benefits",
+        destPath: "/v1/bulk/benefits"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/pools",
+        destPath: "/v1/bulk/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/pools",
+        destPath: "/v1/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/benefits",
+        destPath: "/v1/benefits"
+      }
+    ],
+    "manage._base_domain_": [
+      {
+        srcPath: "/_api/benefit-programs-pools",
+        destPath: ""
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/benefits",
+        destPath: "/v1/bulk/benefits"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/pools",
+        destPath: "/v1/bulk/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/pools",
+        destPath: "/v1/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/benefits",
+        destPath: "/v1/benefits"
+      }
+    ],
+    "www._base_domain_": [
+      {
+        srcPath: "/_api/benefit-programs-pools",
+        destPath: ""
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/benefits",
+        destPath: "/v1/benefits"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/pools",
+        destPath: "/v1/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/benefits",
+        destPath: "/v1/bulk/benefits"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/pools",
+        destPath: "/v1/bulk/pools"
+      }
+    ],
+    "*.dev.wix-code.com": [
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/benefits",
+        destPath: "/v1/bulk/benefits"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/bulk/pools",
+        destPath: "/v1/bulk/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/pools",
+        destPath: "/v1/pools"
+      },
+      {
+        srcPath: "/_api/benefit-programs/v1/benefits",
+        destPath: "/v1/benefits"
+      }
+    ],
+    "www.wixapis.com": [
+      {
+        srcPath: "/benefit-programs/v1/bulk/benefits",
+        destPath: "/v1/bulk/benefits"
+      },
+      {
+        srcPath: "/benefit-programs/v1/bulk/pools",
+        destPath: "/v1/bulk/pools"
+      },
+      {
+        srcPath: "/benefit-programs/v1/pools",
+        destPath: "/v1/pools"
+      },
+      {
+        srcPath: "/benefit-programs/v1/benefits",
+        destPath: "/v1/benefits"
+      }
+    ]
+  };
+  return (0, import_rest_modules2.resolveUrl)(Object.assign(opts, { domainToMappings }));
+}
+var PACKAGE_NAME = "@wix/auto_sdk_benefit-programs_pools";
+function getPool(payload) {
+  function __getPool({ host }) {
+    const metadata = {
+      entityFqdn: "wix.benefit_programs.v1.pool",
+      method: "GET",
+      methodFqn: "wix.benefit_programs.v1.pool.PoolService.GetPool",
+      packageName: PACKAGE_NAME,
+      url: resolveWixBenefitProgramsV1PoolPoolServiceUrl({
+        protoPath: "/v1/pools/{poolId}",
+        data: payload,
+        host
+      }),
+      params: (0, import_rest_modules.toURLSearchParams)(payload),
+      transformResponse: (payload2) => (0, import_transform_paths.transformPaths)(payload2, [
+        {
+          transformFn: import_timestamp2.transformRESTTimestampToSDKTimestamp,
+          paths: [{ path: "pool.createdDate" }, { path: "pool.updatedDate" }]
+        }
+      ])
+    };
+    return metadata;
+  }
+  return __getPool;
+}
+function updatePool(payload) {
+  function __updatePool({ host }) {
+    const serializedData = (0, import_transform_paths.transformPaths)(payload, [
+      {
+        transformFn: import_field_mask.transformSDKFieldMaskToRESTFieldMask,
+        paths: [{ path: "fieldMask" }]
+      },
+      {
+        transformFn: import_timestamp.transformSDKTimestampToRESTTimestamp,
+        paths: [{ path: "pool.createdDate" }, { path: "pool.updatedDate" }]
+      }
+    ]);
+    const metadata = {
+      entityFqdn: "wix.benefit_programs.v1.pool",
+      method: "PATCH",
+      methodFqn: "wix.benefit_programs.v1.pool.PoolService.UpdatePool",
+      packageName: PACKAGE_NAME,
+      url: resolveWixBenefitProgramsV1PoolPoolServiceUrl({
+        protoPath: "/v1/pools/{pool.id}",
+        data: serializedData,
+        host
+      }),
+      data: serializedData,
+      transformResponse: (payload2) => (0, import_transform_paths.transformPaths)(payload2, [
+        {
+          transformFn: import_timestamp2.transformRESTTimestampToSDKTimestamp,
+          paths: [{ path: "pool.createdDate" }, { path: "pool.updatedDate" }]
+        }
+      ])
+    };
+    return metadata;
+  }
+  return __updatePool;
+}
+function queryPools(payload) {
+  function __queryPools({ host }) {
+    const metadata = {
+      entityFqdn: "wix.benefit_programs.v1.pool",
+      method: "POST",
+      methodFqn: "wix.benefit_programs.v1.pool.PoolService.QueryPools",
+      packageName: PACKAGE_NAME,
+      url: resolveWixBenefitProgramsV1PoolPoolServiceUrl({
+        protoPath: "/v1/pools/query",
+        data: payload,
+        host
+      }),
+      data: payload,
+      transformResponse: (payload2) => (0, import_transform_paths.transformPaths)(payload2, [
+        {
+          transformFn: import_timestamp2.transformRESTTimestampToSDKTimestamp,
+          paths: [
+            { path: "pools.createdDate" },
+            { path: "pools.updatedDate" }
+          ]
+        }
+      ])
+    };
+    return metadata;
+  }
+  return __queryPools;
+}
+function redeemBenefit(payload) {
+  function __redeemBenefit({ host }) {
+    const serializedData = (0, import_transform_paths.transformPaths)(payload, [
+      {
+        transformFn: import_timestamp.transformSDKTimestampToRESTTimestamp,
+        paths: [{ path: "targetDate" }]
+      }
+    ]);
+    const metadata = {
+      entityFqdn: "wix.benefit_programs.v1.pool",
+      method: "POST",
+      methodFqn: "wix.benefit_programs.v1.pool.PoolService.RedeemBenefit",
+      packageName: PACKAGE_NAME,
+      url: resolveWixBenefitProgramsV1PoolPoolServiceUrl({
+        protoPath: "/v1/benefits/redeem",
+        data: serializedData,
+        host
+      }),
+      data: serializedData
+    };
+    return metadata;
+  }
+  return __redeemBenefit;
+}
+function checkBenefitEligibility(payload) {
+  function __checkBenefitEligibility({ host }) {
+    const serializedData = (0, import_transform_paths.transformPaths)(payload, [
+      {
+        transformFn: import_timestamp.transformSDKTimestampToRESTTimestamp,
+        paths: [{ path: "targetDate" }]
+      }
+    ]);
+    const metadata = {
+      entityFqdn: "wix.benefit_programs.v1.pool",
+      method: "POST",
+      methodFqn: "wix.benefit_programs.v1.pool.PoolService.CheckBenefitEligibility",
+      packageName: PACKAGE_NAME,
+      url: resolveWixBenefitProgramsV1PoolPoolServiceUrl({
+        protoPath: "/v1/pools/check-eligibility",
+        data: serializedData,
+        host
+      }),
+      data: serializedData
+    };
+    return metadata;
+  }
+  return __checkBenefitEligibility;
+}
+function bulkCheckBenefitEligibility(payload) {
+  function __bulkCheckBenefitEligibility({ host }) {
+    const serializedData = (0, import_transform_paths.transformPaths)(payload, [
+      {
+        transformFn: import_timestamp.transformSDKTimestampToRESTTimestamp,
+        paths: [{ path: "benefitSelectors.targetDate" }]
+      }
+    ]);
+    const metadata = {
+      entityFqdn: "wix.benefit_programs.v1.pool",
+      method: "POST",
+      methodFqn: "wix.benefit_programs.v1.pool.PoolService.BulkCheckBenefitEligibility",
+      packageName: PACKAGE_NAME,
+      url: resolveWixBenefitProgramsV1PoolPoolServiceUrl({
+        protoPath: "/v1/bulk/benefits/check-eligibility",
+        data: serializedData,
+        host
+      }),
+      data: serializedData,
+      transformResponse: (payload2) => (0, import_transform_paths.transformPaths)(payload2, [
+        {
+          transformFn: import_timestamp2.transformRESTTimestampToSDKTimestamp,
+          paths: [{ path: "results.benefitSelector.targetDate" }]
+        }
+      ])
+    };
+    return metadata;
+  }
+  return __bulkCheckBenefitEligibility;
+}
+function getEligibleBenefits(payload) {
+  function __getEligibleBenefits({ host }) {
+    const serializedData = (0, import_transform_paths.transformPaths)(payload, [
+      {
+        transformFn: import_timestamp.transformSDKTimestampToRESTTimestamp,
+        paths: [{ path: "targetDate" }]
+      }
+    ]);
+    const metadata = {
+      entityFqdn: "wix.benefit_programs.v1.pool",
+      method: "POST",
+      methodFqn: "wix.benefit_programs.v1.pool.PoolService.GetEligibleBenefits",
+      packageName: PACKAGE_NAME,
+      url: resolveWixBenefitProgramsV1PoolPoolServiceUrl({
+        protoPath: "/v1/pools/eligible-pools",
+        data: serializedData,
+        host
+      }),
+      data: serializedData
+    };
+    return metadata;
+  }
+  return __getEligibleBenefits;
+}
+function bulkUpdatePools(payload) {
+  function __bulkUpdatePools({ host }) {
+    const serializedData = (0, import_transform_paths.transformPaths)(payload, [
+      {
+        transformFn: import_field_mask.transformSDKFieldMaskToRESTFieldMask,
+        paths: [{ path: "pools.fieldMask" }]
+      },
+      {
+        transformFn: import_timestamp.transformSDKTimestampToRESTTimestamp,
+        paths: [
+          { path: "pools.pool.createdDate" },
+          { path: "pools.pool.updatedDate" }
+        ]
+      }
+    ]);
+    const metadata = {
+      entityFqdn: "wix.benefit_programs.v1.pool",
+      method: "POST",
+      methodFqn: "wix.benefit_programs.v1.pool.PoolService.BulkUpdatePools",
+      packageName: PACKAGE_NAME,
+      url: resolveWixBenefitProgramsV1PoolPoolServiceUrl({
+        protoPath: "/v1/bulk/pools",
+        data: serializedData,
+        host
+      }),
+      data: serializedData,
+      transformResponse: (payload2) => (0, import_transform_paths.transformPaths)(payload2, [
+        {
+          transformFn: import_timestamp2.transformRESTTimestampToSDKTimestamp,
+          paths: [
+            { path: "results.pool.createdDate" },
+            { path: "results.pool.updatedDate" }
+          ]
+        }
+      ])
+    };
+    return metadata;
+  }
+  return __bulkUpdatePools;
+}
+
+// src/benefit-programs-v1-pool-pools.universal.ts
+var import_transform_paths2 = require("@wix/sdk-runtime/transformations/transform-paths");
+var PoolStatus = /* @__PURE__ */ ((PoolStatus2) => {
+  PoolStatus2["UNDEFINED"] = "UNDEFINED";
+  PoolStatus2["ACTIVE"] = "ACTIVE";
+  PoolStatus2["PAUSED"] = "PAUSED";
+  PoolStatus2["ENDED"] = "ENDED";
+  PoolStatus2["PROVISIONING"] = "PROVISIONING";
+  PoolStatus2["RENEWING"] = "RENEWING";
+  return PoolStatus2;
+})(PoolStatus || {});
+var IdentityType = /* @__PURE__ */ ((IdentityType2) => {
+  IdentityType2["UNKNOWN"] = "UNKNOWN";
+  IdentityType2["ANONYMOUS_VISITOR"] = "ANONYMOUS_VISITOR";
+  IdentityType2["MEMBER"] = "MEMBER";
+  IdentityType2["WIX_USER"] = "WIX_USER";
+  return IdentityType2;
+})(IdentityType || {});
+var PolicyExpressionType = /* @__PURE__ */ ((PolicyExpressionType2) => {
+  PolicyExpressionType2["UNKNOWN"] = "UNKNOWN";
+  PolicyExpressionType2["OPERATOR_NOT"] = "OPERATOR_NOT";
+  PolicyExpressionType2["OPERATOR_AND"] = "OPERATOR_AND";
+  PolicyExpressionType2["OPERATOR_OR"] = "OPERATOR_OR";
+  PolicyExpressionType2["POLICY"] = "POLICY";
+  return PolicyExpressionType2;
+})(PolicyExpressionType || {});
+var Type = /* @__PURE__ */ ((Type2) => {
+  Type2["UNKNOWN"] = "UNKNOWN";
+  Type2["FIXED_INTERVAL"] = "FIXED_INTERVAL";
+  Type2["RATE_LIMITED"] = "RATE_LIMITED";
+  Type2["CUSTOM"] = "CUSTOM";
+  return Type2;
+})(Type || {});
+var WeekDay = /* @__PURE__ */ ((WeekDay2) => {
+  WeekDay2["UNKNOWN"] = "UNKNOWN";
+  WeekDay2["MONDAY"] = "MONDAY";
+  WeekDay2["TUESDAY"] = "TUESDAY";
+  WeekDay2["WEDNESDAY"] = "WEDNESDAY";
+  WeekDay2["THURSDAY"] = "THURSDAY";
+  WeekDay2["FRIDAY"] = "FRIDAY";
+  WeekDay2["SATURDAY"] = "SATURDAY";
+  WeekDay2["SUNDAY"] = "SUNDAY";
+  return WeekDay2;
+})(WeekDay || {});
+var RateLimitedPolicyType = /* @__PURE__ */ ((RateLimitedPolicyType2) => {
+  RateLimitedPolicyType2["UNKNOWN"] = "UNKNOWN";
+  RateLimitedPolicyType2["FIXED_INTERVAL"] = "FIXED_INTERVAL";
+  RateLimitedPolicyType2["PER_CYCLE"] = "PER_CYCLE";
+  return RateLimitedPolicyType2;
+})(RateLimitedPolicyType || {});
+var PoolOrigin = /* @__PURE__ */ ((PoolOrigin2) => {
+  PoolOrigin2["UNKNOWN"] = "UNKNOWN";
+  PoolOrigin2["PROVISION"] = "PROVISION";
+  PoolOrigin2["CASCADE"] = "CASCADE";
+  return PoolOrigin2;
+})(PoolOrigin || {});
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["ASC"] = "ASC";
+  SortOrder2["DESC"] = "DESC";
+  return SortOrder2;
+})(SortOrder || {});
+var EligibilityCheckResultType = /* @__PURE__ */ ((EligibilityCheckResultType2) => {
+  EligibilityCheckResultType2["UNKNOWN"] = "UNKNOWN";
+  EligibilityCheckResultType2["ELIGIBLE"] = "ELIGIBLE";
+  EligibilityCheckResultType2["NOT_ENOUGH_BALANCE"] = "NOT_ENOUGH_BALANCE";
+  EligibilityCheckResultType2["POOL_NOT_ACTIVE"] = "POOL_NOT_ACTIVE";
+  EligibilityCheckResultType2["BENEFIT_NOT_FOUND"] = "BENEFIT_NOT_FOUND";
+  EligibilityCheckResultType2["POOL_NOT_FOUND"] = "POOL_NOT_FOUND";
+  return EligibilityCheckResultType2;
+})(EligibilityCheckResultType || {});
+var ListPoolsRequestType = /* @__PURE__ */ ((ListPoolsRequestType2) => {
+  ListPoolsRequestType2["UNKNOWN_FILTER"] = "UNKNOWN_FILTER";
+  ListPoolsRequestType2["BY_ITEM_REFERENCE"] = "BY_ITEM_REFERENCE";
+  return ListPoolsRequestType2;
+})(ListPoolsRequestType || {});
+var ProvisionPoolsForProgramResponseType = /* @__PURE__ */ ((ProvisionPoolsForProgramResponseType2) => {
+  ProvisionPoolsForProgramResponseType2["UNKNOWN"] = "UNKNOWN";
+  ProvisionPoolsForProgramResponseType2["SYNC"] = "SYNC";
+  ProvisionPoolsForProgramResponseType2["ASYNC"] = "ASYNC";
+  return ProvisionPoolsForProgramResponseType2;
+})(ProvisionPoolsForProgramResponseType || {});
+var PoolSelectorType = /* @__PURE__ */ ((PoolSelectorType2) => {
+  PoolSelectorType2["UNKNOWN_SELECTOR"] = "UNKNOWN_SELECTOR";
+  PoolSelectorType2["BY_POOL_DEFINITION_ID_AND_PROGRAM_DEFINITION_ID"] = "BY_POOL_DEFINITION_ID_AND_PROGRAM_DEFINITION_ID";
+  PoolSelectorType2["BY_PROGRAM_ID"] = "BY_PROGRAM_ID";
+  return PoolSelectorType2;
+})(PoolSelectorType || {});
+var WebhookIdentityType = /* @__PURE__ */ ((WebhookIdentityType2) => {
+  WebhookIdentityType2["UNKNOWN"] = "UNKNOWN";
+  WebhookIdentityType2["ANONYMOUS_VISITOR"] = "ANONYMOUS_VISITOR";
+  WebhookIdentityType2["MEMBER"] = "MEMBER";
+  WebhookIdentityType2["WIX_USER"] = "WIX_USER";
+  WebhookIdentityType2["APP"] = "APP";
+  return WebhookIdentityType2;
+})(WebhookIdentityType || {});
+async function getPool2(poolId) {
+  const { httpClient, sideEffects } = arguments[1];
+  const payload = (0, import_rename_all_nested_keys.renameKeysFromSDKRequestToRESTRequest)({ poolId });
+  const reqOpts = getPool(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+    return (0, import_rename_all_nested_keys.renameKeysFromRESTResponseToSDKResponse)(result.data)?.pool;
+  } catch (err) {
+    const transformedError = (0, import_transform_error.transformError)(
+      err,
+      {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: { poolId: "$[0]" },
+        singleArgumentUnchanged: false
+      },
+      ["poolId"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+async function updatePool2(_id, pool) {
+  const { httpClient, sideEffects } = arguments[2];
+  const payload = (0, import_rename_all_nested_keys.renameKeysFromSDKRequestToRESTRequest)({
+    pool: { ...pool, id: _id }
+  });
+  const reqOpts = updatePool(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+    return (0, import_rename_all_nested_keys.renameKeysFromRESTResponseToSDKResponse)(result.data)?.pool;
+  } catch (err) {
+    const transformedError = (0, import_transform_error.transformError)(
+      err,
+      {
+        spreadPathsToArguments: { pool: "$[1]" },
+        explicitPathsToArguments: { "pool.id": "$[0]" },
+        singleArgumentUnchanged: false
+      },
+      ["_id", "pool"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+function queryPools2() {
+  const { httpClient, sideEffects } = arguments[0];
+  return (0, import_query_builder.queryBuilder)({
+    func: async (payload) => {
+      const reqOpts = queryPools(payload);
+      sideEffects?.onSiteCall?.();
+      try {
+        const result = await httpClient.request(reqOpts);
+        sideEffects?.onSuccess?.(result);
+        return result;
+      } catch (err) {
+        sideEffects?.onError?.(err);
+        throw err;
+      }
+    },
+    requestTransformer: (query) => {
+      const args = [query, {}];
+      return (0, import_rename_all_nested_keys.renameKeysFromSDKRequestToRESTRequest)({
+        ...args?.[1],
+        query: args?.[0]
+      });
+    },
+    responseTransformer: ({ data }) => {
+      const transformedData = (0, import_rename_all_nested_keys.renameKeysFromRESTResponseToSDKResponse)(
+        (0, import_transform_paths2.transformPaths)(data, [])
+      );
+      return {
+        items: transformedData?.pools,
+        pagingMetadata: transformedData?.metadata
+      };
+    },
+    errorTransformer: (err) => {
+      const transformedError = (0, import_transform_error.transformError)(err, {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: { query: "$[0]" },
+        singleArgumentUnchanged: false
+      });
+      throw transformedError;
+    },
+    pagingMethod: "CURSOR",
+    transformationPaths: {}
+  });
+}
+async function redeemBenefit2(poolId, options) {
+  const { httpClient, sideEffects } = arguments[2];
+  const payload = (0, import_rename_all_nested_keys.renameKeysFromSDKRequestToRESTRequest)({
+    poolId,
+    itemReference: options?.itemReference,
+    benefitKey: options?.benefitKey,
+    count: options?.count,
+    targetDate: options?.targetDate,
+    idempotencyKey: options?.idempotencyKey,
+    additionalData: options?.additionalData,
+    beneficiary: options?.beneficiary,
+    namespace: options?.namespace
+  });
+  const reqOpts = redeemBenefit(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+    return (0, import_rename_all_nested_keys.renameKeysFromRESTResponseToSDKResponse)(result.data);
+  } catch (err) {
+    const transformedError = (0, import_transform_error.transformError)(
+      err,
+      {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: {
+          poolId: "$[0]",
+          itemReference: "$[1].itemReference",
+          benefitKey: "$[1].benefitKey",
+          count: "$[1].count",
+          targetDate: "$[1].targetDate",
+          idempotencyKey: "$[1].idempotencyKey",
+          additionalData: "$[1].additionalData",
+          beneficiary: "$[1].beneficiary",
+          namespace: "$[1].namespace"
+        },
+        singleArgumentUnchanged: false
+      },
+      ["poolId", "options"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+async function checkBenefitEligibility2(poolId, options) {
+  const { httpClient, sideEffects } = arguments[2];
+  const payload = (0, import_rename_all_nested_keys.renameKeysFromSDKRequestToRESTRequest)({
+    poolId,
+    benefitKey: options?.benefitKey,
+    itemReference: options?.itemReference,
+    count: options?.count,
+    targetDate: options?.targetDate,
+    additionalData: options?.additionalData,
+    beneficiary: options?.beneficiary,
+    namespace: options?.namespace
+  });
+  const reqOpts = checkBenefitEligibility(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+    return (0, import_rename_all_nested_keys.renameKeysFromRESTResponseToSDKResponse)(result.data);
+  } catch (err) {
+    const transformedError = (0, import_transform_error.transformError)(
+      err,
+      {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: {
+          poolId: "$[0]",
+          benefitKey: "$[1].benefitKey",
+          itemReference: "$[1].itemReference",
+          count: "$[1].count",
+          targetDate: "$[1].targetDate",
+          additionalData: "$[1].additionalData",
+          beneficiary: "$[1].beneficiary",
+          namespace: "$[1].namespace"
+        },
+        singleArgumentUnchanged: false
+      },
+      ["poolId", "options"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+async function bulkCheckBenefitEligibility2(options) {
+  const { httpClient, sideEffects } = arguments[1];
+  const payload = (0, import_rename_all_nested_keys.renameKeysFromSDKRequestToRESTRequest)({
+    benefitSelectors: options?.benefitSelectors,
+    namespace: options?.namespace,
+    beneficiary: options?.beneficiary
+  });
+  const reqOpts = bulkCheckBenefitEligibility(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+    return (0, import_rename_all_nested_keys.renameKeysFromRESTResponseToSDKResponse)(result.data);
+  } catch (err) {
+    const transformedError = (0, import_transform_error.transformError)(
+      err,
+      {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: {
+          benefitSelectors: "$[0].benefitSelectors",
+          namespace: "$[0].namespace",
+          beneficiary: "$[0].beneficiary"
+        },
+        singleArgumentUnchanged: false
+      },
+      ["options"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+async function getEligibleBenefits2(itemReference, options) {
+  const { httpClient, sideEffects } = arguments[2];
+  const payload = (0, import_rename_all_nested_keys.renameKeysFromSDKRequestToRESTRequest)({
+    itemReference,
+    count: options?.count,
+    targetDate: options?.targetDate,
+    additionalData: options?.additionalData,
+    beneficiary: options?.beneficiary,
+    namespace: options?.namespace
+  });
+  const reqOpts = getEligibleBenefits(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+    return (0, import_rename_all_nested_keys.renameKeysFromRESTResponseToSDKResponse)(result.data);
+  } catch (err) {
+    const transformedError = (0, import_transform_error.transformError)(
+      err,
+      {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: {
+          itemReference: "$[0]",
+          count: "$[1].count",
+          targetDate: "$[1].targetDate",
+          additionalData: "$[1].additionalData",
+          beneficiary: "$[1].beneficiary",
+          namespace: "$[1].namespace"
+        },
+        singleArgumentUnchanged: false
+      },
+      ["itemReference", "options"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+async function bulkUpdatePools2(options) {
+  const { httpClient, sideEffects } = arguments[1];
+  const payload = (0, import_rename_all_nested_keys.renameKeysFromSDKRequestToRESTRequest)({
+    pools: options?.pools,
+    returnEntity: options?.returnEntity
+  });
+  const reqOpts = bulkUpdatePools(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+    return (0, import_rename_all_nested_keys.renameKeysFromRESTResponseToSDKResponse)(result.data);
+  } catch (err) {
+    const transformedError = (0, import_transform_error.transformError)(
+      err,
+      {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: {
+          pools: "$[0].pools",
+          returnEntity: "$[0].returnEntity"
+        },
+        singleArgumentUnchanged: false
+      },
+      ["options"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+
+// src/benefit-programs-v1-pool-pools.public.ts
+function getPool3(httpClient) {
+  return (poolId) => getPool2(
+    poolId,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function updatePool3(httpClient) {
+  return (_id, pool) => updatePool2(
+    _id,
+    pool,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function queryPools3(httpClient) {
+  return () => queryPools2(
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function redeemBenefit3(httpClient) {
+  return (poolId, options) => redeemBenefit2(
+    poolId,
+    options,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function checkBenefitEligibility3(httpClient) {
+  return (poolId, options) => checkBenefitEligibility2(
+    poolId,
+    options,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function bulkCheckBenefitEligibility3(httpClient) {
+  return (options) => bulkCheckBenefitEligibility2(
+    options,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function getEligibleBenefits3(httpClient) {
+  return (itemReference, options) => getEligibleBenefits2(
+    itemReference,
+    options,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function bulkUpdatePools3(httpClient) {
+  return (options) => bulkUpdatePools2(
+    options,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+
+// src/benefit-programs-v1-pool-pools.context.ts
+var import_rest_modules3 = require("@wix/sdk-runtime/rest-modules");
+var getPool4 = /* @__PURE__ */ (0, import_rest_modules3.createRESTModule)(getPool3);
+var updatePool4 = /* @__PURE__ */ (0, import_rest_modules3.createRESTModule)(updatePool3);
+var queryPools4 = /* @__PURE__ */ (0, import_rest_modules3.createRESTModule)(queryPools3);
+var redeemBenefit4 = /* @__PURE__ */ (0, import_rest_modules3.createRESTModule)(redeemBenefit3);
+var checkBenefitEligibility4 = /* @__PURE__ */ (0, import_rest_modules3.createRESTModule)(checkBenefitEligibility3);
+var bulkCheckBenefitEligibility4 = /* @__PURE__ */ (0, import_rest_modules3.createRESTModule)(bulkCheckBenefitEligibility3);
+var getEligibleBenefits4 = /* @__PURE__ */ (0, import_rest_modules3.createRESTModule)(getEligibleBenefits3);
+var bulkUpdatePools4 = /* @__PURE__ */ (0, import_rest_modules3.createRESTModule)(bulkUpdatePools3);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EligibilityCheckResultType,
+  IdentityType,
+  ListPoolsRequestType,
+  PolicyExpressionType,
+  PoolOrigin,
+  PoolSelectorType,
+  PoolStatus,
+  ProvisionPoolsForProgramResponseType,
+  RateLimitedPolicyType,
+  SortOrder,
+  Type,
+  WebhookIdentityType,
+  WeekDay,
+  bulkCheckBenefitEligibility,
+  bulkUpdatePools,
+  checkBenefitEligibility,
+  getEligibleBenefits,
+  getPool,
+  queryPools,
+  redeemBenefit,
+  updatePool
+});
+//# sourceMappingURL=index.js.map