@webstudio-is/sdk 0.269.0 → 0.271.0

package/lib/schema.js

@@ -0,0 +1,902 @@
+// src/schema/assets.ts
+import { z } from "zod";
+import { FontFormat, FontMeta } from "@webstudio-is/fonts";
+var AssetId = z.string();
+var baseAsset = {
+  id: AssetId,
+  projectId: z.string(),
+  size: z.number(),
+  name: z.string(),
+  filename: z.string().optional(),
+  description: z.union([z.string().optional(), z.null()]),
+  createdAt: z.string()
+};
+var FontAsset = z.object({
+  ...baseAsset,
+  format: FontFormat,
+  meta: FontMeta,
+  type: z.literal("font")
+});
+var ImageMeta = z.object({
+  width: z.number(),
+  height: z.number()
+});
+var ImageAsset = z.object({
+  ...baseAsset,
+  format: z.string(),
+  meta: ImageMeta,
+  type: z.literal("image")
+});
+var FileAsset = z.object({
+  ...baseAsset,
+  format: z.string(),
+  meta: z.object({}),
+  type: z.literal("file")
+});
+var Asset = z.union([FontAsset, ImageAsset, FileAsset]);
+var Assets = z.map(AssetId, Asset);
+
+// src/schema/breakpoints.ts
+import { z as z2 } from "zod";
+var BreakpointId = z2.string();
+var Breakpoint = z2.object({
+  id: BreakpointId,
+  label: z2.string(),
+  minWidth: z2.number().optional(),
+  maxWidth: z2.number().optional(),
+  condition: z2.string().optional()
+}).transform((data) => {
+  if (data.condition !== void 0 && data.condition.trim() === "") {
+    return { ...data, condition: void 0 };
+  }
+  return data;
+}).refine(({ minWidth, maxWidth, condition }) => {
+  if (condition !== void 0) {
+    return minWidth === void 0 && maxWidth === void 0;
+  }
+  if (minWidth !== void 0 && maxWidth !== void 0) {
+    return minWidth < maxWidth;
+  }
+  return true;
+}, "Width-based (minWidth/maxWidth) and condition are mutually exclusive, and minWidth must be less than maxWidth");
+var Breakpoints = z2.map(BreakpointId, Breakpoint);
+var initialBreakpoints = [
+  { id: "placeholder", label: "Base" },
+  { id: "placeholder", label: "Tablet", maxWidth: 991 },
+  { id: "placeholder", label: "Mobile landscape", maxWidth: 767 },
+  { id: "placeholder", label: "Mobile portrait", maxWidth: 479 }
+];
+
+// src/schema/data-sources.ts
+import { z as z3 } from "zod";
+var DataSourceId = z3.string();
+var DataSourceVariableValue = z3.union([
+  z3.object({
+    type: z3.literal("number"),
+    // initial value of variable store
+    value: z3.number()
+  }),
+  z3.object({
+    type: z3.literal("string"),
+    value: z3.string()
+  }),
+  z3.object({
+    type: z3.literal("boolean"),
+    value: z3.boolean()
+  }),
+  z3.object({
+    type: z3.literal("string[]"),
+    value: z3.array(z3.string())
+  }),
+  z3.object({
+    type: z3.literal("json"),
+    value: z3.unknown()
+  })
+]);
+var DataSource = z3.union([
+  z3.object({
+    type: z3.literal("variable"),
+    id: DataSourceId,
+    // The instance should always be specified for variables,
+    // however, there was a bug in the embed template
+    // which produced variables without an instance
+    // and these variables will fail validation
+    // if we make it required
+    scopeInstanceId: z3.string().optional(),
+    name: z3.string(),
+    value: DataSourceVariableValue
+  }),
+  z3.object({
+    type: z3.literal("parameter"),
+    id: DataSourceId,
+    scopeInstanceId: z3.string().optional(),
+    name: z3.string()
+  }),
+  z3.object({
+    type: z3.literal("resource"),
+    id: DataSourceId,
+    scopeInstanceId: z3.string().optional(),
+    name: z3.string(),
+    resourceId: z3.string()
+  })
+]);
+var DataSources = z3.map(DataSourceId, DataSource);
+
+// src/schema/deployment.ts
+import { z as z4 } from "zod";
+var Templates = z4.enum([
+  "docker",
+  "vercel",
+  "netlify",
+  "ssg",
+  "ssg-netlify",
+  "ssg-vercel"
+]);
+var Deployment = z4.union([
+  z4.object({
+    destination: z4.literal("static"),
+    name: z4.string(),
+    assetsDomain: z4.string(),
+    // Must be validated very strictly
+    templates: z4.array(Templates)
+  }),
+  z4.object({
+    destination: z4.literal("saas").optional(),
+    domains: z4.array(z4.string()),
+    assetsDomain: z4.string().optional(),
+    /**
+     * @deprecated This field is deprecated, use `domains` instead.
+     */
+    projectDomain: z4.string().optional(),
+    excludeWstdDomainFromSearch: z4.boolean().optional()
+  })
+]);
+
+// src/schema/instances.ts
+import { z as z5 } from "zod";
+var TextChild = z5.object({
+  type: z5.literal("text"),
+  value: z5.string(),
+  placeholder: z5.boolean().optional()
+});
+var InstanceId = z5.string();
+var IdChild = z5.object({
+  type: z5.literal("id"),
+  value: InstanceId
+});
+var ExpressionChild = z5.object({
+  type: z5.literal("expression"),
+  value: z5.string()
+});
+var InstanceChild = z5.union([IdChild, TextChild, ExpressionChild]);
+var Instance = z5.object({
+  type: z5.literal("instance"),
+  id: InstanceId,
+  component: z5.string(),
+  tag: z5.string().optional(),
+  label: z5.string().optional(),
+  children: z5.array(InstanceChild)
+});
+var Instances = z5.map(InstanceId, Instance);
+
+// src/schema/pages.ts
+import { z as z6 } from "zod";
+import { validateBasicAuth } from "@webstudio-is/wsauth";
+var MIN_TITLE_LENGTH = 2;
+var PageId = z6.string();
+var FolderId = z6.string();
+var FolderName = z6.string().refine((value) => value.trim() !== "", "Can't be empty");
+var Slug = z6.string().refine(
+  (path) => /^[-a-z0-9]*$/.test(path),
+  "Only a-z, 0-9 and - are allowed"
+);
+var Folder = z6.object({
+  id: FolderId,
+  name: FolderName,
+  slug: Slug,
+  children: z6.array(z6.union([FolderId, PageId]))
+});
+var PageName = z6.string().refine((value) => value.trim() !== "", "Can't be empty");
+var PageTitle = z6.string().refine(
+  (val) => val.length >= MIN_TITLE_LENGTH,
+  `Minimum ${MIN_TITLE_LENGTH} characters required`
+);
+var documentTypes = ["html", "xml", "text"];
+var BasicAuthFields = {
+  login: z6.string(),
+  password: z6.string()
+};
+var validateBasicAuthFields = ({
+  login,
+  password
+}, context) => {
+  for (const issue of validateBasicAuth({ login, password }).issues ?? []) {
+    context.addIssue({
+      code: z6.ZodIssueCode.custom,
+      path: issue.path,
+      message: issue.message
+    });
+  }
+};
+var PageBasicAuth = z6.object({
+  method: z6.literal("basic"),
+  ...BasicAuthFields
+}).superRefine(validateBasicAuthFields);
+var LegacyPageBasicAuth = z6.object({
+  type: z6.literal("basic"),
+  ...BasicAuthFields
+}).superRefine(validateBasicAuthFields).transform(({ login, password }) => ({
+  method: "basic",
+  login,
+  password
+}));
+var PageAuth = z6.union([PageBasicAuth, LegacyPageBasicAuth]);
+var commonPageFields = {
+  id: PageId,
+  name: PageName,
+  title: PageTitle,
+  history: z6.optional(z6.array(z6.string())),
+  rootInstanceId: z6.string(),
+  systemDataSourceId: z6.string().optional(),
+  meta: z6.object({
+    description: z6.string().optional(),
+    title: z6.string().optional(),
+    excludePageFromSearch: z6.string().optional(),
+    language: z6.string().optional(),
+    socialImageAssetId: z6.string().optional(),
+    socialImageUrl: z6.string().optional(),
+    status: z6.string().optional(),
+    redirect: z6.string().optional(),
+    documentType: z6.optional(z6.enum(documentTypes)),
+    content: z6.string().optional(),
+    auth: PageAuth.optional(),
+    custom: z6.array(
+      z6.object({
+        property: z6.string(),
+        content: z6.string()
+      })
+    ).optional()
+  }),
+  marketplace: z6.optional(
+    z6.object({
+      include: z6.optional(z6.boolean()),
+      category: z6.optional(z6.string()),
+      thumbnailAssetId: z6.optional(z6.string())
+    })
+  )
+};
+var HomePagePath = z6.string().refine((path) => path === "", "Home page path must be empty");
+var DefaultPagePage = z6.string().refine((path) => path !== "", "Can't be empty").refine((path) => path !== "/", "Can't be just a /").refine((path) => path.endsWith("/") === false, "Can't end with a /").refine((path) => path.includes("//") === false, "Can't contain repeating /").refine(
+  (path) => /^[-_a-z0-9*:?\\/.]*$/.test(path),
+  "Only a-z, 0-9, -, _, /, :, ?, . and * are allowed"
+).refine(
+  // We use /s for our system stuff like /s/css or /s/uploads
+  (path) => path !== "/s" && path.startsWith("/s/") === false,
+  "/s prefix is reserved for the system"
+).refine(
+  // Remix serves build artefacts like JS bundles from /build
+  // And we cannot customize it due to bug in Remix: https://github.com/remix-run/remix/issues/2933
+  (path) => path !== "/build" && path.startsWith("/build/") === false,
+  "/build prefix is reserved for the system"
+).refine((path) => path.length <= 255, "Path can't exceed 255 characters");
+var RedirectSourcePath = z6.string().refine((path) => path !== "", "Can't be empty").refine((path) => path !== "/", "Can't be just a /").refine(
+  (path) => path.startsWith("/") && path.startsWith("//") === false,
+  "Must start with a /"
+).refine((path) => {
+  if (/[\\\u0000-\u001f\u007f]/.test(path)) {
+    return false;
+  }
+  try {
+    new URL(path, "https://example.com");
+    return true;
+  } catch {
+    return false;
+  }
+}, "Must be a valid URL path").refine(
+  (path) => path !== "/s" && path.startsWith("/s/") === false,
+  "/s prefix is reserved for the system"
+).refine(
+  (path) => path !== "/build" && path.startsWith("/build/") === false,
+  "/build prefix is reserved for the system"
+);
+var PagePath = DefaultPagePage.refine(
+  (path) => path === "" || path.startsWith("/"),
+  "Must start with a / or a full URL e.g. https://website.org"
+);
+var Page = z6.object({
+  ...commonPageFields,
+  path: z6.union([HomePagePath, PagePath])
+});
+var PageTemplate = z6.object({
+  id: PageId,
+  name: PageName,
+  title: PageTitle,
+  rootInstanceId: z6.string(),
+  systemDataSourceId: z6.string().optional(),
+  meta: commonPageFields.meta
+});
+var ProjectMeta = z6.object({
+  // All fields are optional to ensure consistency and allow for the addition of new fields without requiring migration
+  siteName: z6.string().optional(),
+  contactEmail: z6.string().optional(),
+  faviconAssetId: z6.string().optional(),
+  code: z6.string().optional(),
+  auth: z6.string().optional()
+});
+var ProjectNewRedirectPath = z6.string().min(1, "Path is required").refine((data) => {
+  try {
+    new URL(data, "http://url.com");
+    return true;
+  } catch {
+    return false;
+  }
+}, "Must be a valid URL");
+var PageRedirect = z6.object({
+  old: RedirectSourcePath,
+  new: ProjectNewRedirectPath,
+  status: z6.enum(["301", "302"]).optional()
+});
+var CompilerSettings = z6.object({
+  // All fields are optional to ensure consistency and allow for the addition of new fields without requiring migration
+  atomicStyles: z6.boolean().optional()
+});
+var Pages = z6.object({
+  meta: ProjectMeta.optional(),
+  compiler: CompilerSettings.optional(),
+  redirects: z6.array(PageRedirect).optional(),
+  homePageId: PageId,
+  rootFolderId: FolderId,
+  pages: z6.map(PageId, Page),
+  pageTemplates: z6.map(PageId, PageTemplate).optional(),
+  folders: z6.map(FolderId, Folder).refine((folders) => folders.size > 0, "Folders can't be empty")
+}).superRefine((pages, context) => {
+  const homePage = pages.pages.get(pages.homePageId);
+  const rootFolder = pages.folders.get(pages.rootFolderId);
+  if (homePage === void 0) {
+    context.addIssue({
+      code: z6.ZodIssueCode.custom,
+      path: ["homePageId"],
+      message: "Home page must reference an existing page"
+    });
+  }
+  if (rootFolder === void 0) {
+    context.addIssue({
+      code: z6.ZodIssueCode.custom,
+      path: ["rootFolderId"],
+      message: "Root folder must reference an existing folder"
+    });
+  }
+  if (homePage !== void 0 && homePage.path !== "") {
+    context.addIssue({
+      code: z6.ZodIssueCode.custom,
+      path: ["pages", pages.homePageId, "path"],
+      message: "Home page path must be empty"
+    });
+  }
+  for (const [pageId, page] of pages.pages) {
+    if (page.id !== pageId) {
+      context.addIssue({
+        code: z6.ZodIssueCode.custom,
+        path: ["pages", pageId, "id"],
+        message: "Page id must match its record key"
+      });
+    }
+    if (pageId !== pages.homePageId && page.path === "") {
+      context.addIssue({
+        code: z6.ZodIssueCode.custom,
+        path: ["pages", pageId, "path"],
+        message: "Page path can't be empty"
+      });
+    }
+  }
+  for (const [templateId, template] of pages.pageTemplates ?? []) {
+    if (template.id !== templateId) {
+      context.addIssue({
+        code: z6.ZodIssueCode.custom,
+        path: ["pageTemplates", templateId, "id"],
+        message: "Page template id must match its record key"
+      });
+    }
+    if (pages.pages.has(templateId)) {
+      context.addIssue({
+        code: z6.ZodIssueCode.custom,
+        path: ["pageTemplates", templateId, "id"],
+        message: "Page template id must not match an existing page id"
+      });
+    }
+  }
+  for (const [folderId, folder] of pages.folders) {
+    if (folder.id !== folderId) {
+      context.addIssue({
+        code: z6.ZodIssueCode.custom,
+        path: ["folders", folderId, "id"],
+        message: "Folder id must match its record key"
+      });
+    }
+    for (const [index, childId] of folder.children.entries()) {
+      if (pages.pages.has(childId) === false && pages.folders.has(childId) === false) {
+        context.addIssue({
+          code: z6.ZodIssueCode.custom,
+          path: ["folders", folderId, "children", index],
+          message: "Folder child must reference an existing page or folder"
+        });
+      }
+      if (childId === pages.rootFolderId) {
+        context.addIssue({
+          code: z6.ZodIssueCode.custom,
+          path: ["folders", folderId, "children", index],
+          message: "Root folder can't be nested"
+        });
+      }
+    }
+  }
+  if (rootFolder !== void 0 && rootFolder.children[0] !== pages.homePageId) {
+    context.addIssue({
+      code: z6.ZodIssueCode.custom,
+      path: ["folders", pages.rootFolderId, "children"],
+      message: "Root folder must start with the home page"
+    });
+  }
+  const childParents = /* @__PURE__ */ new Map();
+  for (const [folderId, folder] of pages.folders) {
+    for (const [index, childId] of folder.children.entries()) {
+      const parentId = childParents.get(childId);
+      if (parentId !== void 0) {
+        context.addIssue({
+          code: z6.ZodIssueCode.custom,
+          path: ["folders", folderId, "children", index],
+          message: `Child is already registered in folder "${parentId}"`
+        });
+        continue;
+      }
+      childParents.set(childId, folderId);
+    }
+  }
+  const hasFolderCycle = (folderId, path = /* @__PURE__ */ new Set()) => {
+    if (path.has(folderId)) {
+      return true;
+    }
+    const folder = pages.folders.get(folderId);
+    if (folder === void 0) {
+      return false;
+    }
+    path.add(folderId);
+    for (const childId of folder.children) {
+      if (pages.folders.has(childId) && hasFolderCycle(childId, path)) {
+        return true;
+      }
+    }
+    path.delete(folderId);
+    return false;
+  };
+  for (const folderId of pages.folders.keys()) {
+    if (hasFolderCycle(folderId)) {
+      context.addIssue({
+        code: z6.ZodIssueCode.custom,
+        path: ["folders", folderId, "children"],
+        message: "Folders can't contain cycles"
+      });
+    }
+  }
+});
+
+// src/schema/props.ts
+import { z as z8 } from "zod";
+
+// src/schema/animation-schema.ts
+import { StyleValue } from "@webstudio-is/css-engine";
+import { z as z7 } from "zod";
+var literalUnion = (arr) => z7.union(
+  arr.map((val) => z7.literal(val))
+);
+var RANGE_UNITS = [
+  "%",
+  "px",
+  "cm",
+  "mm",
+  "q",
+  "in",
+  "pt",
+  "pc",
+  "em",
+  "rem",
+  "ex",
+  "rex",
+  "cap",
+  "rcap",
+  "ch",
+  "rch",
+  "lh",
+  "rlh",
+  "vw",
+  "svw",
+  "lvw",
+  "dvw",
+  "vh",
+  "svh",
+  "lvh",
+  "dvh",
+  "vi",
+  "svi",
+  "lvi",
+  "dvi",
+  "vb",
+  "svb",
+  "lvb",
+  "dvb",
+  "vmin",
+  "svmin",
+  "lvmin",
+  "dvmin",
+  "vmax",
+  "svmax",
+  "lvmax",
+  "dvmax"
+];
+var rangeUnitSchema = literalUnion(RANGE_UNITS);
+var rangeUnitValueSchema = z7.union([
+  z7.object({
+    type: z7.literal("unit"),
+    value: z7.number(),
+    unit: rangeUnitSchema
+  }),
+  z7.object({
+    type: z7.literal("unparsed"),
+    value: z7.string()
+  }),
+  z7.object({
+    type: z7.literal("var"),
+    value: z7.string()
+  })
+]);
+var TIME_UNITS = ["ms", "s"];
+var timeUnitSchema = literalUnion(TIME_UNITS);
+var durationUnitValueSchema = z7.union([
+  z7.object({
+    type: z7.literal("unit"),
+    value: z7.number(),
+    unit: timeUnitSchema
+  }),
+  z7.object({
+    type: z7.literal("var"),
+    value: z7.string()
+  })
+]);
+var iterationsUnitValueSchema = z7.union([z7.number(), z7.literal("infinite")]);
+var insetUnitValueSchema = z7.union([
+  rangeUnitValueSchema,
+  z7.object({
+    type: z7.literal("keyword"),
+    value: z7.literal("auto")
+  })
+]);
+var keyframeStylesSchema = z7.record(StyleValue);
+var animationKeyframeSchema = z7.object({
+  offset: z7.number().optional(),
+  styles: keyframeStylesSchema
+});
+var keyframeEffectOptionsSchema = z7.object({
+  easing: z7.string().optional(),
+  fill: z7.union([
+    z7.literal("none"),
+    z7.literal("forwards"),
+    z7.literal("backwards"),
+    z7.literal("both")
+  ]).optional(),
+  // FillMode
+  duration: durationUnitValueSchema.optional(),
+  delay: durationUnitValueSchema.optional(),
+  iterations: iterationsUnitValueSchema.optional()
+});
+var scrollNamedRangeSchema = z7.union([
+  z7.literal("start"),
+  z7.literal("end")
+]);
+var scrollRangeValueSchema = z7.tuple([
+  scrollNamedRangeSchema,
+  rangeUnitValueSchema
+]);
+var scrollRangeOptionsSchema = z7.object({
+  rangeStart: scrollRangeValueSchema.optional(),
+  rangeEnd: scrollRangeValueSchema.optional()
+});
+var animationAxisSchema = z7.union([
+  z7.literal("block"),
+  z7.literal("inline"),
+  z7.literal("x"),
+  z7.literal("y")
+]);
+var viewNamedRangeSchema = z7.union([
+  z7.literal("contain"),
+  z7.literal("cover"),
+  z7.literal("entry"),
+  z7.literal("exit"),
+  z7.literal("entry-crossing"),
+  z7.literal("exit-crossing")
+]);
+var viewRangeValueSchema = z7.tuple([
+  viewNamedRangeSchema,
+  rangeUnitValueSchema
+]);
+var viewRangeOptionsSchema = z7.object({
+  rangeStart: viewRangeValueSchema.optional(),
+  rangeEnd: viewRangeValueSchema.optional()
+});
+var baseAnimation = z7.object({
+  name: z7.string().optional(),
+  description: z7.string().optional(),
+  enabled: z7.array(z7.tuple([z7.string().describe("breakpointId"), z7.boolean()])).optional(),
+  keyframes: z7.array(animationKeyframeSchema)
+});
+var scrollAnimationSchema = baseAnimation.merge(
+  z7.object({
+    timing: keyframeEffectOptionsSchema.merge(scrollRangeOptionsSchema)
+  })
+);
+var scrollActionSchema = z7.object({
+  type: z7.literal("scroll"),
+  source: z7.union([z7.literal("closest"), z7.literal("nearest"), z7.literal("root")]).optional(),
+  axis: animationAxisSchema.optional(),
+  animations: z7.array(scrollAnimationSchema),
+  isPinned: z7.boolean().optional(),
+  debug: z7.boolean().optional()
+});
+var viewAnimationSchema = baseAnimation.merge(
+  z7.object({
+    timing: keyframeEffectOptionsSchema.merge(viewRangeOptionsSchema)
+  })
+);
+var viewActionSchema = z7.object({
+  type: z7.literal("view"),
+  subject: z7.string().optional(),
+  axis: animationAxisSchema.optional(),
+  animations: z7.array(viewAnimationSchema),
+  insetStart: insetUnitValueSchema.optional(),
+  insetEnd: insetUnitValueSchema.optional(),
+  isPinned: z7.boolean().optional(),
+  debug: z7.boolean().optional()
+});
+var animationActionSchema = z7.discriminatedUnion("type", [
+  scrollActionSchema,
+  viewActionSchema
+]);
+
+// src/schema/props.ts
+var PropId = z8.string();
+var baseProp = {
+  id: PropId,
+  instanceId: z8.string(),
+  name: z8.string(),
+  required: z8.optional(z8.boolean())
+};
+var Prop = z8.union([
+  z8.object({
+    ...baseProp,
+    type: z8.literal("number"),
+    value: z8.number()
+  }),
+  z8.object({
+    ...baseProp,
+    type: z8.literal("string"),
+    value: z8.string()
+  }),
+  z8.object({
+    ...baseProp,
+    type: z8.literal("boolean"),
+    value: z8.boolean()
+  }),
+  z8.object({
+    ...baseProp,
+    type: z8.literal("json"),
+    value: z8.unknown()
+  }),
+  z8.object({
+    ...baseProp,
+    type: z8.literal("asset"),
+    value: z8.string()
+    // asset id
+  }),
+  z8.object({
+    ...baseProp,
+    type: z8.literal("page"),
+    value: z8.union([
+      z8.string(),
+      // page id
+      z8.object({
+        pageId: z8.string(),
+        instanceId: z8.string()
+      })
+    ])
+  }),
+  z8.object({
+    ...baseProp,
+    type: z8.literal("string[]"),
+    value: z8.array(z8.string())
+  }),
+  z8.object({
+    ...baseProp,
+    type: z8.literal("parameter"),
+    // data source id
+    value: z8.string()
+  }),
+  z8.object({
+    ...baseProp,
+    type: z8.literal("resource"),
+    // resource id
+    value: z8.string()
+  }),
+  z8.object({
+    ...baseProp,
+    type: z8.literal("expression"),
+    // expression code
+    value: z8.string()
+  }),
+  z8.object({
+    ...baseProp,
+    type: z8.literal("action"),
+    value: z8.array(
+      z8.object({
+        type: z8.literal("execute"),
+        args: z8.array(z8.string()),
+        code: z8.string()
+      })
+    )
+  }),
+  z8.object({
+    ...baseProp,
+    type: z8.literal("animationAction"),
+    value: animationActionSchema
+  })
+]);
+var Props = z8.map(PropId, Prop);
+
+// src/schema/resources.ts
+import { z as z9 } from "zod";
+var ResourceId = z9.string();
+var Method = z9.union([
+  z9.literal("get"),
+  z9.literal("post"),
+  z9.literal("put"),
+  z9.literal("delete")
+]);
+var Resource = z9.object({
+  id: ResourceId,
+  name: z9.string(),
+  control: z9.optional(z9.union([z9.literal("system"), z9.literal("graphql")])),
+  method: Method,
+  // expression
+  url: z9.string(),
+  searchParams: z9.array(
+    z9.object({
+      name: z9.string(),
+      // expression
+      value: z9.string()
+    })
+  ).optional(),
+  headers: z9.array(
+    z9.object({
+      name: z9.string(),
+      // expression
+      value: z9.string()
+    })
+  ),
+  // expression
+  body: z9.optional(z9.string())
+});
+var ResourceRequest = z9.object({
+  name: z9.string(),
+  method: Method,
+  url: z9.string(),
+  searchParams: z9.array(
+    z9.object({
+      name: z9.string(),
+      // can be string or object which should be serialized
+      value: z9.unknown()
+    })
+  ),
+  headers: z9.array(
+    z9.object({
+      name: z9.string(),
+      // can be string or object which should be serialized
+      value: z9.unknown()
+    })
+  ),
+  body: z9.optional(z9.unknown())
+});
+var Resources = z9.map(ResourceId, Resource);
+
+// src/schema/style-source-selections.ts
+import { z as z10 } from "zod";
+var InstanceId2 = z10.string();
+var StyleSourceId = z10.string();
+var StyleSourceSelection = z10.object({
+  instanceId: InstanceId2,
+  values: z10.array(StyleSourceId)
+});
+var StyleSourceSelections = z10.map(InstanceId2, StyleSourceSelection);
+
+// src/schema/style-sources.ts
+import { z as z11 } from "zod";
+var StyleSourceId2 = z11.string();
+var StyleSourceToken = z11.object({
+  type: z11.literal("token"),
+  id: StyleSourceId2,
+  name: z11.string(),
+  locked: z11.boolean().optional()
+});
+var StyleSourceLocal = z11.object({
+  type: z11.literal("local"),
+  id: StyleSourceId2
+});
+var StyleSource = z11.union([StyleSourceToken, StyleSourceLocal]);
+var StyleSources = z11.map(StyleSourceId2, StyleSource);
+
+// src/schema/styles.ts
+import { z as z12 } from "zod";
+import { StyleValue as StyleValue2 } from "@webstudio-is/css-engine";
+var StyleDeclRaw = z12.object({
+  styleSourceId: z12.string(),
+  breakpointId: z12.string(),
+  state: z12.optional(z12.string()),
+  // @todo can't figure out how to make property to be enum
+  property: z12.string(),
+  value: StyleValue2,
+  listed: z12.boolean().optional().describe("Whether the style is from the Advanced panel")
+});
+var StyleDecl = StyleDeclRaw;
+var getStyleDeclKey = (styleDecl) => {
+  return `${styleDecl.styleSourceId}:${styleDecl.breakpointId}:${styleDecl.property}:${styleDecl.state ?? ""}`;
+};
+var Styles = z12.map(z12.string(), StyleDecl);
+export {
+  Asset,
+  Assets,
+  Breakpoint,
+  Breakpoints,
+  CompilerSettings,
+  DataSource,
+  DataSourceVariableValue,
+  DataSources,
+  Deployment,
+  ExpressionChild,
+  FileAsset,
+  Folder,
+  FolderId,
+  FolderName,
+  FontAsset,
+  HomePagePath,
+  IdChild,
+  ImageAsset,
+  ImageMeta,
+  Instance,
+  InstanceChild,
+  Instances,
+  Page,
+  PageAuth,
+  PageId,
+  PageName,
+  PagePath,
+  PageRedirect,
+  PageTemplate,
+  PageTitle,
+  Pages,
+  ProjectMeta,
+  ProjectNewRedirectPath,
+  Prop,
+  Props,
+  RedirectSourcePath,
+  Resource,
+  ResourceRequest,
+  Resources,
+  StyleDecl,
+  StyleSource,
+  StyleSourceSelection,
+  StyleSourceSelections,
+  StyleSources,
+  Styles,
+  Templates,
+  TextChild,
+  documentTypes,
+  getStyleDeclKey,
+  initialBreakpoints
+};