@webstudio-is/sdk 0.123.0 → 0.125.0

package/lib/index.js

@@ -32,13 +32,26 @@ var Assets = z.map(AssetId, Asset);
 // src/schema/pages.ts
 import { z as z2 } from "zod";
 var MIN_TITLE_LENGTH = 2;
+var PageId = z2.string();
+var FolderId = z2.string();
+var FolderName = z2.string().refine((value) => value.trim() !== "", "Can't be empty");
+var FolderSlug = z2.string().refine((slug) => slug !== "", "Can't be empty").refine((slug) => slug.includes("/") === false, "Can't contain a /").refine(
+  (path) => /^[-a-z0-9]*$/.test(path),
+  "Only a-z, 0-9 and - are allowed"
+);
+var Folder = z2.object({
+  id: FolderId,
+  name: FolderName,
+  slug: z2.string(),
+  children: z2.array(z2.union([FolderId, PageId]))
+});
 var PageName = z2.string().refine((value) => value.trim() !== "", "Can't be empty");
 var PageTitle = z2.string().refine(
   (val) => val.length >= MIN_TITLE_LENGTH,
   `Minimum ${MIN_TITLE_LENGTH} characters required`
 );
 var commonPageFields = {
-  id: z2.string(),
+  id: PageId,
   name: PageName,
   title: PageTitle,
   meta: z2.object({
@@ -62,8 +75,8 @@ var HomePage = z2.object({
   path: HomePagePath
 });
 var PagePath = z2.string().refine((path) => path !== "", "Can't be empty").refine((path) => path !== "/", "Can't be just a /").refine((path) => path === "" || path.startsWith("/"), "Must start with 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"
+  (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,
@@ -78,37 +91,48 @@ var Page = z2.object({
   ...commonPageFields,
   path: PagePath
 });
-var SiteMeta = z2.object({
+var ProjectMeta = z2.object({
+  // All fields are optional to ensure consistency and allow for the addition of new fields without requiring migration
   siteName: z2.string().optional(),
   faviconAssetId: z2.string().optional(),
   code: z2.string().optional()
 });
+var ProjectSettings = z2.object({
+  // All fields are optional to ensure consistency and allow for the addition of new fields without requiring migration
+  atomicStyles: z2.boolean().optional()
+});
 var Pages = z2.object({
-  meta: SiteMeta.optional(),
+  meta: ProjectMeta.optional(),
+  settings: ProjectSettings.optional(),
   homePage: HomePage,
   pages: z2.array(Page).refine(
     (array) => new Set(array.map((page) => page.path)).size === array.length,
     "All paths must be unique"
-  )
+  ),
+  folders: z2.array(Folder).refine((folders) => folders.length > 0, "Folders can't be empty")
 });
 
 // src/schema/instances.ts
 import { z as z3 } from "zod";
-var Text = z3.object({
+var TextChild = z3.object({
   type: z3.literal("text"),
   value: z3.string()
 });
 var InstanceId = z3.string();
-var Id = z3.object({
+var IdChild = z3.object({
   type: z3.literal("id"),
   value: InstanceId
 });
+var ExpressionChild = z3.object({
+  type: z3.literal("expression"),
+  value: z3.string()
+});
 var Instance = z3.object({
   type: z3.literal("instance"),
   id: InstanceId,
   component: z3.string(),
   label: z3.string().optional(),
-  children: z3.array(z3.union([Id, Text]))
+  children: z3.array(z3.union([IdChild, TextChild, ExpressionChild]))
 });
 var Instances = z3.map(InstanceId, Instance);
 
@@ -151,97 +175,130 @@ var DataSource = z4.union([
     id: DataSourceId,
     scopeInstanceId: z4.optional(z4.string()),
     name: z4.string()
+  }),
+  z4.object({
+    type: z4.literal("resource"),
+    id: DataSourceId,
+    scopeInstanceId: z4.optional(z4.string()),
+    name: z4.string(),
+    resourceId: z4.string()
   })
 ]);
 var DataSources = z4.map(DataSourceId, DataSource);
 
-// src/schema/props.ts
+// src/schema/resources.ts
 import { z as z5 } from "zod";
-var PropId = z5.string();
+var ResourceId = z5.string();
+var Method = z5.union([
+  z5.literal("get"),
+  z5.literal("post"),
+  z5.literal("put"),
+  z5.literal("delete")
+]);
+var Header = z5.object({
+  name: z5.string(),
+  // expression
+  value: z5.string()
+});
+var Resource = z5.object({
+  id: ResourceId,
+  name: z5.string(),
+  method: Method,
+  // expression
+  url: z5.string(),
+  headers: z5.array(Header),
+  // expression
+  body: z5.optional(z5.string())
+});
+var Resources = z5.map(ResourceId, Resource);
+
+// src/schema/props.ts
+import { z as z6 } from "zod";
+var PropId = z6.string();
 var baseProp = {
   id: PropId,
-  instanceId: z5.string(),
-  name: z5.string(),
-  required: z5.optional(z5.boolean())
+  instanceId: z6.string(),
+  name: z6.string(),
+  required: z6.optional(z6.boolean())
 };
-var Prop = z5.union([
-  z5.object({
+var Prop = z6.union([
+  z6.object({
     ...baseProp,
-    type: z5.literal("number"),
-    value: z5.number()
+    type: z6.literal("number"),
+    value: z6.number()
   }),
-  z5.object({
+  z6.object({
     ...baseProp,
-    type: z5.literal("string"),
-    value: z5.string()
+    type: z6.literal("string"),
+    value: z6.string()
   }),
-  z5.object({
+  z6.object({
     ...baseProp,
-    type: z5.literal("boolean"),
-    value: z5.boolean()
+    type: z6.literal("boolean"),
+    value: z6.boolean()
   }),
-  z5.object({
+  z6.object({
     ...baseProp,
-    type: z5.literal("json"),
-    value: z5.unknown()
+    type: z6.literal("json"),
+    value: z6.unknown()
   }),
-  z5.object({
+  z6.object({
     ...baseProp,
-    type: z5.literal("asset"),
-    value: z5.string()
+    type: z6.literal("asset"),
+    value: z6.string()
     // asset id
   }),
-  z5.object({
+  z6.object({
     ...baseProp,
-    type: z5.literal("page"),
-    value: z5.union([
-      z5.string(),
+    type: z6.literal("page"),
+    value: z6.union([
+      z6.string(),
       // page id
-      z5.object({
-        pageId: z5.string(),
-        instanceId: z5.string()
+      z6.object({
+        pageId: z6.string(),
+        instanceId: z6.string()
       })
     ])
   }),
-  z5.object({
+  z6.object({
     ...baseProp,
-    type: z5.literal("string[]"),
-    value: z5.array(z5.string())
+    type: z6.literal("string[]"),
+    value: z6.array(z6.string())
   }),
-  z5.object({
+  z6.object({
     ...baseProp,
-    type: z5.literal("parameter"),
+    type: z6.literal("parameter"),
     // data source id
-    value: z5.string()
+    value: z6.string()
   }),
-  z5.object({
+  z6.object({
     ...baseProp,
-    type: z5.literal("expression"),
+    type: z6.literal("expression"),
     // expression code
-    value: z5.string()
+    value: z6.string()
   }),
-  z5.object({
+  z6.object({
     ...baseProp,
-    type: z5.literal("action"),
-    value: z5.array(
-      z5.object({
-        type: z5.literal("execute"),
-        args: z5.array(z5.string()),
-        code: z5.string()
+    type: z6.literal("action"),
+    value: z6.array(
+      z6.object({
+        type: z6.literal("execute"),
+        args: z6.array(z6.string()),
+        code: z6.string()
       })
     )
   })
 ]);
-var Props = z5.map(PropId, Prop);
+var Props = z6.map(PropId, Prop);
 
 // src/schema/breakpoints.ts
-import { z as z6 } from "zod";
-var BreakpointId = z6.string();
-var Breakpoint = z6.object({
+import { z as z7 } from "zod";
+var BreakpointId = z7.string();
+var Breakpoint = z7.object({
   id: BreakpointId,
-  label: z6.string(),
-  minWidth: z6.number().optional(),
-  maxWidth: z6.number().optional()
+  label: z7.string(),
+  minWidth: z7.number().optional(),
+  maxWidth: z7.number().optional()
 }).refine(({ minWidth, maxWidth }) => {
   return (
     // Either min or max width have to be defined
@@ -249,7 +306,7 @@ var Breakpoint = z6.object({
     minWidth === void 0 && maxWidth === void 0
   );
 }, "Either minWidth or maxWidth should be defined");
-var Breakpoints = z6.map(BreakpointId, Breakpoint);
+var Breakpoints = z7.map(BreakpointId, Breakpoint);
 var initialBreakpoints = [
   { id: "placeholder", label: "Base" },
   { id: "placeholder", label: "Tablet", maxWidth: 991 },
@@ -258,52 +315,52 @@ var initialBreakpoints = [
 ];
 
 // src/schema/style-sources.ts
-import { z as z7 } from "zod";
-var StyleSourceId = z7.string();
-var StyleSourceToken = z7.object({
-  type: z7.literal("token"),
+import { z as z8 } from "zod";
+var StyleSourceId = z8.string();
+var StyleSourceToken = z8.object({
+  type: z8.literal("token"),
   id: StyleSourceId,
-  name: z7.string()
+  name: z8.string()
 });
-var StyleSourceLocal = z7.object({
-  type: z7.literal("local"),
+var StyleSourceLocal = z8.object({
+  type: z8.literal("local"),
   id: StyleSourceId
 });
-var StyleSource = z7.union([StyleSourceToken, StyleSourceLocal]);
-var StyleSources = z7.map(StyleSourceId, StyleSource);
+var StyleSource = z8.union([StyleSourceToken, StyleSourceLocal]);
+var StyleSources = z8.map(StyleSourceId, StyleSource);
 
 // src/schema/style-source-selections.ts
-import { z as z8 } from "zod";
-var InstanceId2 = z8.string();
-var StyleSourceId2 = z8.string();
-var StyleSourceSelection = z8.object({
+import { z as z9 } from "zod";
+var InstanceId2 = z9.string();
+var StyleSourceId2 = z9.string();
+var StyleSourceSelection = z9.object({
   instanceId: InstanceId2,
-  values: z8.array(StyleSourceId2)
+  values: z9.array(StyleSourceId2)
 });
-var StyleSourceSelections = z8.map(InstanceId2, StyleSourceSelection);
+var StyleSourceSelections = z9.map(InstanceId2, StyleSourceSelection);
 
 // src/schema/styles.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 import { StyleValue } from "@webstudio-is/css-engine";
-var StyleDeclRaw = z9.object({
-  styleSourceId: z9.string(),
-  breakpointId: z9.string(),
-  state: z9.optional(z9.string()),
+var StyleDeclRaw = z10.object({
+  styleSourceId: z10.string(),
+  breakpointId: z10.string(),
+  state: z10.optional(z10.string()),
   // @todo can't figure out how to make property to be enum
-  property: z9.string(),
+  property: z10.string(),
   value: StyleValue
 });
 var StyleDecl = StyleDeclRaw;
 var getStyleDeclKey = (styleDecl) => {
   return `${styleDecl.styleSourceId}:${styleDecl.breakpointId}:${styleDecl.property}:${styleDecl.state ?? ""}`;
 };
-var Styles = z9.map(z9.string(), StyleDecl);
+var Styles = z10.map(z10.string(), StyleDecl);
 
 // src/schema/deployment.ts
-import { z as z10 } from "zod";
-var Deployment = z10.object({
-  domains: z10.array(z10.string()),
-  projectDomain: z10.string()
+import { z as z11 } from "zod";
+var Deployment = z11.object({
+  domains: z11.array(z11.string()),
+  projectDomain: z11.string()
 });
 
 // src/instances-utils.ts
@@ -387,6 +444,34 @@ var createScope = (occupiedIdentifiers = []) => {
     getName
   };
 };
+
+// src/resource-loader.ts
+var loadResource = async (resourceData) => {
+  const { url, method, headers, body } = resourceData;
+  const requestHeaders = new Headers(
+    headers.map(({ name, value }) => [name, value])
+  );
+  const requestInit = {
+    method,
+    headers: requestHeaders
+  };
+  if (method !== "get" && body !== void 0) {
+    requestInit.body = body;
+  }
+  const response = await fetch(url, requestInit);
+  let data;
+  if (response.ok && // accept json by default and when specified explicitly
+  (requestHeaders.has("accept") === false || requestHeaders.get("accept") === "application/json")) {
+    data = await response.json();
+  } else {
+    data = await response.text();
+  }
+  return {
+    data,
+    status: response.status,
+    statusText: response.statusText
+  };
+};
 export {
   Asset,
   Assets,
@@ -396,9 +481,13 @@ export {
   DataSourceVariableValue,
   DataSources,
   Deployment,
+  ExpressionChild,
+  Folder,
+  FolderName,
+  FolderSlug,
   FontAsset,
   HomePagePath,
-  Id,
+  IdChild,
   ImageAsset,
   ImageMeta,
   Instance,
@@ -409,17 +498,20 @@ export {
   Pages,
   Prop,
   Props,
+  Resource,
+  Resources,
   StyleDecl,
   StyleSource,
   StyleSourceSelection,
   StyleSourceSelections,
   StyleSources,
   Styles,
-  Text,
+  TextChild,
   createScope,
   findTreeInstanceIds,
   findTreeInstanceIdsExcludingSlotDescendants,
   getStyleDeclKey,
   initialBreakpoints,
+  loadResource,
   parseComponentName
 };

package/lib/types/index.d.ts

@@ -2,6 +2,7 @@ export * from "./schema/assets";
 export * from "./schema/pages";
 export * from "./schema/instances";
 export * from "./schema/data-sources";
+export * from "./schema/resources";
 export * from "./schema/props";
 export * from "./schema/breakpoints";
 export * from "./schema/style-sources";
@@ -10,3 +11,4 @@ export * from "./schema/styles";
 export * from "./schema/deployment";
 export * from "./instances-utils";
 export * from "./scope";
+export * from "./resource-loader";

package/lib/types/instances-utils.d.ts

@@ -2,27 +2,33 @@ import type { Instance } from "./schema/instances";
 export declare const findTreeInstanceIds: (instances: Map<string, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }>, rootInstanceId: Instance["id"]) => Set<string>;
 export declare const findTreeInstanceIdsExcludingSlotDescendants: (instances: Map<string, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }>, rootInstanceId: Instance["id"]) => Set<string>;
 export declare const parseComponentName: (componentName: string) => readonly [string | undefined, string];

package/lib/types/resource-loader.d.ts

@@ -0,0 +1,6 @@
+import type { Resource } from "./schema/resources";
+export declare const loadResource: (resourceData: Resource) => Promise<{
+    data: any;
+    status: number;
+    statusText: string;
+}>;

package/lib/types/schema/data-sources.d.ts

@@ -153,6 +153,24 @@ export declare const DataSource: z.ZodUnion<[z.ZodObject<{
     name: string;
     id: string;
     scopeInstanceId?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"resource">;
+    id: z.ZodString;
+    scopeInstanceId: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    resourceId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "resource";
+    name: string;
+    id: string;
+    resourceId: string;
+    scopeInstanceId?: string | undefined;
+}, {
+    type: "resource";
+    name: string;
+    id: string;
+    resourceId: string;
+    scopeInstanceId?: string | undefined;
 }>]>;
 export type DataSource = z.infer<typeof DataSource>;
 export declare const DataSources: z.ZodMap<z.ZodString, z.ZodUnion<[z.ZodObject<{
@@ -263,5 +281,23 @@ export declare const DataSources: z.ZodMap<z.ZodString, z.ZodUnion<[z.ZodObject<
     name: string;
     id: string;
     scopeInstanceId?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"resource">;
+    id: z.ZodString;
+    scopeInstanceId: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    resourceId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "resource";
+    name: string;
+    id: string;
+    resourceId: string;
+    scopeInstanceId?: string | undefined;
+}, {
+    type: "resource";
+    name: string;
+    id: string;
+    resourceId: string;
+    scopeInstanceId?: string | undefined;
 }>]>>;
 export type DataSources = z.infer<typeof DataSources>;

package/lib/types/schema/instances.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export declare const Text: z.ZodObject<{
+export declare const TextChild: z.ZodObject<{
     type: z.ZodLiteral<"text">;
     value: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -9,8 +9,8 @@ export declare const Text: z.ZodObject<{
     value: string;
     type: "text";
 }>;
-export type Text = z.infer<typeof Text>;
-export declare const Id: z.ZodObject<{
+export type TextChild = z.infer<typeof TextChild>;
+export declare const IdChild: z.ZodObject<{
     type: z.ZodLiteral<"id">;
     value: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -20,7 +20,18 @@ export declare const Id: z.ZodObject<{
     value: string;
     type: "id";
 }>;
-export type Id = z.infer<typeof Id>;
+export type IdChild = z.infer<typeof IdChild>;
+export declare const ExpressionChild: z.ZodObject<{
+    type: z.ZodLiteral<"expression">;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "expression";
+}, {
+    value: string;
+    type: "expression";
+}>;
+export type ExpressionChild = z.infer<typeof ExpressionChild>;
 export declare const Instance: z.ZodObject<{
     type: z.ZodLiteral<"instance">;
     id: z.ZodString;
@@ -44,30 +55,45 @@ export declare const Instance: z.ZodObject<{
     }, {
         value: string;
         type: "text";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"expression">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        type: "expression";
+    }, {
+        value: string;
+        type: "expression";
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }>;
 export type Instance = z.infer<typeof Instance>;
@@ -94,30 +120,45 @@ export declare const Instances: z.ZodMap<z.ZodString, z.ZodObject<{
     }, {
         value: string;
         type: "text";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"expression">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        type: "expression";
+    }, {
+        value: string;
+        type: "expression";
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }>>;
 export type Instances = z.infer<typeof Instances>;

package/lib/types/schema/pages.d.ts

@@ -1,4 +1,23 @@
 import { z } from "zod";
+export declare const FolderName: z.ZodEffects<z.ZodString, string, string>;
+export declare const FolderSlug: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
+export declare const Folder: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodEffects<z.ZodString, string, string>;
+    slug: z.ZodString;
+    children: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodString]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    slug: string;
+    children: string[];
+}, {
+    name: string;
+    id: string;
+    slug: string;
+    children: string[];
+}>;
+export type Folder = z.infer<typeof Folder>;
 export declare const PageName: z.ZodEffects<z.ZodString, string, string>;
 export declare const PageTitle: z.ZodEffects<z.ZodString, string, string>;
 export declare const HomePagePath: z.ZodEffects<z.ZodString, string, string>;
@@ -79,7 +98,7 @@ declare const Page: z.ZodObject<{
     rootInstanceId: string;
     pathVariableId?: string | undefined;
 }>;
-declare const SiteMeta: z.ZodObject<{
+declare const ProjectMeta: z.ZodObject<{
     siteName: z.ZodOptional<z.ZodString>;
     faviconAssetId: z.ZodOptional<z.ZodString>;
     code: z.ZodOptional<z.ZodString>;
@@ -92,7 +111,7 @@ declare const SiteMeta: z.ZodObject<{
     faviconAssetId?: string | undefined;
     code?: string | undefined;
 }>;
-export type SiteMeta = z.infer<typeof SiteMeta>;
+export type ProjectMeta = z.infer<typeof ProjectMeta>;
 export type Page = z.infer<typeof Page>;
 export declare const Pages: z.ZodObject<{
     meta: z.ZodOptional<z.ZodObject<{
@@ -108,6 +127,13 @@ export declare const Pages: z.ZodObject<{
         faviconAssetId?: string | undefined;
         code?: string | undefined;
     }>>;
+    settings: z.ZodOptional<z.ZodObject<{
+        atomicStyles: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        atomicStyles?: boolean | undefined;
+    }, {
+        atomicStyles?: boolean | undefined;
+    }>>;
     homePage: z.ZodObject<{
         path: z.ZodEffects<z.ZodString, string, string>;
         id: z.ZodString;
@@ -294,6 +320,32 @@ export declare const Pages: z.ZodObject<{
         rootInstanceId: string;
         pathVariableId?: string | undefined;
     }[]>;
+    folders: z.ZodEffects<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodEffects<z.ZodString, string, string>;
+        slug: z.ZodString;
+        children: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodString]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }, {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }>, "many">, {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }[], {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }[]>;
 }, "strip", z.ZodTypeAny, {
     homePage: {
         path: string;
@@ -331,11 +383,20 @@ export declare const Pages: z.ZodObject<{
         rootInstanceId: string;
         pathVariableId?: string | undefined;
     }[];
+    folders: {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }[];
     meta?: {
         siteName?: string | undefined;
         faviconAssetId?: string | undefined;
         code?: string | undefined;
     } | undefined;
+    settings?: {
+        atomicStyles?: boolean | undefined;
+    } | undefined;
 }, {
     homePage: {
         path: string;
@@ -373,11 +434,20 @@ export declare const Pages: z.ZodObject<{
         rootInstanceId: string;
         pathVariableId?: string | undefined;
     }[];
+    folders: {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }[];
     meta?: {
         siteName?: string | undefined;
         faviconAssetId?: string | undefined;
         code?: string | undefined;
     } | undefined;
+    settings?: {
+        atomicStyles?: boolean | undefined;
+    } | undefined;
 }>;
 export type Pages = z.infer<typeof Pages>;
 export {};

package/lib/types/schema/resources.d.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+export declare const Resource: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    method: z.ZodUnion<[z.ZodLiteral<"get">, z.ZodLiteral<"post">, z.ZodLiteral<"put">, z.ZodLiteral<"delete">]>;
+    url: z.ZodString;
+    headers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        name: string;
+    }, {
+        value: string;
+        name: string;
+    }>, "many">;
+    body: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    method: "get" | "post" | "put" | "delete";
+    url: string;
+    headers: {
+        value: string;
+        name: string;
+    }[];
+    body?: string | undefined;
+}, {
+    name: string;
+    id: string;
+    method: "get" | "post" | "put" | "delete";
+    url: string;
+    headers: {
+        value: string;
+        name: string;
+    }[];
+    body?: string | undefined;
+}>;
+export type Resource = z.infer<typeof Resource>;
+export declare const Resources: z.ZodMap<z.ZodString, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    method: z.ZodUnion<[z.ZodLiteral<"get">, z.ZodLiteral<"post">, z.ZodLiteral<"put">, z.ZodLiteral<"delete">]>;
+    url: z.ZodString;
+    headers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        name: string;
+    }, {
+        value: string;
+        name: string;
+    }>, "many">;
+    body: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    method: "get" | "post" | "put" | "delete";
+    url: string;
+    headers: {
+        value: string;
+        name: string;
+    }[];
+    body?: string | undefined;
+}, {
+    name: string;
+    id: string;
+    method: "get" | "post" | "put" | "delete";
+    url: string;
+    headers: {
+        value: string;
+        name: string;
+    }[];
+    body?: string | undefined;
+}>>;
+export type Resources = z.infer<typeof Resources>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@webstudio-is/sdk",
-  "version": "0.123.0",
-  "description": "Webstudio site data schema",
+  "version": "0.125.0",
+  "description": "Webstudio project data schema",
   "author": "Webstudio <github@webstudio.is>",
   "homepage": "https://webstudio.is",
   "license": "AGPL-3.0-or-later",
@@ -19,8 +19,8 @@
   "sideEffects": false,
   "dependencies": {
     "zod": "^3.21.4",
-    "@webstudio-is/css-engine": "0.123.0",
-    "@webstudio-is/fonts": "0.123.0"
+    "@webstudio-is/css-engine": "0.125.0",
+    "@webstudio-is/fonts": "0.125.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",