@wix/astro 0.0.0-experimental-react-component → 0.0.1-experimental

package/build-runtime/chunk-JODQ44LE.js

@@ -0,0 +1,1079 @@
+import {
+  DEFAULT_LIMIT,
+  ITEMS_RESULT_PROPERTY_NAME,
+  PAGING_METADATA_RESULT_PROPERTY_NAME,
+  SDKRequestToRESTRequestRenameMap,
+  createRESTModule,
+  renameKeysFromRESTResponseToSDKResponse,
+  renameKeysFromSDKRequestToRESTRequest,
+  resolveUrl,
+  toURLSearchParams,
+  transformError
+} from "./chunk-EK7YZVWJ.js";
+import {
+  EventDefinition,
+  contextualizeEventDefinitionModuleV2
+} from "./chunk-PSHIUVP2.js";
+import {
+  __export
+} from "./chunk-QRPWKJ4C.js";
+
+// ../../node_modules/@wix/auto_sdk_auth-management_o-auth-apps/build/es/index.mjs
+var es_exports = {};
+__export(es_exports, {
+  DeleteStatus: () => DeleteStatus,
+  Namespace: () => Namespace,
+  OAuthAppType: () => OAuthAppType,
+  OAuthTechnologies: () => OAuthTechnologies,
+  SiteCreatedContext: () => SiteCreatedContext,
+  SortOrder: () => SortOrder,
+  State: () => State,
+  WebhookIdentityType: () => WebhookIdentityType,
+  createOAuthApp: () => createOAuthApp4,
+  deleteOAuthApp: () => deleteOAuthApp4,
+  generateOAuthAppSecret: () => generateOAuthAppSecret4,
+  getOAuthApp: () => getOAuthApp4,
+  onOAuthAppCreated: () => onOAuthAppCreated2,
+  onOAuthAppDeleted: () => onOAuthAppDeleted2,
+  onOAuthAppUpdated: () => onOAuthAppUpdated2,
+  queryOAuthApps: () => queryOAuthApps4,
+  updateOAuthApp: () => updateOAuthApp4
+});
+
+// ../../node_modules/@wix/sdk-runtime/build/transformations/timestamp.js
+function transformSDKTimestampToRESTTimestamp(val) {
+  return val?.toISOString();
+}
+function transformRESTTimestampToSDKTimestamp(val) {
+  return val ? new Date(val) : void 0;
+}
+
+// ../../node_modules/@wix/sdk-runtime/build/transformations/transform-paths.js
+function transformPath(obj, { path, isRepeated, isMap }, transformFn) {
+  const pathParts = path.split(".");
+  if (pathParts.length === 1 && path in obj) {
+    obj[path] = isRepeated ? obj[path].map(transformFn) : isMap ? Object.fromEntries(Object.entries(obj[path]).map(([key, value]) => [key, transformFn(value)])) : transformFn(obj[path]);
+    return obj;
+  }
+  const [first, ...rest] = pathParts;
+  if (first.endsWith("{}")) {
+    const cleanPath = first.slice(0, -2);
+    obj[cleanPath] = Object.fromEntries(Object.entries(obj[cleanPath]).map(([key, value]) => [
+      key,
+      transformPath(value, { path: rest.join("."), isRepeated, isMap }, transformFn)
+    ]));
+  } else if (Array.isArray(obj[first])) {
+    obj[first] = obj[first].map((item) => transformPath(item, { path: rest.join("."), isRepeated, isMap }, transformFn));
+  } else if (first in obj && typeof obj[first] === "object" && obj[first] !== null) {
+    obj[first] = transformPath(obj[first], { path: rest.join("."), isRepeated, isMap }, transformFn);
+  } else if (first === "*") {
+    Object.keys(obj).reduce((acc, curr) => {
+      acc[curr] = transformPath(obj[curr], { path: rest.join("."), isRepeated, isMap }, transformFn);
+      return acc;
+    }, obj);
+  }
+  return obj;
+}
+function transformPaths(obj, transformations) {
+  return transformations.reduce((acc, { paths, transformFn }) => paths.reduce((transformerAcc, path) => transformPath(transformerAcc, path, transformFn), acc), obj);
+}
+
+// ../../node_modules/@wix/sdk-runtime/build/query-filter.js
+function isAndOperator(filter) {
+  return Object.keys(filter).length === 1 && "$and" in filter && Array.isArray(filter.$and);
+}
+function isOrOperator(filter) {
+  return Object.keys(filter).length === 1 && "$or" in filter && Array.isArray(filter.$or);
+}
+function isNotOperator(filter) {
+  return Object.keys(filter).length === 1 && "$not" in filter && typeof filter.$not === "object";
+}
+function and(a, b) {
+  if (typeof a === "undefined" || Object.keys(a).length === 0) {
+    return b;
+  } else if (typeof b === "undefined" || Object.keys(b).length === 0) {
+    return a;
+  } else {
+    return {
+      $and: [
+        ...isAndOperator(a) ? a.$and : [a],
+        ...isAndOperator(b) ? b.$and : [b]
+      ]
+    };
+  }
+}
+function or(a, b) {
+  if (typeof a === "undefined" || Object.keys(a).length === 0) {
+    return b;
+  } else if (typeof b === "undefined" || Object.keys(b).length === 0) {
+    return a;
+  } else {
+    return {
+      $or: [
+        ...isOrOperator(a) ? a.$or : [a],
+        ...isOrOperator(b) ? b.$or : [b]
+      ]
+    };
+  }
+}
+function not(a) {
+  if (typeof a === "undefined" || Object.keys(a).length === 0) {
+    return void 0;
+  } else if (isNotOperator(a)) {
+    return a.$not;
+  } else {
+    return { $not: a };
+  }
+}
+
+// ../../node_modules/@wix/sdk-runtime/build/query-iterators.js
+var Iterator = class {
+  _items;
+  _fetchNextPage;
+  _fetchPrevPage;
+  _originQuery;
+  _limit;
+  constructor({ items, originQuery, fetchNextPage, fetchPrevPage, limit }) {
+    this._items = items;
+    this._fetchNextPage = fetchNextPage;
+    this._fetchPrevPage = fetchPrevPage;
+    this._originQuery = originQuery;
+    this._limit = limit;
+  }
+  get items() {
+    return this._items;
+  }
+  get length() {
+    return this._items.length;
+  }
+  get pageSize() {
+    return this._limit;
+  }
+  get query() {
+    return this._originQuery;
+  }
+  async next() {
+    if (!this.hasNext()) {
+      throw new Error("No next page to fetch");
+    }
+    const nextPageIterator = await this._fetchNextPage();
+    return nextPageIterator;
+  }
+  async prev() {
+    if (!this.hasPrev()) {
+      throw new Error("No previous page to fetch");
+    }
+    const previousPageIterator = await this._fetchPrevPage();
+    return previousPageIterator;
+  }
+};
+var CursorBasedIterator = class extends Iterator {
+  _nextCursor;
+  _prevCursor;
+  cursors;
+  constructor({ items, originQuery, fetchNextPage, fetchPrevPage, limit, nextCursor, prevCursor }) {
+    super({ items, originQuery, fetchNextPage, fetchPrevPage, limit });
+    this._nextCursor = nextCursor;
+    this._prevCursor = prevCursor;
+    this.cursors = {
+      next: nextCursor,
+      prev: prevCursor
+    };
+  }
+  hasNext() {
+    return !!this._nextCursor;
+  }
+  hasPrev() {
+    return !!this._prevCursor;
+  }
+};
+var OffsetBasedIterator = class extends Iterator {
+  _totalCount;
+  _offset;
+  _tooManyToCount;
+  constructor({ items, fetchNextPage, fetchPrevPage, offset, originQuery, limit, totalCount, tooManyToCount }) {
+    super({ items, fetchNextPage, fetchPrevPage, originQuery, limit });
+    this._totalCount = totalCount;
+    this._offset = offset;
+    this._tooManyToCount = tooManyToCount;
+  }
+  get currentPage() {
+    return this._limit === 0 ? void 0 : Math.floor(this._offset / this._limit);
+  }
+  get totalPages() {
+    return this._tooManyToCount || this._limit === 0 ? void 0 : Math.ceil(this._totalCount / this._limit);
+  }
+  get totalCount() {
+    return this._tooManyToCount ? void 0 : this._totalCount;
+  }
+  hasNext() {
+    return Boolean(this._limit !== 0 && this.currentPage !== void 0 && // currentPage 0 is the first page
+    this.totalPages !== void 0 && this.currentPage < this.totalPages - 1);
+  }
+  hasPrev() {
+    return Boolean(this._limit !== 0 && this.currentPage && this.currentPage > 0);
+  }
+};
+
+// ../../node_modules/@wix/sdk-runtime/build/query-builder.js
+function queryBuilder(opts) {
+  const createQueryBuilder = (query) => {
+    return {
+      query,
+      async find() {
+        try {
+          const request = opts.requestTransformer(opts.pagingMethod === "CURSOR" && query.cursorPaging.cursor ? {
+            cursorPaging: query.cursorPaging
+          } : query);
+          const response = await opts.func(request);
+          const { [ITEMS_RESULT_PROPERTY_NAME]: items, [PAGING_METADATA_RESULT_PROPERTY_NAME]: pagingMetadata } = opts.responseTransformer(response);
+          if (opts.pagingMethod === "OFFSET") {
+            const offsetQuery = query;
+            return new OffsetBasedIterator({
+              items: items ?? [],
+              fetchNextPage: () => {
+                return createQueryBuilder({
+                  ...offsetQuery,
+                  paging: {
+                    offset: offsetQuery.paging.offset + offsetQuery.paging.limit,
+                    limit: offsetQuery.paging.limit
+                  }
+                }).find();
+              },
+              fetchPrevPage: () => {
+                return createQueryBuilder({
+                  ...query,
+                  paging: {
+                    offset: Math.max(offsetQuery.paging.offset - offsetQuery.paging.limit, 0),
+                    limit: offsetQuery.paging.limit
+                  }
+                }).find();
+              },
+              offset: offsetQuery.paging.offset,
+              limit: offsetQuery.paging.limit,
+              totalCount: pagingMetadata?.total,
+              tooManyToCount: pagingMetadata?.tooManyToCount,
+              originQuery: this
+            });
+          }
+          const paging = query.cursorPaging;
+          return new CursorBasedIterator({
+            items: items ?? [],
+            limit: paging.limit,
+            originQuery: this,
+            fetchNextPage: () => {
+              return createQueryBuilder({
+                ...query,
+                cursorPaging: {
+                  cursor: pagingMetadata?.cursors?.next ?? void 0,
+                  limit: paging.limit
+                }
+              }).find();
+            },
+            fetchPrevPage: () => {
+              return createQueryBuilder({
+                ...query,
+                cursorPaging: {
+                  cursor: pagingMetadata?.cursors?.prev ?? void 0,
+                  limit: paging.limit
+                }
+              }).find();
+            },
+            prevCursor: pagingMetadata?.cursors?.prev ?? void 0,
+            nextCursor: pagingMetadata?.cursors?.next ?? void 0
+          });
+        } catch (err) {
+          throw opts.errorTransformer(err);
+        }
+      },
+      skipTo(cursor) {
+        return createQueryBuilder({
+          ...query,
+          cursorPaging: {
+            cursor,
+            limit: query.cursorPaging.limit
+          }
+        });
+      },
+      eq(field, value) {
+        const serializableValue = typeof value === "undefined" ? null : value;
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: serializableValue
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      ne(field, value) {
+        const serializableValue = typeof value === "undefined" ? null : value;
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: {
+            $ne: serializableValue
+          }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      ge(field, value) {
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: {
+            $gte: value
+          }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      gt(field, value) {
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: { $gt: value }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      le(field, value) {
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: {
+            $lte: value
+          }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      lt(field, value) {
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: { $lt: value }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      isNotEmpty(field) {
+        return this.ne(field, null);
+      },
+      isEmpty(field) {
+        return this.eq(field, null);
+      },
+      startsWith(field, value) {
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: {
+            $startsWith: value
+          }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      endsWith(field, value) {
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: {
+            $endsWith: value
+          }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      contains(field, value) {
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: {
+            $contains: value
+          }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      hasSome(field, ...values) {
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: {
+            $hasSome: Array.isArray(values[0]) ? values[0] : values
+          }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      hasAll(field, ...values) {
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: {
+            $hasAll: Array.isArray(values[0]) ? values[0] : values
+          }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      between(field, from, to) {
+        return this.ge(field, from).lt(field, to);
+      },
+      in(field, values) {
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: {
+            $in: values
+          }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      exists(field, value = true) {
+        const newFilter = {
+          [renameFieldByPaths(opts.transformationPaths, field)]: {
+            $exists: value
+          }
+        };
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, newFilter)
+        });
+      },
+      or(orQuery) {
+        return createQueryBuilder({
+          ...query,
+          filter: or(query.filter, orQuery.query.filter)
+        });
+      },
+      and(andQuery) {
+        return createQueryBuilder({
+          ...query,
+          filter: and(query.filter, andQuery.query.filter)
+        });
+      },
+      not(notQuery) {
+        return createQueryBuilder({
+          ...query,
+          filter: not(notQuery.query.filter)
+        });
+      },
+      ascending(...fieldNames) {
+        return createQueryBuilder({
+          ...query,
+          sort: [
+            ...query.sort ?? [],
+            ...fieldNames.map((fieldName) => ({
+              fieldName: renameFieldByPaths(opts.transformationPaths, fieldName),
+              order: "ASC"
+            }))
+          ]
+        });
+      },
+      descending(...fieldNames) {
+        return createQueryBuilder({
+          ...query,
+          sort: [
+            ...query.sort ?? [],
+            ...fieldNames.map((fieldName) => ({
+              fieldName: renameFieldByPaths(opts.transformationPaths, fieldName),
+              order: "DESC"
+            }))
+          ]
+        });
+      },
+      skip(offset) {
+        return createQueryBuilder({
+          ...query,
+          paging: {
+            offset,
+            limit: "limit" in query.paging ? query.paging.limit : DEFAULT_LIMIT
+          }
+        });
+      },
+      limit(limit) {
+        if (opts.pagingMethod === "CURSOR") {
+          const cursorQuery = query;
+          return createQueryBuilder({
+            ...query,
+            cursorPaging: {
+              limit,
+              cursor: "cursor" in cursorQuery.cursorPaging ? cursorQuery.cursorPaging.cursor : void 0
+            }
+          });
+        }
+        const offsetQuery = query;
+        return createQueryBuilder({
+          ...query,
+          paging: {
+            limit,
+            offset: "offset" in offsetQuery.paging ? offsetQuery.paging.offset : 0
+          }
+        });
+      }
+    };
+  };
+  return createQueryBuilder({
+    filter: {},
+    ...opts.pagingMethod === "OFFSET" ? { paging: { offset: 0, limit: DEFAULT_LIMIT } } : { cursorPaging: { limit: DEFAULT_LIMIT } }
+  });
+}
+function renameFieldByPaths(transformationPaths, fieldPath) {
+  const transformationPath = Object.entries(transformationPaths).find(([path]) => path === fieldPath || fieldPath.startsWith(`${path}.`))?.[0];
+  if (transformationPath) {
+    return fieldPath.replace(transformationPath, transformationPaths[transformationPath]);
+  }
+  return fieldPath.split(".").map((segment) => transformationPaths[segment] ?? SDKRequestToRESTRequestRenameMap[segment] ?? segment).join(".");
+}
+
+// ../../node_modules/@wix/sdk-runtime/build/transformations/field-mask.js
+function transformSDKFieldMaskToRESTFieldMask(val) {
+  if (!val) {
+    return val;
+  }
+  return val.join(",");
+}
+
+// ../../node_modules/@wix/sdk-runtime/build/event-definition-modules.js
+function createEventModule(eventDefinition) {
+  return contextualizeEventDefinitionModuleV2(eventDefinition);
+}
+
+// ../../node_modules/@wix/auto_sdk_auth-management_o-auth-apps/build/es/index.mjs
+function resolveWixHeadlessV1OAuthAppServiceUrl(opts) {
+  const domainToMappings = {
+    "manage._base_domain_": [
+      {
+        srcPath: "/oauth-app-service",
+        destPath: ""
+      },
+      {
+        srcPath: "/oauth-app",
+        destPath: ""
+      }
+    ],
+    "www.wixapis.com": [
+      {
+        srcPath: "/oauth-app",
+        destPath: ""
+      }
+    ],
+    "api._api_base_domain_": [
+      {
+        srcPath: "/oauth-app-service",
+        destPath: ""
+      }
+    ]
+  };
+  return resolveUrl(Object.assign(opts, { domainToMappings }));
+}
+var PACKAGE_NAME = "@wix/auto_sdk_auth-management_o-auth-apps";
+function createOAuthApp(payload) {
+  function __createOAuthApp({ host }) {
+    const serializedData = transformPaths(payload, [
+      {
+        transformFn: transformSDKTimestampToRESTTimestamp,
+        paths: [{ path: "oAuthApp.createdDate" }]
+      }
+    ]);
+    const metadata = {
+      entityFqdn: "wix.headless.v1.o_auth_app",
+      method: "POST",
+      methodFqn: "wix.headless.v1.OAuthAppService.CreateOAuthApp",
+      packageName: PACKAGE_NAME,
+      url: resolveWixHeadlessV1OAuthAppServiceUrl({
+        protoPath: "/v1/oauth-apps",
+        data: serializedData,
+        host
+      }),
+      data: serializedData,
+      transformResponse: (payload2) => transformPaths(payload2, [
+        {
+          transformFn: transformRESTTimestampToSDKTimestamp,
+          paths: [{ path: "oAuthApp.createdDate" }]
+        }
+      ])
+    };
+    return metadata;
+  }
+  return __createOAuthApp;
+}
+function getOAuthApp(payload) {
+  function __getOAuthApp({ host }) {
+    const metadata = {
+      entityFqdn: "wix.headless.v1.o_auth_app",
+      method: "GET",
+      methodFqn: "wix.headless.v1.OAuthAppService.GetOAuthApp",
+      packageName: PACKAGE_NAME,
+      url: resolveWixHeadlessV1OAuthAppServiceUrl({
+        protoPath: "/v1/oauth-apps/{oAuthAppId}",
+        data: payload,
+        host
+      }),
+      params: toURLSearchParams(payload),
+      transformResponse: (payload2) => transformPaths(payload2, [
+        {
+          transformFn: transformRESTTimestampToSDKTimestamp,
+          paths: [{ path: "oAuthApp.createdDate" }]
+        }
+      ])
+    };
+    return metadata;
+  }
+  return __getOAuthApp;
+}
+function updateOAuthApp(payload) {
+  function __updateOAuthApp({ host }) {
+    const serializedData = transformPaths(payload, [
+      {
+        transformFn: transformSDKFieldMaskToRESTFieldMask,
+        paths: [{ path: "mask" }]
+      },
+      {
+        transformFn: transformSDKTimestampToRESTTimestamp,
+        paths: [{ path: "oAuthApp.createdDate" }]
+      }
+    ]);
+    const metadata = {
+      entityFqdn: "wix.headless.v1.o_auth_app",
+      method: "PATCH",
+      methodFqn: "wix.headless.v1.OAuthAppService.UpdateOAuthApp",
+      packageName: PACKAGE_NAME,
+      url: resolveWixHeadlessV1OAuthAppServiceUrl({
+        protoPath: "/v1/oauth-apps/{oAuthApp.id}",
+        data: serializedData,
+        host
+      }),
+      data: serializedData,
+      transformResponse: (payload2) => transformPaths(payload2, [
+        {
+          transformFn: transformRESTTimestampToSDKTimestamp,
+          paths: [{ path: "oAuthApp.createdDate" }]
+        }
+      ])
+    };
+    return metadata;
+  }
+  return __updateOAuthApp;
+}
+function deleteOAuthApp(payload) {
+  function __deleteOAuthApp({ host }) {
+    const metadata = {
+      entityFqdn: "wix.headless.v1.o_auth_app",
+      method: "DELETE",
+      methodFqn: "wix.headless.v1.OAuthAppService.DeleteOAuthApp",
+      packageName: PACKAGE_NAME,
+      url: resolveWixHeadlessV1OAuthAppServiceUrl({
+        protoPath: "/v1/oauth-apps/{oAuthAppId}",
+        data: payload,
+        host
+      }),
+      params: toURLSearchParams(payload)
+    };
+    return metadata;
+  }
+  return __deleteOAuthApp;
+}
+function queryOAuthApps(payload) {
+  function __queryOAuthApps({ host }) {
+    const metadata = {
+      entityFqdn: "wix.headless.v1.o_auth_app",
+      method: "POST",
+      methodFqn: "wix.headless.v1.OAuthAppService.QueryOAuthApps",
+      packageName: PACKAGE_NAME,
+      url: resolveWixHeadlessV1OAuthAppServiceUrl({
+        protoPath: "/v1/oauth-apps/query",
+        data: payload,
+        host
+      }),
+      data: payload,
+      transformResponse: (payload2) => transformPaths(payload2, [
+        {
+          transformFn: transformRESTTimestampToSDKTimestamp,
+          paths: [{ path: "oAuthApps.createdDate" }]
+        }
+      ])
+    };
+    return metadata;
+  }
+  return __queryOAuthApps;
+}
+function generateOAuthAppSecret(payload) {
+  function __generateOAuthAppSecret({ host }) {
+    const metadata = {
+      entityFqdn: "wix.headless.v1.o_auth_app",
+      method: "POST",
+      methodFqn: "wix.headless.v1.OAuthAppService.GenerateOAuthAppSecret",
+      packageName: PACKAGE_NAME,
+      url: resolveWixHeadlessV1OAuthAppServiceUrl({
+        protoPath: "/v1/oauth-apps/{oAuthAppId}/generate-secret",
+        data: payload,
+        host
+      }),
+      data: payload
+    };
+    return metadata;
+  }
+  return __generateOAuthAppSecret;
+}
+var OAuthAppType = /* @__PURE__ */ ((OAuthAppType2) => {
+  OAuthAppType2["OAUTH_APP_TYPE_UNSPECIFIED"] = "OAUTH_APP_TYPE_UNSPECIFIED";
+  OAuthAppType2["WEB_APP"] = "WEB_APP";
+  OAuthAppType2["MOBILE"] = "MOBILE";
+  OAuthAppType2["OTHER"] = "OTHER";
+  return OAuthAppType2;
+})(OAuthAppType || {});
+var OAuthTechnologies = /* @__PURE__ */ ((OAuthTechnologies2) => {
+  OAuthTechnologies2["OAUTH_TECHNOLOGY_UNSPECIFIED"] = "OAUTH_TECHNOLOGY_UNSPECIFIED";
+  OAuthTechnologies2["JAVASCRIPT"] = "JAVASCRIPT";
+  OAuthTechnologies2["ANGULAR"] = "ANGULAR";
+  OAuthTechnologies2["VUE"] = "VUE";
+  OAuthTechnologies2["REACT"] = "REACT";
+  OAuthTechnologies2["REACT_NATIVE"] = "REACT_NATIVE";
+  OAuthTechnologies2["IOS"] = "IOS";
+  OAuthTechnologies2["ANDROID"] = "ANDROID";
+  OAuthTechnologies2["OTHER_TECHNOLOGY"] = "OTHER_TECHNOLOGY";
+  return OAuthTechnologies2;
+})(OAuthTechnologies || {});
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["ASC"] = "ASC";
+  SortOrder2["DESC"] = "DESC";
+  return SortOrder2;
+})(SortOrder || {});
+var State = /* @__PURE__ */ ((State2) => {
+  State2["UNKNOWN"] = "UNKNOWN";
+  State2["ENABLED"] = "ENABLED";
+  State2["DISABLED"] = "DISABLED";
+  State2["PENDING"] = "PENDING";
+  State2["DEMO"] = "DEMO";
+  return State2;
+})(State || {});
+var SiteCreatedContext = /* @__PURE__ */ ((SiteCreatedContext2) => {
+  SiteCreatedContext2["OTHER"] = "OTHER";
+  SiteCreatedContext2["FROM_TEMPLATE"] = "FROM_TEMPLATE";
+  SiteCreatedContext2["DUPLICATE_BY_SITE_TRANSFER"] = "DUPLICATE_BY_SITE_TRANSFER";
+  SiteCreatedContext2["DUPLICATE"] = "DUPLICATE";
+  SiteCreatedContext2["OLD_SITE_TRANSFER"] = "OLD_SITE_TRANSFER";
+  SiteCreatedContext2["FLASH"] = "FLASH";
+  return SiteCreatedContext2;
+})(SiteCreatedContext || {});
+var Namespace = /* @__PURE__ */ ((Namespace2) => {
+  Namespace2["UNKNOWN_NAMESPACE"] = "UNKNOWN_NAMESPACE";
+  Namespace2["WIX"] = "WIX";
+  Namespace2["SHOUT_OUT"] = "SHOUT_OUT";
+  Namespace2["ALBUMS"] = "ALBUMS";
+  Namespace2["WIX_STORES_TEST_DRIVE"] = "WIX_STORES_TEST_DRIVE";
+  Namespace2["HOTELS"] = "HOTELS";
+  Namespace2["CLUBS"] = "CLUBS";
+  Namespace2["ONBOARDING_DRAFT"] = "ONBOARDING_DRAFT";
+  Namespace2["DEV_SITE"] = "DEV_SITE";
+  Namespace2["LOGOS"] = "LOGOS";
+  Namespace2["VIDEO_MAKER"] = "VIDEO_MAKER";
+  Namespace2["PARTNER_DASHBOARD"] = "PARTNER_DASHBOARD";
+  Namespace2["DEV_CENTER_COMPANY"] = "DEV_CENTER_COMPANY";
+  Namespace2["HTML_DRAFT"] = "HTML_DRAFT";
+  Namespace2["SITELESS_BUSINESS"] = "SITELESS_BUSINESS";
+  Namespace2["CREATOR_ECONOMY"] = "CREATOR_ECONOMY";
+  Namespace2["DASHBOARD_FIRST"] = "DASHBOARD_FIRST";
+  Namespace2["ANYWHERE"] = "ANYWHERE";
+  Namespace2["HEADLESS"] = "HEADLESS";
+  Namespace2["ACCOUNT_MASTER_CMS"] = "ACCOUNT_MASTER_CMS";
+  Namespace2["RISE"] = "RISE";
+  Namespace2["BRANDED_FIRST"] = "BRANDED_FIRST";
+  Namespace2["NOWNIA"] = "NOWNIA";
+  Namespace2["UGC_TEMPLATE"] = "UGC_TEMPLATE";
+  Namespace2["CODUX"] = "CODUX";
+  Namespace2["MEDIA_DESIGN_CREATOR"] = "MEDIA_DESIGN_CREATOR";
+  Namespace2["SHARED_BLOG_ENTERPRISE"] = "SHARED_BLOG_ENTERPRISE";
+  Namespace2["STANDALONE_FORMS"] = "STANDALONE_FORMS";
+  Namespace2["STANDALONE_EVENTS"] = "STANDALONE_EVENTS";
+  Namespace2["MIMIR"] = "MIMIR";
+  Namespace2["TWINS"] = "TWINS";
+  return Namespace2;
+})(Namespace || {});
+var DeleteStatus = /* @__PURE__ */ ((DeleteStatus2) => {
+  DeleteStatus2["UNKNOWN"] = "UNKNOWN";
+  DeleteStatus2["TRASH"] = "TRASH";
+  DeleteStatus2["DELETED"] = "DELETED";
+  DeleteStatus2["PENDING_PURGE"] = "PENDING_PURGE";
+  DeleteStatus2["PURGED_EXTERNALLY"] = "PURGED_EXTERNALLY";
+  return DeleteStatus2;
+})(DeleteStatus || {});
+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 createOAuthApp2(oAuthApp) {
+  const { httpClient, sideEffects } = arguments[1];
+  const payload = renameKeysFromSDKRequestToRESTRequest({ oAuthApp });
+  const reqOpts = createOAuthApp(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+    return renameKeysFromRESTResponseToSDKResponse(result.data)?.oAuthApp;
+  } catch (err) {
+    const transformedError = transformError(
+      err,
+      {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: { oAuthApp: "$[0]" },
+        singleArgumentUnchanged: false
+      },
+      ["oAuthApp"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+async function getOAuthApp2(oAuthAppId) {
+  const { httpClient, sideEffects } = arguments[1];
+  const payload = renameKeysFromSDKRequestToRESTRequest({
+    oAuthAppId
+  });
+  const reqOpts = getOAuthApp(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+    return renameKeysFromRESTResponseToSDKResponse(result.data)?.oAuthApp;
+  } catch (err) {
+    const transformedError = transformError(
+      err,
+      {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: { oAuthAppId: "$[0]" },
+        singleArgumentUnchanged: false
+      },
+      ["oAuthAppId"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+async function updateOAuthApp2(_id, oAuthApp, mask) {
+  const { httpClient, sideEffects } = arguments[3];
+  const payload = renameKeysFromSDKRequestToRESTRequest({
+    oAuthApp: { ...oAuthApp, id: _id },
+    mask
+  });
+  const reqOpts = updateOAuthApp(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+    return renameKeysFromRESTResponseToSDKResponse(result.data)?.oAuthApp;
+  } catch (err) {
+    const transformedError = transformError(
+      err,
+      {
+        spreadPathsToArguments: { oAuthApp: "$[1]" },
+        explicitPathsToArguments: { "oAuthApp.id": "$[0]", mask: "$[2]" },
+        singleArgumentUnchanged: false
+      },
+      ["_id", "oAuthApp", "mask"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+async function deleteOAuthApp2(oAuthAppId) {
+  const { httpClient, sideEffects } = arguments[1];
+  const payload = renameKeysFromSDKRequestToRESTRequest({
+    oAuthAppId
+  });
+  const reqOpts = deleteOAuthApp(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+  } catch (err) {
+    const transformedError = transformError(
+      err,
+      {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: { oAuthAppId: "$[0]" },
+        singleArgumentUnchanged: false
+      },
+      ["oAuthAppId"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+function queryOAuthApps2() {
+  const { httpClient, sideEffects } = arguments[0];
+  return queryBuilder({
+    func: async (payload) => {
+      const reqOpts = queryOAuthApps(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 renameKeysFromSDKRequestToRESTRequest({
+        ...args?.[1],
+        query: args?.[0]
+      });
+    },
+    responseTransformer: ({ data }) => {
+      const transformedData = renameKeysFromRESTResponseToSDKResponse(
+        transformPaths(data, [])
+      );
+      return {
+        items: transformedData?.oAuthApps,
+        pagingMetadata: transformedData?.pagingMetadata
+      };
+    },
+    errorTransformer: (err) => {
+      const transformedError = transformError(err, {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: { query: "$[0]" },
+        singleArgumentUnchanged: false
+      });
+      throw transformedError;
+    },
+    pagingMethod: "OFFSET",
+    transformationPaths: {}
+  });
+}
+async function generateOAuthAppSecret2(oAuthAppId) {
+  const { httpClient, sideEffects } = arguments[1];
+  const payload = renameKeysFromSDKRequestToRESTRequest({
+    oAuthAppId
+  });
+  const reqOpts = generateOAuthAppSecret(payload);
+  sideEffects?.onSiteCall?.();
+  try {
+    const result = await httpClient.request(reqOpts);
+    sideEffects?.onSuccess?.(result);
+    return renameKeysFromRESTResponseToSDKResponse(result.data);
+  } catch (err) {
+    const transformedError = transformError(
+      err,
+      {
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: { oAuthAppId: "$[0]" },
+        singleArgumentUnchanged: false
+      },
+      ["oAuthAppId"]
+    );
+    sideEffects?.onError?.(err);
+    throw transformedError;
+  }
+}
+function createOAuthApp3(httpClient) {
+  return (oAuthApp) => createOAuthApp2(
+    oAuthApp,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function getOAuthApp3(httpClient) {
+  return (oAuthAppId) => getOAuthApp2(
+    oAuthAppId,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function updateOAuthApp3(httpClient) {
+  return (_id, oAuthApp, mask) => updateOAuthApp2(
+    _id,
+    oAuthApp,
+    mask,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function deleteOAuthApp3(httpClient) {
+  return (oAuthAppId) => deleteOAuthApp2(
+    oAuthAppId,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function queryOAuthApps3(httpClient) {
+  return () => queryOAuthApps2(
+    // @ts-ignore
+    { httpClient }
+  );
+}
+function generateOAuthAppSecret3(httpClient) {
+  return (oAuthAppId) => generateOAuthAppSecret2(
+    oAuthAppId,
+    // @ts-ignore
+    { httpClient }
+  );
+}
+var onOAuthAppCreated = EventDefinition(
+  "wix.headless.v1.o_auth_app_created",
+  true,
+  (event) => renameKeysFromRESTResponseToSDKResponse(
+    transformPaths(event, [
+      {
+        transformFn: transformRESTTimestampToSDKTimestamp,
+        paths: [
+          { path: "entity.createdDate" },
+          { path: "metadata.eventTime" }
+        ]
+      }
+    ])
+  )
+)();
+var onOAuthAppDeleted = EventDefinition(
+  "wix.headless.v1.o_auth_app_deleted",
+  true,
+  (event) => renameKeysFromRESTResponseToSDKResponse(
+    transformPaths(event, [
+      {
+        transformFn: transformRESTTimestampToSDKTimestamp,
+        paths: [
+          { path: "undefined.createdDate" },
+          { path: "metadata.eventTime" }
+        ]
+      }
+    ])
+  )
+)();
+var onOAuthAppUpdated = EventDefinition(
+  "wix.headless.v1.o_auth_app_updated",
+  true,
+  (event) => renameKeysFromRESTResponseToSDKResponse(
+    transformPaths(event, [
+      {
+        transformFn: transformRESTTimestampToSDKTimestamp,
+        paths: [
+          { path: "entity.createdDate" },
+          { path: "metadata.eventTime" }
+        ]
+      }
+    ])
+  )
+)();
+var createOAuthApp4 = /* @__PURE__ */ createRESTModule(createOAuthApp3);
+var getOAuthApp4 = /* @__PURE__ */ createRESTModule(getOAuthApp3);
+var updateOAuthApp4 = /* @__PURE__ */ createRESTModule(updateOAuthApp3);
+var deleteOAuthApp4 = /* @__PURE__ */ createRESTModule(deleteOAuthApp3);
+var queryOAuthApps4 = /* @__PURE__ */ createRESTModule(queryOAuthApps3);
+var generateOAuthAppSecret4 = /* @__PURE__ */ createRESTModule(generateOAuthAppSecret3);
+var onOAuthAppCreated2 = createEventModule(onOAuthAppCreated);
+var onOAuthAppDeleted2 = createEventModule(onOAuthAppDeleted);
+var onOAuthAppUpdated2 = createEventModule(onOAuthAppUpdated);
+
+export {
+  es_exports
+};