@magiclabs.ai/magicbook-client 0.7.5-canary.1 → 0.7.6-canary

package/index.js

@@ -205,7 +205,9 @@ var styles = {
   6096: { slug: "simply-scrapbook-sfly" },
   6097: { slug: "boho-wedding-sfly" },
   6098: { slug: "black-and-white-rustic-sfly" },
-  6099: { slug: "bright-color-pop-sfly" }
+  6099: { slug: "bright-color-pop-sfly" },
+  6159: { slug: "grateful-for-you-sfly" },
+  6156: { slug: "europe-mementos-sfly" }
 };
 var bookSizes = ["8x8", "10x10", "12x12", "8x11", "11x8", "11x14"];
 var coverTypes = ["sc", "hc", "pl"];
@@ -265,11 +267,7 @@ function snakeCaseObjectKeysToCamelCase(snakeCaseObject) {
       delete snakeCaseObject[key];
     }
     if (typeof snakeCaseObject[camelCaseKey] === "object") {
-      if (snakeCaseObject[camelCaseKey] === null) {
-        snakeCaseObject[camelCaseKey] = null;
-      } else {
-        snakeCaseObject[camelCaseKey] = snakeCaseObjectKeysToCamelCase(snakeCaseObject[camelCaseKey]);
-      }
+      snakeCaseObject[camelCaseKey] = snakeCaseObjectKeysToCamelCase(snakeCaseObject[camelCaseKey]);
     }
   });
   return snakeCaseObject;
@@ -281,6 +279,15 @@ async function handleAsyncFunction(fn) {
     return Promise.reject(error);
   }
 }
+function bindThisToFunctions(instance) {
+  for (const name of Object.getOwnPropertyNames(
+    Object.getPrototypeOf(instance)
+  )) {
+    if (typeof instance[name] === "function" && name !== "constructor") {
+      instance[name] = instance[name].bind(instance);
+    }
+  }
+}
 function cleanJSON(obj) {
   return JSON.parse(JSON.stringify(obj));
 }
@@ -4027,7 +4034,7 @@ var z = /* @__PURE__ */ Object.freeze({
   ZodError
 });
 
-// ../../core/types/book.ts
+// ../../core/models/book.ts
 var BookDesignRequest = class {
   occasion;
   style;
@@ -4069,7 +4076,7 @@ var bookPropsSchema = z.object({
   state: z.enum(states).optional(),
   guid: z.string().optional(),
   cancelled_at: z.string().optional(),
-  mb_client_timeout: z.string().optional(),
+  mb_client_timeout: z.number().optional(),
   user_id: z.string().optional(),
   revision: z.number().optional()
 });
@@ -4092,7 +4099,7 @@ var Book = class {
     this.state = props.state;
     this.guid = props.guid;
     this.cancelled_at = props.cancelled_at;
-    this.timeout = props.mb_client_timeout ? parseInt(props.mb_client_timeout) * 1e3 : void 0;
+    this.timeout = props.mb_client_timeout ? props.mb_client_timeout * 1e3 : void 0;
     this.user_id = props.user_id;
     this.revision = props.revision;
   }
@@ -4106,12 +4113,12 @@ var Book = class {
   toBookProps() {
     return {
       ...this,
-      mb_client_timeout: this.timeout ? (this.timeout / 1e3).toString() : void 0
+      mb_client_timeout: this.timeout ? this.timeout / 1e3 : void 0
     };
   }
 };
 
-// ../../core/types/design-request/image.ts
+// ../../core/models/design-request/image.ts
 var Images = class {
   // eslint-disable-next-line no-unused-vars
   constructor(client, parentId, designRequestState) {
@@ -4131,10 +4138,7 @@ var Images = class {
     } else {
       this.images.push(image);
       this.length = this.images.length;
-      await this.client.engineAPI.images.addToBook({
-        bookId: this.parentId,
-        image: new ImageServer(image)
-      });
+      await this.client.engineAPI.images.addToBook(this.parentId, new ImageServer(image));
       return new Promise((resolve) => {
         resolve(this.length);
       });
@@ -4189,7 +4193,7 @@ function imageServerToImage(imageServer) {
   };
 }
 
-// ../../core/types/design-request/design-options.ts
+// ../../core/models/design-request/design-options.ts
 var imageDensityOptionSchema = z.object({
   maxPageCount: z.number(),
   minPageCount: z.number(),
@@ -4205,8 +4209,23 @@ var imageDensityOptionsSchema = z.object({
 var designOptionsSchema = z.object({
   densities: imageDensityOptionsSchema
 });
+var imageDensityOptionServerSchema = z.object({
+  max_page_count: z.number(),
+  min_page_count: z.number(),
+  max_image_count: z.number(),
+  avg_image_count: z.number(),
+  min_image_count: z.number()
+});
+var imageDensityOptionsServerSchema = z.object({
+  high: imageDensityOptionServerSchema,
+  medium: imageDensityOptionServerSchema,
+  low: imageDensityOptionServerSchema
+});
+var designOptionsServerSchema = z.object({
+  densities: imageDensityOptionsServerSchema
+});
 
-// ../../core/types/design-request/index.ts
+// ../../core/models/design-request/index.ts
 var DesignRequestOptions = {
   occasion: occasions,
   style: Object.keys(styles).map((key) => parseInt(key)),
@@ -4262,27 +4281,31 @@ var DesignRequest = class {
   }
   async getOptions(imageCount) {
     const options = designOptionsSchema.parse(
-      await this.client.engineAPI.designOptions.retrieve({
-        bookSize: this.bookSize,
-        imageCount: imageCount || this.images.length,
-        imageFilteringLevel: this.imageFilteringLevel
-      })
+      snakeCaseObjectKeysToCamelCase(
+        await this.client.engineAPI.designOptions.retrieve(
+          this.bookSize,
+          imageCount || this.images.length,
+          this.imageFilteringLevel
+        )
+      )
     );
     return options;
   }
+  async getAlternateLayouts(pageNumber) {
+    if (this.state === "ready") {
+      return await this.client.engineAPI.spreads.layouts(this.parentId, pageNumber);
+    } else {
+      throw new Error("Design request not ready");
+    }
+  }
   async submit(submitDesignRequestProps) {
     if (!canSubmitDesignRequest(this.state)) {
       throw new Error("You need to wait for the current design request to be ready before submitting a new one");
     } else {
       submitDesignRequestProps && this.updateDesignRequest(submitDesignRequestProps);
       this.webSocket = new WebSocket(`${this.client.webSocketHost}/?book_id=${this.parentId}`);
-      await this.client.engineAPI.books.update({
-        bookId: this.parentId,
-        payload: this.toBook()
-      });
-      this.updateDesignRequest(
-        (await this.client.engineAPI.books.design({ bookId: this.parentId })).toDesignRequestProps()
-      );
+      await this.client.engineAPI.books.update(this.parentId, this.toBook());
+      this.updateDesignRequest((await this.client.engineAPI.books.design(this.parentId)).toDesignRequestProps());
       this.getProgress();
       return this;
     }
@@ -4293,10 +4316,7 @@ var DesignRequest = class {
     } else {
       this.guid = guid;
       this.updateDesignRequest(
-        (await this.client.engineAPI.books.update({
-          bookId: this.parentId,
-          payload: this.toBook()
-        })).toDesignRequestProps()
+        (await this.client.engineAPI.books.update(this.parentId, this.toBook())).toDesignRequestProps()
       );
       return this.guid;
     }
@@ -4310,9 +4330,7 @@ var DesignRequest = class {
       throw new Error("Design request not submitted");
     } else {
       this.updateDesignRequest({
-        ...(await this.client.engineAPI.books.cancel({
-          bookId: this.parentId
-        })).toDesignRequestProps(),
+        ...(await this.client.engineAPI.books.cancel(this.parentId)).toDesignRequestProps(),
         state: "cancelled"
       });
       await this.eventHandler(cancelledEventDetail);
@@ -4321,31 +4339,22 @@ var DesignRequest = class {
   }
   async getJSON() {
     if (this.state === "ready") {
-      return await this.client.engineAPI.books.retrieveGalleon({
-        bookId: this.parentId
-      });
+      return await this.client.engineAPI.books.retrieveGalleon(this.parentId);
     } else {
       throw new Error("Design request not ready");
     }
   }
   async logEvent(name, data) {
-    return await this.client.engineAPI.events.createBookEvent({
-      bookId: this.parentId,
-      name,
-      data
-    });
+    return await this.client.engineAPI.events.createBookEvent(this.parentId, name, data);
   }
   async eventHandler(detail, type = "MagicBook.designRequestUpdated") {
     const customEvent = new CustomEvent(type, { detail });
     if (statesToCloseWS.includes(detail.slug)) {
       this.webSocket?.close();
       if (statesToReport.includes(detail.slug)) {
-        await this.client.engineAPI.books.report({
-          bookId: this.parentId,
-          report: {
-            error: detail.slug === "error" ? "design" : "timeout",
-            step: this.state
-          }
+        await this.client.engineAPI.books.report(this.parentId, {
+          error: detail.slug === "error" ? "design" : "timeout",
+          step: this.state
         });
       }
     }
@@ -4398,7 +4407,7 @@ var DesignRequest = class {
   }
 };
 
-// ../../core/types/galleon.ts
+// ../../core/models/galleon.ts
 var imageAssignmentSchema = z.object({
   photoRefId: z.string(),
   finalCrop: z.array(z.number())
@@ -4477,357 +4486,128 @@ var bookCreationRequestSchema = z.object({
   reportingData: reportingDataSchema
 });
 
-// ../../core/types/engine-api/endpoints/books.ts
+// ../../core/models/engine-api/endpoints/books.ts
 var BooksEndpoints = class {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
+    bindThisToFunctions(this);
   }
-  create({ book, qs }) {
+  create(book) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: "/v1/books",
         options: {
           method: "POST",
           body: cleanJSON(book)
-        },
-        qs
+        }
       });
+      bookPropsSchema.safeParse(res);
       return new Book(res);
     });
   }
-  retrieve({ bookId, qs }) {
+  retrieve(bookId) {
     return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({
-        path: `/v1/books/${bookId}`,
-        qs
-      });
-      const bookProps = bookPropsSchema.parse(res);
-      return new Book(bookProps);
+      const res = await this.engineAPI.fetcher.call({ path: `/v1/books/${bookId}` });
+      bookPropsSchema.safeParse(res);
+      return new Book(res);
     });
   }
-  update({ bookId, payload, qs }) {
+  update(bookId, book) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/books/${bookId}`,
         options: {
           method: "PUT",
-          body: cleanJSON(payload)
-        },
-        qs
-      });
-      const bookProps = bookPropsSchema.parse(res);
-      return new Book(bookProps);
-    });
-  }
-  delete({ bookId, qs }) {
-    return handleAsyncFunction(async () => {
-      await this.engineAPI.fetcher.call({
-        path: `/v1/books/${bookId}`,
-        options: { method: "DELETE" },
-        qs
+          body: cleanJSON(book)
+        }
       });
+      bookPropsSchema.safeParse(res);
+      return new Book(res);
     });
   }
-  design({ bookId, qs }) {
+  design(bookId) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/books/${bookId}/design`,
-        options: { method: "POST" },
-        qs
+        options: { method: "POST" }
       });
-      const bookProps = bookPropsSchema.parse(res);
-      return new Book(bookProps);
+      bookPropsSchema.safeParse(res);
+      return new Book(res);
     });
   }
-  cancel({ bookId, qs }) {
+  cancel(bookId) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/books/${bookId}/cancel`,
-        options: { method: "POST" },
-        qs
+        options: { method: "POST" }
       });
-      const bookProps = bookPropsSchema.parse(res);
-      return new Book(bookProps);
-    });
-  }
-  retrieveGalleon({ bookId, qs }) {
-    return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({
-        path: `/v1/books/${bookId}/format/galleon`,
-        qs
-      });
-      return bookCreationRequestSchema.parse(res);
+      bookPropsSchema.safeParse(res);
+      return new Book(res);
     });
   }
-  report({ bookId, report, qs }) {
+  report(bookId, report) {
     return handleAsyncFunction(async () => {
       await this.engineAPI.fetcher.call({
         path: `/v1/books/${bookId}/report`,
         options: {
           method: "POST",
           body: cleanJSON(report)
-        },
-        qs
+        }
       });
     });
   }
-};
-
-// ../../core/types/engine-api/endpoints/design-options.ts
-var DesignOptionsEndpoints = class {
-  // eslint-disable-next-line no-unused-vars
-  constructor(engineAPI) {
-    this.engineAPI = engineAPI;
+  delete(bookId) {
+    return handleAsyncFunction(async () => {
+      await this.engineAPI.fetcher.call({
+        path: `/v1/books/${bookId}`,
+        options: { method: "DELETE" }
+      });
+    });
   }
-  retrieve(props) {
+  retrieveGalleon(bookId) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        // eslint-disable-next-line max-len
-        path: `/v1/designoptions/booksize/${props.bookSize}/imagecount/${props.imageCount}/imagefilteringlevel/${props.imageFilteringLevel}`,
-        qs: props.qs
+        path: `/v1/books/${bookId}/format/galleon`
       });
-      return designOptionsSchema.parse(snakeCaseObjectKeysToCamelCase(res));
+      return bookCreationRequestSchema.parse(res);
     });
   }
 };
 
-// ../../core/types/embellishment.ts
-var embellishmentTypes = [
-  "background",
-  "band",
-  "strip",
-  "page-corner",
-  "photo-corner",
-  "frame",
-  "t-point",
-  "luggage-tag",
-  "stamp",
-  "tape",
-  "postcard",
-  "top-sticker",
-  "bottom-sticker",
-  "graphic-sticker",
-  "text-sticker"
-];
-var embellishmentOrientations = [
-  "top",
-  "bottom",
-  "left",
-  "right",
-  "top-left",
-  "top-right",
-  "bottom-right",
-  "bottom-left"
-];
-var embellishmentThicknesses = ["thin", "thick", "normal"];
-var embellishmentStackings = ["front", "back"];
-var embellishmentAnchorsSchema = z.object({
-  x0: z.number(),
-  x1: z.number(),
-  y0: z.number(),
-  y1: z.number()
-});
-var embellishmentPhotoCornerAnchorsSchema = z.object({
-  x0: z.number(),
-  y0: z.number()
-});
-var embellishmentBaseSchema = z.object({
-  id: z.string(),
-  active: z.boolean(),
-  url: z.string(),
-  name: z.string(),
-  pattern: z.string(),
-  primaryColor: z.string(),
-  margin: z.number(),
-  width: z.number(),
-  height: z.number(),
-  style: z.string()
-});
-var embellishmentTextStickerSchema = embellishmentBaseSchema.extend({
-  type: z.literal("text-sticker"),
-  text: z.string(),
-  isSpecific: z.boolean(),
-  minSurface: z.number(),
-  maxSurface: z.number()
-});
-var embellishmentTPointSchema = embellishmentBaseSchema.extend({
-  type: z.literal("t-point"),
-  minSurface: z.number(),
-  maxSurface: z.number()
-});
-var embellishmentGraphicStickerSchema = embellishmentBaseSchema.extend({
-  type: z.literal("graphic-sticker"),
-  minSurface: z.number(),
-  maxSurface: z.number(),
-  hFlippable: z.boolean(),
-  vFlippable: z.boolean()
-});
-var embellishmentStampSchema = embellishmentBaseSchema.extend({
-  type: z.literal("stamp"),
-  minSurface: z.number(),
-  maxSurface: z.number(),
-  hFlippable: z.boolean(),
-  vFlippable: z.boolean()
-});
-var embellishmentTapeSchema = embellishmentBaseSchema.extend({
-  type: z.literal("tape"),
-  minSurface: z.number(),
-  maxSurface: z.number(),
-  hFlippable: z.boolean(),
-  vFlippable: z.boolean()
-});
-var embellishmentPostcardSchema = embellishmentBaseSchema.extend({
-  type: z.literal("postcard"),
-  minSurface: z.number(),
-  maxSurface: z.number(),
-  hFlippable: z.boolean(),
-  vFlippable: z.boolean()
-});
-var embellishmentBandSchema = embellishmentBaseSchema.extend({
-  type: z.literal("band"),
-  orientation: z.enum(embellishmentOrientations),
-  orientations: z.array(z.enum(embellishmentOrientations)),
-  thickness: z.enum(embellishmentThicknesses)
-});
-var embellishmentStripSchema = embellishmentBaseSchema.extend({
-  type: z.literal("strip"),
-  orientation: z.enum(embellishmentOrientations),
-  orientations: z.array(z.enum(embellishmentOrientations)),
-  thickness: z.enum(embellishmentThicknesses)
-});
-var embellishmentPhotoCornerSchema = embellishmentBaseSchema.extend({
-  type: z.literal("photo-corner"),
-  orientation: z.enum(embellishmentOrientations),
-  orientations: z.array(z.enum(embellishmentOrientations)),
-  anchors: embellishmentPhotoCornerAnchorsSchema,
-  stacking: z.enum(embellishmentStackings),
-  scale: z.number()
-});
-var embellishmentPageCornerSchema = embellishmentBaseSchema.extend({
-  type: z.literal("page-corner"),
-  orientation: z.enum(embellishmentOrientations),
-  orientations: z.array(z.enum(embellishmentOrientations)),
-  scale: z.number()
-});
-var embellishmentFrameSchema = embellishmentBaseSchema.extend({
-  type: z.literal("frame"),
-  rotatable: z.boolean(),
-  anchors: embellishmentAnchorsSchema,
-  stacking: z.enum(embellishmentStackings)
-});
-var embellishmentBackgroundListSchema = embellishmentBaseSchema.extend({
-  type: z.literal("background"),
-  rotatable: z.boolean()
-});
-var embellishmentBackgroundSchema = embellishmentBackgroundListSchema.extend({
-  colors: z.record(z.unknown()),
-  backgrounds: z.record(z.unknown())
-});
-var embellishmentSchemasArray = [
-  embellishmentBackgroundSchema,
-  embellishmentFrameSchema,
-  embellishmentTextStickerSchema,
-  embellishmentBandSchema,
-  embellishmentStripSchema,
-  embellishmentPageCornerSchema,
-  embellishmentPhotoCornerSchema,
-  embellishmentTPointSchema,
-  embellishmentStampSchema,
-  embellishmentTapeSchema,
-  embellishmentPostcardSchema,
-  embellishmentGraphicStickerSchema
-];
-var embellishmentSchemas = z.union(
-  [...embellishmentSchemasArray]
-);
-var embellishmentUpdateSchemas = z.union(
-  [
-    ...embellishmentSchemasArray.map((schema) => schema.partial().optional())
-  ]
-);
-var embellishmentListSchemasArray = [...embellishmentSchemasArray];
-embellishmentListSchemasArray.shift();
-embellishmentListSchemasArray.push(embellishmentBackgroundListSchema);
-var embellishmentListSchemas = z.union(
-  [...embellishmentListSchemasArray]
-);
-
-// ../../core/types/engine-api/pagination.ts
-function paginatedResponseSchema(arrayOf) {
-  return z.object({
-    count: z.number(),
-    nextCursor: z.string().nullable(),
-    previousCursor: z.string().optional(),
-    results: z.array(arrayOf)
-  });
-}
-
-// ../../core/types/engine-api/endpoints/embellishments.ts
-var embellishmentPaginatedSchema = paginatedResponseSchema(embellishmentListSchemas);
-var EmbellishmentsEndpoints = class {
+// ../../core/models/engine-api/endpoints/design-options.ts
+var DesignOptionsEndpoints = class {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
+    bindThisToFunctions(this);
   }
-  list({ styleSlug, qs }) {
-    return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({
-        path: `/v1/embellishments/style/${styleSlug}`,
-        qs
-      });
-      return embellishmentPaginatedSchema.parse(snakeCaseObjectKeysToCamelCase(res));
-    });
-  }
-  retrieve({ styleSlug, embellishmentId, qs }) {
+  retrieve(bookSize, imageCount, imageFilteringLevel) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/embellishments/${embellishmentId}/style/${styleSlug}`,
-        qs
-      });
-      return embellishmentSchemas.parse(snakeCaseObjectKeysToCamelCase(res));
-    });
-  }
-  update({ styleSlug, embellishmentId, payload }) {
-    return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({
-        path: `/v1/embellishments/${embellishmentId}/style/${styleSlug}`,
-        options: {
-          method: "PUT",
-          body: cleanJSON(camelCaseObjectKeysToSnakeCase({ ...payload }))
-        }
+        // eslint-disable-next-line max-len
+        path: `/v1/designoptions/booksize/${bookSize}/imagecount/${imageCount}/imagefilteringlevel/${imageFilteringLevel}`
       });
-      return embellishmentSchemas.parse(snakeCaseObjectKeysToCamelCase(res));
+      return designOptionsServerSchema.parse(res);
     });
   }
 };
 
-// ../../core/types/event.ts
+// ../../core/models/event.ts
 var eventContextSchema = z.record(z.string(), z.unknown()).optional();
 var eventSchema = z.object({
   name: z.string(),
-  context: eventContextSchema,
-  bookId: z.string(),
-  createdAt: z.string()
+  context: eventContextSchema
 });
 
-// ../../core/types/engine-api/endpoints/events.ts
-var eventPaginatedSchema = paginatedResponseSchema(eventSchema);
+// ../../core/models/engine-api/endpoints/events.ts
 var EventsEndpoints = class {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
+    bindThisToFunctions(this);
   }
-  listBookEvents({ bookId, qs }) {
-    return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({
-        path: `/v1/events/book/${bookId}`,
-        qs
-      });
-      return eventPaginatedSchema.parse(snakeCaseObjectKeysToCamelCase(res));
-    });
-  }
-  createBookEvent({ name, data, bookId, qs }) {
+  createBookEvent(bookId, name, data) {
     return handleAsyncFunction(async () => {
       const body = {
         name
@@ -4838,26 +4618,14 @@ var EventsEndpoints = class {
         options: {
           method: "POST",
           body: cleanJSON(body)
-        },
-        qs
-      });
-      return eventSchema.parse(snakeCaseObjectKeysToCamelCase(res));
-    });
-  }
-  deleteBookEvent({ name, bookId, qs }) {
-    return handleAsyncFunction(async () => {
-      await this.engineAPI.fetcher.call({
-        path: `/v1/events/book/${bookId}/name/${name}`,
-        options: {
-          method: "DELETE"
-        },
-        qs
+        }
       });
+      return eventSchema.parse(res);
     });
   }
 };
 
-// ../../core/types/fetcher.ts
+// ../../core/models/fetcher.ts
 var baseOptions = {
   headers: {
     "Content-Type": "application/json"
@@ -4878,14 +4646,12 @@ var Fetcher = class {
       }
       const baseOptions2 = { ...this.options };
       const options = props.options ? mergeNestedObject(baseOptions2, props.options) : baseOptions2;
-      const qs = props.qs ? `?${props.qs}` : "";
-      const res = await fetch(this.cleanUrl(`${this.baseUrl}${props.path}${qs}`), options);
-      if (res.status >= 200 && res.status < 300 && res.ok) {
-        const result = await res.text();
+      const res = await fetch(this.cleanUrl(new URL(props.path, this.baseUrl).href), options);
+      if (res.status >= 200 && res.status < 300) {
         try {
-          return JSON.parse(result);
+          return await res.json();
         } catch (error) {
-          return result;
+          return {};
         }
       } else {
         let detail = res.statusText;
@@ -4900,102 +4666,70 @@ var Fetcher = class {
     }
   }
   cleanUrl(url) {
-    return url.replace(/\/\//g, "/").replaceAll(" ", "").trim();
-  }
-};
-
-// ../../core/types/font.ts
-var fontRoles = ["title", "subtitle", "caption"];
-var fontSchema = z.object({
-  slug: z.string(),
-  family: z.string()
-});
-var styleFontSchema = fontSchema.extend({
-  role: z.enum(fontRoles)
-});
-
-// ../../core/types/engine-api/endpoints/fonts.ts
-var fontPaginatedSchema = paginatedResponseSchema(fontSchema);
-var FontsEndpoints = class {
-  // eslint-disable-next-line no-unused-vars
-  constructor(engineAPI) {
-    this.engineAPI = engineAPI;
-  }
-  list(props) {
-    return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({
-        path: "/v1/fonts",
-        qs: props?.qs
-      });
-      return fontPaginatedSchema.parse(snakeCaseObjectKeysToCamelCase(res));
-    });
+    return url.replaceAll(" ", "").trim();
   }
 };
 
-// ../../core/types/engine-api/endpoints/images.ts
+// ../../core/models/engine-api/endpoints/images.ts
 var ImagesEndpoints = class {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
+    bindThisToFunctions(this);
   }
-  list({ bookId, qs }) {
+  list(bookId) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/images/book/${bookId}`,
-        qs
+        path: `/v1/images/book/${bookId}`
       });
       return z.array(imageServerSchema).parse(res);
     });
   }
-  addToBook({ bookId, image, qs }) {
+  retrieve(imageId, bookId) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/images/book/${bookId}`,
-        options: {
-          method: "POST",
-          body: cleanJSON(image)
-        },
-        qs
+        path: `/v1/images/${imageId}/book/${bookId}/`
       });
       return imageServerSchema.parse(res);
     });
   }
-  retrieve({ bookId, imageId, qs }) {
+  update(imageId, bookId, image) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/images/${imageId}/book/${bookId}/`,
-        qs
+        options: {
+          method: "PUT",
+          body: cleanJSON(image)
+        }
       });
       return imageServerSchema.parse(res);
     });
   }
-  update({ bookId, imageId, payload, qs }) {
+  delete(imageId, bookId) {
     return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({
+      await this.engineAPI.fetcher.call({
         path: `/v1/images/${imageId}/book/${bookId}/`,
         options: {
-          method: "PUT",
-          body: cleanJSON(payload)
-        },
-        qs
+          method: "DELETE"
+        }
       });
-      return imageServerSchema.parse(res);
     });
   }
-  delete({ bookId, imageId, qs }) {
+  addToBook(bookId, image) {
     return handleAsyncFunction(async () => {
-      await this.engineAPI.fetcher.call({
-        path: `/v1/images/${imageId}/book/${bookId}/`,
+      const res = await this.engineAPI.fetcher.call({
+        path: `/v1/images/book/${bookId}`,
         options: {
-          method: "DELETE"
-        },
-        qs
+          method: "POST",
+          body: cleanJSON(image)
+        }
       });
+      return imageServerSchema.parse(res);
     });
   }
 };
 
-// ../../core/types/spread.ts
+// ../../core/models/spread.ts
 var spreadServerSchema = z.object({
   id: z.string().optional(),
   book_id: z.string(),
@@ -5029,70 +4763,94 @@ var spreadSchema = z.object({
   url: z.string().nullable().optional()
 });
 
-// ../../core/types/engine-api/endpoints/spreads.ts
+// ../../core/models/engine-api/endpoints/spreads.ts
 var SpreadsEndpoints = class {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
+    bindThisToFunctions(this);
   }
-  list({ bookId, qs }) {
+  list(bookId) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/spreads/book/${bookId}`,
-        qs
+        path: `/v1/spreads/book/${bookId}`
       });
-      return z.array(spreadSchema).parse(snakeCaseObjectKeysToCamelCase(res));
+      return z.array(spreadServerSchema).parse(res);
     });
   }
-  create({ bookId, spread, qs }) {
+  create(bookId, spread) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/spreads/book/${bookId}`,
         options: {
           method: "POST",
           body: cleanJSON(spread)
-        },
-        qs
+        }
       });
-      return spreadSchema.parse(snakeCaseObjectKeysToCamelCase(res));
+      return spreadServerSchema.parse(res);
     });
   }
-  retrieve({ bookId, spreadId, qs }) {
+  retrieve(spreadId, bookId) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/spreads/${spreadId}/book/${bookId}`,
-        qs
+        path: `/v1/spreads/${spreadId}/book/${bookId}`
       });
-      return spreadSchema.parse(snakeCaseObjectKeysToCamelCase(res));
+      return spreadServerSchema.parse(res);
     });
   }
-  update({ bookId, spreadId, payload, qs }) {
+  update(spreadId, bookId, spread) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/spreads/${spreadId}/book/${bookId}`,
         options: {
           method: "PUT",
-          body: cleanJSON(payload)
-        },
-        qs
+          body: cleanJSON(spread)
+        }
       });
-      return spreadSchema.parse(snakeCaseObjectKeysToCamelCase(res));
+      return spreadServerSchema.parse(res);
     });
   }
-  delete({ bookId, spreadId, qs }) {
+  delete(spreadId, bookId) {
     return handleAsyncFunction(async () => {
       await this.engineAPI.fetcher.call({
         path: `/v1/spreads/${spreadId}/book/${bookId}`,
         options: {
           method: "DELETE"
-        },
-        qs
+        }
+      });
+    });
+  }
+  layouts(bookId, page) {
+    return handleAsyncFunction(async () => {
+      const res = await this.engineAPI.fetcher.call({
+        path: "/v1/spreads/layouts",
+        options: {
+          method: "POST",
+          body: cleanJSON({
+            user_id: bookId,
+            page_num: page
+          })
+        }
       });
+      return z.array(canvasSchema).parse(res);
     });
   }
 };
 
-// ../../core/types/storyboard-item.ts
+// ../../core/models/storyboard-item.ts
+var StoryboardItemImageFaceServerSchema = z.object({
+  score: z.number(),
+  bounding_box: z.object({
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number()
+  }),
+  size: z.number(),
+  eyes_open_score: z.number(),
+  smile_score: z.number(),
+  facing_camera_score: z.number()
+});
 var StoryboardItemImageFaceSchema = z.object({
   score: z.number(),
   boundingBox: z.object({
@@ -5106,14 +4864,27 @@ var StoryboardItemImageFaceSchema = z.object({
   smileScore: z.number(),
   facingCameraScore: z.number()
 });
-var StoryboardItemImageSchema = z.object({
+var StoryboardItemImageServerSchema = z.object({
   id: z.string(),
   url: z.string(),
   category: z.string(),
-  aesthetics: z.object({
-    score: z.number(),
-    scoreWithoutDistance: z.number()
+  aesthetic_score: z.number(),
+  faces: z.array(StoryboardItemImageFaceServerSchema),
+  roi: z.object({
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number()
   }),
+  taken_at: z.number(),
+  width: z.number(),
+  height: z.number()
+});
+var StoryboardItemImageSchema = z.object({
+  id: z.string(),
+  url: z.string(),
+  category: z.string(),
+  aestheticScore: z.number(),
   faces: z.array(StoryboardItemImageFaceSchema),
   roi: z.object({
     x: z.number(),
@@ -5125,6 +4896,21 @@ var StoryboardItemImageSchema = z.object({
   width: z.number(),
   height: z.number()
 });
+var StoryboardItemServerSchema = z.object({
+  id: z.string(),
+  sequence: z.number(),
+  book_id: z.string(),
+  similarity: z.number(),
+  duplicate: z.boolean(),
+  selected: z.boolean(),
+  surface_weight: z.number(),
+  front_cover: z.boolean().optional(),
+  back_cover: z.boolean().optional(),
+  scene: z.number(),
+  subscene: z.number(),
+  spine_break: z.boolean().optional(),
+  image: StoryboardItemImageServerSchema
+});
 var StoryboardItemSchema = z.object({
   id: z.string(),
   sequence: z.number(),
@@ -5141,138 +4927,34 @@ var StoryboardItemSchema = z.object({
   image: StoryboardItemImageSchema
 });
 
-// ../../core/types/engine-api/endpoints/storyboard-items.ts
+// ../../core/models/engine-api/endpoints/storyboard-items.ts
 var StoryboardItemsEndpoints = class {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
+    bindThisToFunctions(this);
   }
-  list(props) {
-    return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({
-        path: `/v1/storyboarditems/book/${props.bookId}`
-      });
-      return z.array(StoryboardItemSchema).parse(snakeCaseObjectKeysToCamelCase(res));
-    });
-  }
-};
-
-// ../../core/types/style.ts
-var styleBaseSchema = z.object({
-  active: z.boolean(),
-  name: z.string(),
-  slug: z.string()
-});
-var backgroundSchema = z.object({
-  url: z.string(),
-  compatible: z.boolean()
-});
-var colorSchema = z.object({
-  compatible: z.boolean()
-});
-var compatibleBackgroundSchema = z.object({
-  id: z.string(),
-  url: z.string(),
-  backgrounds: z.record(z.string(), backgroundSchema),
-  colors: z.record(z.string(), colorSchema)
-});
-var whitespaceSchema = z.object({
-  min: z.number(),
-  max: z.number()
-});
-var layoutConstraintsClasses = [
-  "A",
-  "B",
-  "C",
-  "D",
-  "E",
-  "F",
-  "G",
-  "H",
-  "I",
-  "J",
-  "K",
-  "L",
-  "M",
-  "N",
-  "O",
-  "P",
-  "Q",
-  "R",
-  "S",
-  "T",
-  "U",
-  "V",
-  "W",
-  "X",
-  "Y",
-  "Z"
-];
-var layoutConstraintSchema = z.object({
-  whitespace: whitespaceSchema,
-  iWhitespace: whitespaceSchema,
-  classes: z.array(z.enum(layoutConstraintsClasses))
-});
-var layoutConstraintsSchema = z.object({
-  lots: layoutConstraintSchema,
-  few: layoutConstraintSchema,
-  none: layoutConstraintSchema
-});
-var styleSchema = styleBaseSchema.extend({
-  position: z.number(),
-  compatibleBackgrounds: z.array(compatibleBackgroundSchema),
-  fonts: z.array(styleFontSchema),
-  layoutConstraints: layoutConstraintsSchema,
-  colors: z.record(z.string(), z.array(z.string()))
-});
-
-// ../../core/types/engine-api/endpoints/styles.ts
-var stylePaginatedSchema = paginatedResponseSchema(styleBaseSchema);
-var StylesEndpoints = class {
-  // eslint-disable-next-line no-unused-vars
-  constructor(engineAPI) {
-    this.engineAPI = engineAPI;
-  }
-  list(props) {
-    return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({
-        path: "/v1/styles",
-        qs: props?.qs
-      });
-      return stylePaginatedSchema.parse(snakeCaseObjectKeysToCamelCase(res));
-    });
-  }
-  retrieve({ styleSlug, qs }) {
+  list(bookId) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/styles/${styleSlug}`,
-        qs
+        path: `/v1/storyboarditems/book/${bookId}`
       });
-      return styleSchema.parse(snakeCaseObjectKeysToCamelCase(res));
-    });
-  }
-  update({ styleSlug, payload, qs }) {
-    return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({
-        path: `/v1/styles/${styleSlug}`,
-        qs,
-        options: {
-          method: "PUT",
-          body: cleanJSON(payload)
-        }
-      });
-      return styleSchema.parse(snakeCaseObjectKeysToCamelCase(res));
+      return z.array(StoryboardItemServerSchema).parse(res);
     });
   }
 };
 
-// ../../core/types/engine-api/index.ts
+// ../../core/models/engine-api/index.ts
 var EngineAPI = class {
+  baseUrl;
+  apiKey;
   fetcher;
   constructor(baseUrl, apiKey) {
+    this.baseUrl = new URL(baseUrl);
+    this.apiKey = apiKey;
     const options = {
       headers: {
-        "Authorization": `API-Key ${apiKey}`
+        "Authorization": `API-Key ${this.apiKey}`
       }
     };
     this.fetcher = new Fetcher(baseUrl, options);
@@ -5280,19 +4962,16 @@ var EngineAPI = class {
   books = new BooksEndpoints(this);
   designOptions = new DesignOptionsEndpoints(this);
   events = new EventsEndpoints(this);
-  embellishments = new EmbellishmentsEndpoints(this);
-  fonts = new FontsEndpoints(this);
   images = new ImagesEndpoints(this);
-  spreads = new SpreadsEndpoints(this);
   storyboardItems = new StoryboardItemsEndpoints(this);
-  styles = new StylesEndpoints(this);
+  spreads = new SpreadsEndpoints(this);
 };
 
 // ../../core/config.ts
-var defaultApiHost = "https://api.dev-sls.magicbook.io";
-var defaultWebSocketHost = "wss://socket.dev-sls.magicbook.io";
+var defaultApiHost = "https://api.sfly-sls.magicbook.io";
+var defaultWebSocketHost = "wss://socket.sfly-sls.magicbook.io";
 
-// ../../core/types/client.ts
+// ../../core/models/client.ts
 var MagicBookClient = class {
   constructor(apiKey, apiHost = defaultApiHost, webSocketHost = defaultWebSocketHost) {
     this.apiKey = apiKey;
@@ -5303,7 +4982,7 @@ var MagicBookClient = class {
   engineAPI;
   async createDesignRequest(designRequestProps) {
     if (designRequestProps.userId) {
-      const book = await this.engineAPI.books.create({ book: { user_id: designRequestProps.userId } });
+      const book = await this.engineAPI.books.create(camelCaseObjectKeysToSnakeCase({ ...designRequestProps }));
       return new DesignRequest(book.id, this, designRequestProps);
     } else {
       throw new Error("userId is required");
@@ -5315,17 +4994,10 @@ export {
   BookDesignRequest,
   DesignRequest,
   DesignRequestOptions,
-  EmbellishmentsEndpoints,
-  EngineAPI,
   ImageServer,
   Images,
   MagicBookClient,
-  StoryboardItemImageFaceSchema,
-  StoryboardItemImageSchema,
-  StoryboardItemSchema,
-  StylesEndpoints,
   assetSchema,
-  backgroundSchema,
   bookCreationRequestSchema,
   bookDesignRequestSchema,
   bookPropsSchema,
@@ -5333,68 +5005,34 @@ export {
   canSubmitDesignRequest,
   cancelledEventDetail,
   canvasSchema,
-  colorSchema,
-  compatibleBackgroundSchema,
   coverTypes,
   designOptionsSchema,
-  embellishmentAnchorsSchema,
-  embellishmentBackgroundListSchema,
-  embellishmentBackgroundSchema,
-  embellishmentBandSchema,
-  embellishmentBaseSchema,
-  embellishmentFrameSchema,
-  embellishmentGraphicStickerSchema,
+  designOptionsServerSchema,
   embellishmentLevels,
-  embellishmentListSchemas,
-  embellishmentOrientations,
-  embellishmentPageCornerSchema,
-  embellishmentPhotoCornerAnchorsSchema,
-  embellishmentPhotoCornerSchema,
-  embellishmentPostcardSchema,
-  embellishmentSchemas,
-  embellishmentStackings,
-  embellishmentStampSchema,
-  embellishmentStripSchema,
-  embellishmentTPointSchema,
-  embellishmentTapeSchema,
-  embellishmentTextStickerSchema,
-  embellishmentThicknesses,
-  embellishmentTypes,
-  embellishmentUpdateSchemas,
-  fontRoles,
-  fontSchema,
   imageAssignmentSchema,
   imageDensities,
   imageDensityOptionSchema,
+  imageDensityOptionServerSchema,
   imageDensityOptionsSchema,
+  imageDensityOptionsServerSchema,
   imageFilteringLevels,
   imageServerSchema,
   imageServerToImage,
   isDesignRequestSubmitted,
-  layoutConstraintSchema,
-  layoutConstraintsClasses,
-  layoutConstraintsSchema,
   magicShopBookSchema,
   occasions,
   pageSchema,
   pageTypes,
-  paginatedResponseSchema,
   photoMetadataSchema,
   photoStripSchema,
   positionSchema,
   propertySchema,
   reportingDataSchema,
-  spreadSchema,
-  spreadServerSchema,
   states,
   statesToCloseWS,
   statesToReport,
-  styleBaseSchema,
-  styleFontSchema,
-  styleSchema,
   styles,
   textStickerLevels,
-  timeoutEventDetail,
-  whitespaceSchema
+  timeoutEventDetail
 };
 //# sourceMappingURL=index.js.map