@wix/cli 1.1.60 → 1.1.62

package/build/{chunk-OISYBAR4.js → chunk-Y5LMYOCJ.js}

@@ -4,19 +4,19 @@ import {
   require_isexe
 } from "./chunk-OJHDGJWP.js";
 import {
-  require_http_cache_semantics
-} from "./chunk-YXFEXGAH.js";
+  GridAppLayout
+} from "./chunk-6LI4WGAW.js";
 import {
   resolveUrl,
   serializer,
   toURLSearchParams
-} from "./chunk-24KEFD7K.js";
+} from "./chunk-XOFZJ3JQ.js";
 import {
   require_clean,
   require_is_core_module,
   require_semver,
   require_valid
-} from "./chunk-XWFG3TRU.js";
+} from "./chunk-4ZQFECEW.js";
 import {
   require_index_node,
   require_ms,
@@ -24,10 +24,10 @@ import {
 } from "./chunk-WN3D6AOY.js";
 import {
   z
-} from "./chunk-BNWDAMAL.js";
+} from "./chunk-PX2L3CCA.js";
 import {
   require_verror
-} from "./chunk-GG7YZNYL.js";
+} from "./chunk-YQW75RJ5.js";
 import {
   __commonJS,
   __dirname,
@@ -34881,6 +34881,474 @@ var require_options = __commonJS({
   }
 });
 
+// ../../node_modules/http-cache-semantics/index.js
+var require_http_cache_semantics = __commonJS({
+  "../../node_modules/http-cache-semantics/index.js"(exports2, module2) {
+    "use strict";
+    init_esm_shims();
+    var statusCodeCacheableByDefault = /* @__PURE__ */ new Set([
+      200,
+      203,
+      204,
+      206,
+      300,
+      301,
+      308,
+      404,
+      405,
+      410,
+      414,
+      501
+    ]);
+    var understoodStatuses = /* @__PURE__ */ new Set([
+      200,
+      203,
+      204,
+      300,
+      301,
+      302,
+      303,
+      307,
+      308,
+      404,
+      405,
+      410,
+      414,
+      501
+    ]);
+    var errorStatusCodes = /* @__PURE__ */ new Set([
+      500,
+      502,
+      503,
+      504
+    ]);
+    var hopByHopHeaders = {
+      date: true,
+      // included, because we add Age update Date
+      connection: true,
+      "keep-alive": true,
+      "proxy-authenticate": true,
+      "proxy-authorization": true,
+      te: true,
+      trailer: true,
+      "transfer-encoding": true,
+      upgrade: true
+    };
+    var excludedFromRevalidationUpdate = {
+      // Since the old body is reused, it doesn't make sense to change properties of the body
+      "content-length": true,
+      "content-encoding": true,
+      "transfer-encoding": true,
+      "content-range": true
+    };
+    function toNumberOrZero(s) {
+      const n = parseInt(s, 10);
+      return isFinite(n) ? n : 0;
+    }
+    function isErrorResponse(response) {
+      if (!response) {
+        return true;
+      }
+      return errorStatusCodes.has(response.status);
+    }
+    function parseCacheControl(header) {
+      const cc = {};
+      if (!header) return cc;
+      const parts = header.trim().split(/,/);
+      for (const part of parts) {
+        const [k, v] = part.split(/=/, 2);
+        cc[k.trim()] = v === void 0 ? true : v.trim().replace(/^"|"$/g, "");
+      }
+      return cc;
+    }
+    function formatCacheControl(cc) {
+      let parts = [];
+      for (const k in cc) {
+        const v = cc[k];
+        parts.push(v === true ? k : k + "=" + v);
+      }
+      if (!parts.length) {
+        return void 0;
+      }
+      return parts.join(", ");
+    }
+    module2.exports = class CachePolicy {
+      constructor(req, res, {
+        shared,
+        cacheHeuristic,
+        immutableMinTimeToLive,
+        ignoreCargoCult,
+        _fromObject
+      } = {}) {
+        if (_fromObject) {
+          this._fromObject(_fromObject);
+          return;
+        }
+        if (!res || !res.headers) {
+          throw Error("Response headers missing");
+        }
+        this._assertRequestHasHeaders(req);
+        this._responseTime = this.now();
+        this._isShared = shared !== false;
+        this._cacheHeuristic = void 0 !== cacheHeuristic ? cacheHeuristic : 0.1;
+        this._immutableMinTtl = void 0 !== immutableMinTimeToLive ? immutableMinTimeToLive : 24 * 3600 * 1e3;
+        this._status = "status" in res ? res.status : 200;
+        this._resHeaders = res.headers;
+        this._rescc = parseCacheControl(res.headers["cache-control"]);
+        this._method = "method" in req ? req.method : "GET";
+        this._url = req.url;
+        this._host = req.headers.host;
+        this._noAuthorization = !req.headers.authorization;
+        this._reqHeaders = res.headers.vary ? req.headers : null;
+        this._reqcc = parseCacheControl(req.headers["cache-control"]);
+        if (ignoreCargoCult && "pre-check" in this._rescc && "post-check" in this._rescc) {
+          delete this._rescc["pre-check"];
+          delete this._rescc["post-check"];
+          delete this._rescc["no-cache"];
+          delete this._rescc["no-store"];
+          delete this._rescc["must-revalidate"];
+          this._resHeaders = Object.assign({}, this._resHeaders, {
+            "cache-control": formatCacheControl(this._rescc)
+          });
+          delete this._resHeaders.expires;
+          delete this._resHeaders.pragma;
+        }
+        if (res.headers["cache-control"] == null && /no-cache/.test(res.headers.pragma)) {
+          this._rescc["no-cache"] = true;
+        }
+      }
+      now() {
+        return Date.now();
+      }
+      storable() {
+        return !!(!this._reqcc["no-store"] && // A cache MUST NOT store a response to any request, unless:
+        // The request method is understood by the cache and defined as being cacheable, and
+        ("GET" === this._method || "HEAD" === this._method || "POST" === this._method && this._hasExplicitExpiration()) && // the response status code is understood by the cache, and
+        understoodStatuses.has(this._status) && // the "no-store" cache directive does not appear in request or response header fields, and
+        !this._rescc["no-store"] && // the "private" response directive does not appear in the response, if the cache is shared, and
+        (!this._isShared || !this._rescc.private) && // the Authorization header field does not appear in the request, if the cache is shared,
+        (!this._isShared || this._noAuthorization || this._allowsStoringAuthenticated()) && // the response either:
+        // contains an Expires header field, or
+        (this._resHeaders.expires || // contains a max-age response directive, or
+        // contains a s-maxage response directive and the cache is shared, or
+        // contains a public response directive.
+        this._rescc["max-age"] || this._isShared && this._rescc["s-maxage"] || this._rescc.public || // has a status code that is defined as cacheable by default
+        statusCodeCacheableByDefault.has(this._status)));
+      }
+      _hasExplicitExpiration() {
+        return this._isShared && this._rescc["s-maxage"] || this._rescc["max-age"] || this._resHeaders.expires;
+      }
+      _assertRequestHasHeaders(req) {
+        if (!req || !req.headers) {
+          throw Error("Request headers missing");
+        }
+      }
+      satisfiesWithoutRevalidation(req) {
+        this._assertRequestHasHeaders(req);
+        const requestCC = parseCacheControl(req.headers["cache-control"]);
+        if (requestCC["no-cache"] || /no-cache/.test(req.headers.pragma)) {
+          return false;
+        }
+        if (requestCC["max-age"] && this.age() > requestCC["max-age"]) {
+          return false;
+        }
+        if (requestCC["min-fresh"] && this.timeToLive() < 1e3 * requestCC["min-fresh"]) {
+          return false;
+        }
+        if (this.stale()) {
+          const allowsStale = requestCC["max-stale"] && !this._rescc["must-revalidate"] && (true === requestCC["max-stale"] || requestCC["max-stale"] > this.age() - this.maxAge());
+          if (!allowsStale) {
+            return false;
+          }
+        }
+        return this._requestMatches(req, false);
+      }
+      _requestMatches(req, allowHeadMethod) {
+        return (!this._url || this._url === req.url) && this._host === req.headers.host && // the request method associated with the stored response allows it to be used for the presented request, and
+        (!req.method || this._method === req.method || allowHeadMethod && "HEAD" === req.method) && // selecting header fields nominated by the stored response (if any) match those presented, and
+        this._varyMatches(req);
+      }
+      _allowsStoringAuthenticated() {
+        return this._rescc["must-revalidate"] || this._rescc.public || this._rescc["s-maxage"];
+      }
+      _varyMatches(req) {
+        if (!this._resHeaders.vary) {
+          return true;
+        }
+        if (this._resHeaders.vary === "*") {
+          return false;
+        }
+        const fields = this._resHeaders.vary.trim().toLowerCase().split(/\s*,\s*/);
+        for (const name of fields) {
+          if (req.headers[name] !== this._reqHeaders[name]) return false;
+        }
+        return true;
+      }
+      _copyWithoutHopByHopHeaders(inHeaders) {
+        const headers = {};
+        for (const name in inHeaders) {
+          if (hopByHopHeaders[name]) continue;
+          headers[name] = inHeaders[name];
+        }
+        if (inHeaders.connection) {
+          const tokens = inHeaders.connection.trim().split(/\s*,\s*/);
+          for (const name of tokens) {
+            delete headers[name];
+          }
+        }
+        if (headers.warning) {
+          const warnings = headers.warning.split(/,/).filter((warning) => {
+            return !/^\s*1[0-9][0-9]/.test(warning);
+          });
+          if (!warnings.length) {
+            delete headers.warning;
+          } else {
+            headers.warning = warnings.join(",").trim();
+          }
+        }
+        return headers;
+      }
+      responseHeaders() {
+        const headers = this._copyWithoutHopByHopHeaders(this._resHeaders);
+        const age = this.age();
+        if (age > 3600 * 24 && !this._hasExplicitExpiration() && this.maxAge() > 3600 * 24) {
+          headers.warning = (headers.warning ? `${headers.warning}, ` : "") + '113 - "rfc7234 5.5.4"';
+        }
+        headers.age = `${Math.round(age)}`;
+        headers.date = new Date(this.now()).toUTCString();
+        return headers;
+      }
+      /**
+       * Value of the Date response header or current time if Date was invalid
+       * @return timestamp
+       */
+      date() {
+        const serverDate = Date.parse(this._resHeaders.date);
+        if (isFinite(serverDate)) {
+          return serverDate;
+        }
+        return this._responseTime;
+      }
+      /**
+       * Value of the Age header, in seconds, updated for the current time.
+       * May be fractional.
+       *
+       * @return Number
+       */
+      age() {
+        let age = this._ageValue();
+        const residentTime = (this.now() - this._responseTime) / 1e3;
+        return age + residentTime;
+      }
+      _ageValue() {
+        return toNumberOrZero(this._resHeaders.age);
+      }
+      /**
+       * Value of applicable max-age (or heuristic equivalent) in seconds. This counts since response's `Date`.
+       *
+       * For an up-to-date value, see `timeToLive()`.
+       *
+       * @return Number
+       */
+      maxAge() {
+        if (!this.storable() || this._rescc["no-cache"]) {
+          return 0;
+        }
+        if (this._isShared && (this._resHeaders["set-cookie"] && !this._rescc.public && !this._rescc.immutable)) {
+          return 0;
+        }
+        if (this._resHeaders.vary === "*") {
+          return 0;
+        }
+        if (this._isShared) {
+          if (this._rescc["proxy-revalidate"]) {
+            return 0;
+          }
+          if (this._rescc["s-maxage"]) {
+            return toNumberOrZero(this._rescc["s-maxage"]);
+          }
+        }
+        if (this._rescc["max-age"]) {
+          return toNumberOrZero(this._rescc["max-age"]);
+        }
+        const defaultMinTtl = this._rescc.immutable ? this._immutableMinTtl : 0;
+        const serverDate = this.date();
+        if (this._resHeaders.expires) {
+          const expires = Date.parse(this._resHeaders.expires);
+          if (Number.isNaN(expires) || expires < serverDate) {
+            return 0;
+          }
+          return Math.max(defaultMinTtl, (expires - serverDate) / 1e3);
+        }
+        if (this._resHeaders["last-modified"]) {
+          const lastModified = Date.parse(this._resHeaders["last-modified"]);
+          if (isFinite(lastModified) && serverDate > lastModified) {
+            return Math.max(
+              defaultMinTtl,
+              (serverDate - lastModified) / 1e3 * this._cacheHeuristic
+            );
+          }
+        }
+        return defaultMinTtl;
+      }
+      timeToLive() {
+        const age = this.maxAge() - this.age();
+        const staleIfErrorAge = age + toNumberOrZero(this._rescc["stale-if-error"]);
+        const staleWhileRevalidateAge = age + toNumberOrZero(this._rescc["stale-while-revalidate"]);
+        return Math.max(0, age, staleIfErrorAge, staleWhileRevalidateAge) * 1e3;
+      }
+      stale() {
+        return this.maxAge() <= this.age();
+      }
+      _useStaleIfError() {
+        return this.maxAge() + toNumberOrZero(this._rescc["stale-if-error"]) > this.age();
+      }
+      useStaleWhileRevalidate() {
+        return this.maxAge() + toNumberOrZero(this._rescc["stale-while-revalidate"]) > this.age();
+      }
+      static fromObject(obj) {
+        return new this(void 0, void 0, { _fromObject: obj });
+      }
+      _fromObject(obj) {
+        if (this._responseTime) throw Error("Reinitialized");
+        if (!obj || obj.v !== 1) throw Error("Invalid serialization");
+        this._responseTime = obj.t;
+        this._isShared = obj.sh;
+        this._cacheHeuristic = obj.ch;
+        this._immutableMinTtl = obj.imm !== void 0 ? obj.imm : 24 * 3600 * 1e3;
+        this._status = obj.st;
+        this._resHeaders = obj.resh;
+        this._rescc = obj.rescc;
+        this._method = obj.m;
+        this._url = obj.u;
+        this._host = obj.h;
+        this._noAuthorization = obj.a;
+        this._reqHeaders = obj.reqh;
+        this._reqcc = obj.reqcc;
+      }
+      toObject() {
+        return {
+          v: 1,
+          t: this._responseTime,
+          sh: this._isShared,
+          ch: this._cacheHeuristic,
+          imm: this._immutableMinTtl,
+          st: this._status,
+          resh: this._resHeaders,
+          rescc: this._rescc,
+          m: this._method,
+          u: this._url,
+          h: this._host,
+          a: this._noAuthorization,
+          reqh: this._reqHeaders,
+          reqcc: this._reqcc
+        };
+      }
+      /**
+       * Headers for sending to the origin server to revalidate stale response.
+       * Allows server to return 304 to allow reuse of the previous response.
+       *
+       * Hop by hop headers are always stripped.
+       * Revalidation headers may be added or removed, depending on request.
+       */
+      revalidationHeaders(incomingReq) {
+        this._assertRequestHasHeaders(incomingReq);
+        const headers = this._copyWithoutHopByHopHeaders(incomingReq.headers);
+        delete headers["if-range"];
+        if (!this._requestMatches(incomingReq, true) || !this.storable()) {
+          delete headers["if-none-match"];
+          delete headers["if-modified-since"];
+          return headers;
+        }
+        if (this._resHeaders.etag) {
+          headers["if-none-match"] = headers["if-none-match"] ? `${headers["if-none-match"]}, ${this._resHeaders.etag}` : this._resHeaders.etag;
+        }
+        const forbidsWeakValidators = headers["accept-ranges"] || headers["if-match"] || headers["if-unmodified-since"] || this._method && this._method != "GET";
+        if (forbidsWeakValidators) {
+          delete headers["if-modified-since"];
+          if (headers["if-none-match"]) {
+            const etags = headers["if-none-match"].split(/,/).filter((etag) => {
+              return !/^\s*W\//.test(etag);
+            });
+            if (!etags.length) {
+              delete headers["if-none-match"];
+            } else {
+              headers["if-none-match"] = etags.join(",").trim();
+            }
+          }
+        } else if (this._resHeaders["last-modified"] && !headers["if-modified-since"]) {
+          headers["if-modified-since"] = this._resHeaders["last-modified"];
+        }
+        return headers;
+      }
+      /**
+       * Creates new CachePolicy with information combined from the previews response,
+       * and the new revalidation response.
+       *
+       * Returns {policy, modified} where modified is a boolean indicating
+       * whether the response body has been modified, and old cached body can't be used.
+       *
+       * @return {Object} {policy: CachePolicy, modified: Boolean}
+       */
+      revalidatedPolicy(request, response) {
+        this._assertRequestHasHeaders(request);
+        if (this._useStaleIfError() && isErrorResponse(response)) {
+          return {
+            modified: false,
+            matches: false,
+            policy: this
+          };
+        }
+        if (!response || !response.headers) {
+          throw Error("Response headers missing");
+        }
+        let matches = false;
+        if (response.status !== void 0 && response.status != 304) {
+          matches = false;
+        } else if (response.headers.etag && !/^\s*W\//.test(response.headers.etag)) {
+          matches = this._resHeaders.etag && this._resHeaders.etag.replace(/^\s*W\//, "") === response.headers.etag;
+        } else if (this._resHeaders.etag && response.headers.etag) {
+          matches = this._resHeaders.etag.replace(/^\s*W\//, "") === response.headers.etag.replace(/^\s*W\//, "");
+        } else if (this._resHeaders["last-modified"]) {
+          matches = this._resHeaders["last-modified"] === response.headers["last-modified"];
+        } else {
+          if (!this._resHeaders.etag && !this._resHeaders["last-modified"] && !response.headers.etag && !response.headers["last-modified"]) {
+            matches = true;
+          }
+        }
+        if (!matches) {
+          return {
+            policy: new this.constructor(request, response),
+            // Client receiving 304 without body, even if it's invalid/mismatched has no option
+            // but to reuse a cached body. We don't have a good way to tell clients to do
+            // error recovery in such case.
+            modified: response.status != 304,
+            matches: false
+          };
+        }
+        const headers = {};
+        for (const k in this._resHeaders) {
+          headers[k] = k in response.headers && !excludedFromRevalidationUpdate[k] ? response.headers[k] : this._resHeaders[k];
+        }
+        const newResponse = Object.assign({}, response, {
+          status: this._status,
+          method: this._method,
+          headers
+        });
+        return {
+          policy: new this.constructor(request, newResponse, {
+            shared: this._isShared,
+            cacheHeuristic: this._cacheHeuristic,
+            immutableMinTimeToLive: this._immutableMinTtl
+          }),
+          modified: false,
+          matches: true
+        };
+      }
+    };
+  }
+});
+
 // ../../node_modules/negotiator/lib/charset.js
 var require_charset = __commonJS({
   "../../node_modules/negotiator/lib/charset.js"(exports2, module2) {
@@ -49223,6 +49691,46 @@ var require_types_impl = __commonJS({
   }
 });
 
+// ../../node_modules/@wix/ambassador-velo-ide-v1-gridapp-filestructure/build/cjs/types.impl.js
+var require_types_impl2 = __commonJS({
+  "../../node_modules/@wix/ambassador-velo-ide-v1-gridapp-filestructure/build/cjs/types.impl.js"(exports2) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WebhookIdentityType = exports2.Action = exports2.GridAppLayout = exports2.FileType = void 0;
+    var FileType;
+    (function(FileType2) {
+      FileType2["FILE"] = "FILE";
+      FileType2["DIRECTORY"] = "DIRECTORY";
+    })(FileType = exports2.FileType || (exports2.FileType = {}));
+    var GridAppLayout3;
+    (function(GridAppLayout4) {
+      GridAppLayout4["UNKNOWN_GRID_APP_LAYOUT"] = "UNKNOWN_GRID_APP_LAYOUT";
+      GridAppLayout4["ONLINE"] = "ONLINE";
+      GridAppLayout4["GITHUB"] = "GITHUB";
+      GridAppLayout4["GITHUB_BLOCKS"] = "GITHUB_BLOCKS";
+      GridAppLayout4["WIX_IDE"] = "WIX_IDE";
+    })(GridAppLayout3 = exports2.GridAppLayout || (exports2.GridAppLayout = {}));
+    var Action;
+    (function(Action2) {
+      Action2["UNKNOWN"] = "UNKNOWN";
+      Action2["UPDATE"] = "UPDATE";
+      Action2["CREATE"] = "CREATE";
+      Action2["MOVE"] = "MOVE";
+      Action2["OVERWRITE"] = "OVERWRITE";
+      Action2["COPY"] = "COPY";
+    })(Action = exports2.Action || (exports2.Action = {}));
+    var WebhookIdentityType;
+    (function(WebhookIdentityType2) {
+      WebhookIdentityType2["UNKNOWN"] = "UNKNOWN";
+      WebhookIdentityType2["ANONYMOUS_VISITOR"] = "ANONYMOUS_VISITOR";
+      WebhookIdentityType2["MEMBER"] = "MEMBER";
+      WebhookIdentityType2["WIX_USER"] = "WIX_USER";
+      WebhookIdentityType2["APP"] = "APP";
+    })(WebhookIdentityType = exports2.WebhookIdentityType || (exports2.WebhookIdentityType = {}));
+  }
+});
+
 // ../../node_modules/@wix/velo-site-types-syncer/build/index.js
 init_esm_shims();
 import { mkdir as mkdir5 } from "node:fs/promises";
@@ -49385,11 +49893,18 @@ async function pRetry(input, options) {
 
 // ../../node_modules/@wix/velo-site-types-syncer/build/index.js
 var import_comment_json2 = __toESM(require_src3(), 1);
+var import_http_client = __toESM(require_index_node(), 1);
 import { join as join3 } from "node:path";
 import { mkdir as mkdir2 } from "node:fs/promises";
 import { join as join32, dirname as dirname2, relative as relative22 } from "node:path";
-import { mkdir as mkdir3, writeFile as writeFile3, rm, readFile as readFile3 } from "node:fs/promises";
-import path, { dirname as dirname3, join as join5, relative as relative4 } from "node:path";
+import { mkdir as mkdir3, writeFile as writeFile3, rm as rm2, readFile as readFile3 } from "node:fs/promises";
+import path, { dirname as dirname3, join as join6, relative as relative4 } from "node:path";
+var import_verror2 = __toESM(require_verror(), 1);
+var import_types = __toESM(require_types_impl(), 1);
+var import_types_impl = __toESM(require_types_impl2(), 1);
+import { join as join5 } from "node:path";
+import { readdir, rm, unlink } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import process2 from "node:process";
 
 // ../../node_modules/@wix/ambassador-typok-v1-site/build/es/http.impl.js
@@ -49553,49 +50068,10 @@ function getLatestPageTypes(payload) {
 getLatestPageTypes.__isAmbassador = true;
 
 // ../../node_modules/@wix/velo-site-types-syncer/build/index.js
-var import_verror2 = __toESM(require_verror(), 1);
-var import_http_client = __toESM(require_index_node(), 1);
 var import_verror3 = __toESM(require_verror(), 1);
-var import_types = __toESM(require_types_impl(), 1);
-import { join as join6 } from "node:path";
-import { readdir, rm as rm2, unlink } from "node:fs/promises";
-import { existsSync } from "node:fs";
 import { join as join7 } from "node:path";
 import { mkdir as mkdir4 } from "node:fs/promises";
 
-// ../../node_modules/@wix/ambassador-velo-ide-v1-gridapp-filestructure/build/es/types.impl.js
-init_esm_shims();
-var FileType;
-(function(FileType2) {
-  FileType2["FILE"] = "FILE";
-  FileType2["DIRECTORY"] = "DIRECTORY";
-})(FileType || (FileType = {}));
-var GridAppLayout;
-(function(GridAppLayout3) {
-  GridAppLayout3["UNKNOWN_GRID_APP_LAYOUT"] = "UNKNOWN_GRID_APP_LAYOUT";
-  GridAppLayout3["ONLINE"] = "ONLINE";
-  GridAppLayout3["GITHUB"] = "GITHUB";
-  GridAppLayout3["GITHUB_BLOCKS"] = "GITHUB_BLOCKS";
-  GridAppLayout3["WIX_IDE"] = "WIX_IDE";
-})(GridAppLayout || (GridAppLayout = {}));
-var Action;
-(function(Action2) {
-  Action2["UNKNOWN"] = "UNKNOWN";
-  Action2["UPDATE"] = "UPDATE";
-  Action2["CREATE"] = "CREATE";
-  Action2["MOVE"] = "MOVE";
-  Action2["OVERWRITE"] = "OVERWRITE";
-  Action2["COPY"] = "COPY";
-})(Action || (Action = {}));
-var WebhookIdentityType;
-(function(WebhookIdentityType2) {
-  WebhookIdentityType2["UNKNOWN"] = "UNKNOWN";
-  WebhookIdentityType2["ANONYMOUS_VISITOR"] = "ANONYMOUS_VISITOR";
-  WebhookIdentityType2["MEMBER"] = "MEMBER";
-  WebhookIdentityType2["WIX_USER"] = "WIX_USER";
-  WebhookIdentityType2["APP"] = "APP";
-})(WebhookIdentityType || (WebhookIdentityType = {}));
-
 // ../../node_modules/@wix/ambassador-velo-ide-v1-path-transform/build/es/http.impl.js
 init_esm_shims();
 var _transformPathRequest = {};
@@ -50019,6 +50495,70 @@ async function updateRootConfigPageReferences(projectFolder, createdPageIds, rem
   );
   await writeRootConfig(projectFolder, rootConfig);
 }
+async function httpRequest(opts, requestOptions) {
+  try {
+    return await new import_http_client.HttpClient(opts).request(requestOptions);
+  } catch (e) {
+    if (e instanceof import_http_client.HttpError) {
+      if (e.response?.status === 403) {
+        throw new import_verror2.default(
+          {
+            name: "PermissionDenied",
+            cause: e
+          },
+          "Forbidden operation. Missing permissions"
+        );
+      }
+      throw e;
+    } else {
+      throw e;
+    }
+  }
+}
+var cleanupTypes = async (projectFolder) => {
+  const typesDir = getTypesDir2(projectFolder);
+  if (!existsSync(typesDir)) {
+    return Promise.resolve();
+  }
+  const filesOrDirs = await readdir(typesDir, { withFileTypes: true });
+  const rootConfigPath = join5(projectFolder, "jsconfig.json");
+  const files = filesOrDirs.filter((f) => f.isFile());
+  const dirs = filesOrDirs.filter(
+    (dir) => dir.isDirectory() && dir.name !== WIX_CODE_TYPES_DIR
+  );
+  return Promise.all([
+    () => {
+      if (existsSync(rootConfigPath)) {
+        return unlink(rootConfigPath);
+      }
+      Promise.resolve();
+    },
+    ...files.map((file) => unlink(join5(typesDir, file.name))),
+    ...dirs.map((dir) => rm(join5(typesDir, dir.name), { recursive: true }))
+  ]);
+};
+var getPageCodeFilePathFromLayoutPath = (pFolder, page) => {
+  return join5(pFolder, page.pageMetaData.layoutPath);
+};
+var isGridAppLayout = (layout) => {
+  return typeof layout === "string" && isValidGridAppLayout(layout);
+};
+var isCustomLayout = (layout) => {
+  return typeof layout === "function";
+};
+var isValidGridAppLayout = (layout) => {
+  return Object.keys(import_types.GridAppLayout).includes(layout);
+};
+var widgetDtsContent = `declare global {
+  namespace $widget {
+    const props: any;
+    function fireEvent(eventName: string, data: any): void;
+    function onPropsChanged(handler: onPropsChangedHandler): any;
+    type onPropsChangedHandler = (oldProps: any, newProps: any) => void;
+  }
+}
+
+export {};`;
 async function syncTypesForPages(projectFolder, pagesData, definitions, hasMasterPage = true) {
   await writeFile3(
     definitions.types.getBackendDTSPath(projectFolder),
@@ -50042,7 +50582,7 @@ async function syncTypesForPages(projectFolder, pagesData, definitions, hasMaste
       await Promise.all(
         Object.entries(pageDeclarationsFiles).map(
           async ([filename, content]) => {
-            await writeFile3(join5(pageConfigDir, filename), content);
+            await writeFile3(join6(pageConfigDir, filename), content);
           }
         )
       );
@@ -50079,7 +50619,7 @@ function getConfigForPage(projectFolder, page, definitions) {
       jsx: "react",
       paths: {
         "public/*": [
-          join5(
+          join6(
             relative4(
               dirname3(configFilePath),
               definitions.layout.getPublicFolder(projectFolder)
@@ -50088,7 +50628,7 @@ function getConfigForPage(projectFolder, page, definitions) {
           )
         ],
         "backend/*.web.js": [
-          join5(
+          join6(
             relative4(
               dirname3(configFilePath),
               definitions.layout.getBackendFolder(projectFolder)
@@ -50097,7 +50637,7 @@ function getConfigForPage(projectFolder, page, definitions) {
           )
         ],
         "backend/*.web": [
-          join5(
+          join6(
             relative4(
               dirname3(configFilePath),
               definitions.layout.getBackendFolder(projectFolder)
@@ -50119,14 +50659,14 @@ function getConfigForPage(projectFolder, page, definitions) {
       ...Object.entries(
         getPageDeclarationFiles(projectFolder, page, definitions)
       ).map(([filename]) => filename),
-      join5(
+      join6(
         relative4(
           dirname3(configFilePath),
           definitions.layout.getPublicFolder(projectFolder)
         ),
         "**/*"
       ),
-      join5(
+      join6(
         relative4(
           dirname3(configFilePath),
           definitions.layout.getBackendFolder(projectFolder)
@@ -50158,6 +50698,7 @@ function getPageDeclarationFiles(projectFolder, page, definitions, hasMasterPage
       "index.d.ts": `type PageElementsMap = MasterPageElementsMap;`
     };
   }
+  let returnedDeclarationFiles;
   if (hasMasterPage) {
     const masterPageDTSDir = dirname3(
       definitions.types.getPageConfigFilename(projectFolder, MASTER_PAGE_NAME)
@@ -50168,81 +50709,31 @@ function getPageDeclarationFiles(projectFolder, page, definitions, hasMasterPage
         page.pageMetaData.pageId
       )
     );
-    const masterPageDTSRelativePath = join5(
+    const masterPageDTSRelativePath = join6(
       relative4(pageDTSDir, masterPageDTSDir),
       definitions.types.getPageElementsMapDTSFilename(MASTER_PAGE_NAME)
     );
-    return {
+    returnedDeclarationFiles = {
       [pageDTSFilename]: `/// <reference path="${masterPageDTSRelativePath}" />
 type PageElementsMap = MasterPageElementsMap & {${pageElementsMapContent}}`
     };
   } else {
-    return {
+    returnedDeclarationFiles = {
       [pageDTSFilename]: `type PageElementsMap = {${pageElementsMapContent}}`
     };
   }
+  if (definitions.layout.outputLayout === import_types_impl.GridAppLayout.GITHUB_BLOCKS) {
+    returnedDeclarationFiles["widget.d.ts"] = widgetDtsContent;
+  }
+  return returnedDeclarationFiles;
 }
 async function deletePageTypes(projectFolder, pageId, definitions) {
   const pageConfigFile = definitions.types.getPageConfigFilename(
     projectFolder,
     pageId
   );
-  await rm(path.dirname(pageConfigFile), { recursive: true });
-}
-async function httpRequest(opts, requestOptions) {
-  try {
-    return await new import_http_client.HttpClient(opts).request(requestOptions);
-  } catch (e) {
-    if (e instanceof import_http_client.HttpError) {
-      if (e.response?.status === 403) {
-        throw new import_verror3.default(
-          {
-            name: "PermissionDenied",
-            cause: e
-          },
-          "Forbidden operation. Missing permissions"
-        );
-      }
-      throw e;
-    } else {
-      throw e;
-    }
-  }
+  await rm2(path.dirname(pageConfigFile), { recursive: true });
 }
-var cleanupTypes = async (projectFolder) => {
-  const typesDir = getTypesDir2(projectFolder);
-  if (!existsSync(typesDir)) {
-    return Promise.resolve();
-  }
-  const filesOrDirs = await readdir(typesDir, { withFileTypes: true });
-  const rootConfigPath = join6(projectFolder, "jsconfig.json");
-  const files = filesOrDirs.filter((f) => f.isFile());
-  const dirs = filesOrDirs.filter(
-    (dir) => dir.isDirectory() && dir.name !== WIX_CODE_TYPES_DIR
-  );
-  return Promise.all([
-    () => {
-      if (existsSync(rootConfigPath)) {
-        return unlink(rootConfigPath);
-      }
-      Promise.resolve();
-    },
-    ...files.map((file) => unlink(join6(typesDir, file.name))),
-    ...dirs.map((dir) => rm2(join6(typesDir, dir.name), { recursive: true }))
-  ]);
-};
-var getPageCodeFilePathFromLayoutPath = (pFolder, page) => {
-  return join6(pFolder, page.pageMetaData.layoutPath);
-};
-var isGridAppLayout = (layout) => {
-  return typeof layout === "string" && isValidGridAppLayout(layout);
-};
-var isCustomLayout = (layout) => {
-  return typeof layout === "function";
-};
-var isValidGridAppLayout = (layout) => {
-  return Object.keys(import_types.GridAppLayout).includes(layout);
-};
 var pageSchema = z.object({
   pageTitle: z.string().optional().default(""),
   pageMetaData: z.object({
@@ -50261,7 +50752,7 @@ var siteSchema = z.object({
 var getSiteTypesSchema = z.object({
   site: siteSchema
 });
-var { WError } = import_verror2.default;
+var { WError } = import_verror3.default;
 async function fetchPagesData(metaSiteId, revision, requestOptions) {
   let response;
   try {
@@ -50498,7 +50989,8 @@ var createAgnosticTypeSyncer = async (projectFolder, layout = GridAppLayout.GITH
     layout: {
       getPageCodeFilePath: getPageCodeFilePathFromLayoutPath,
       getBackendFolder: (projectFolder_ = "") => join7(projectFolder_, backendFolder),
-      getPublicFolder: (projectFolder_ = "") => join7(projectFolder_, publicFolder)
+      getPublicFolder: (projectFolder_ = "") => join7(projectFolder_, publicFolder),
+      outputLayout: layout
     },
     types: {
       getBackendConfigPath,
@@ -50795,7 +51287,6 @@ async function syncTypes(projectFolder, pagesData, definitions = defaultDefiniti
 }
 
 export {
-  GridAppLayout,
   require_negotiator,
   agnosticTypeSyncer_default,
   syncRevisionTypes,
@@ -50883,4 +51374,4 @@ make-fetch-happen/lib/fetch.js:
    * governing permissions and limitations under the License.
    *)
 */
-//# sourceMappingURL=chunk-OISYBAR4.js.map
+//# sourceMappingURL=chunk-Y5LMYOCJ.js.map