@magiclabs.ai/magicbook-client 0.7.4 → 0.7.5-canary.0

package/index.js

@@ -265,7 +265,11 @@ function snakeCaseObjectKeysToCamelCase(snakeCaseObject) {
       delete snakeCaseObject[key];
     }
     if (typeof snakeCaseObject[camelCaseKey] === "object") {
-      snakeCaseObject[camelCaseKey] = snakeCaseObjectKeysToCamelCase(snakeCaseObject[camelCaseKey]);
+      if (snakeCaseObject[camelCaseKey] === null) {
+        snakeCaseObject[camelCaseKey] = null;
+      } else {
+        snakeCaseObject[camelCaseKey] = snakeCaseObjectKeysToCamelCase(snakeCaseObject[camelCaseKey]);
+      }
     }
   });
   return snakeCaseObject;
@@ -277,15 +281,6 @@ 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));
 }
@@ -299,7 +294,7 @@ function getStyleIdBySlug(slug) {
   return void 0;
 }
 
-// ../../node_modules/.pnpm/zod@3.21.4/node_modules/zod/lib/index.mjs
+// ../../node_modules/.pnpm/zod@3.22.4/node_modules/zod/lib/index.mjs
 var util;
 (function(util2) {
   util2.assertEqual = (val) => val;
@@ -725,7 +720,7 @@ var ParseStatus = class _ParseStatus {
         status.dirty();
       if (value.status === "dirty")
         status.dirty();
-      if (typeof value.value !== "undefined" || pair.alwaysSet) {
+      if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
         finalObject[key.value] = value.value;
       }
     }
@@ -828,6 +823,7 @@ var ZodType = class {
     this.catch = this.catch.bind(this);
     this.describe = this.describe.bind(this);
     this.pipe = this.pipe.bind(this);
+    this.readonly = this.readonly.bind(this);
     this.isNullable = this.isNullable.bind(this);
     this.isOptional = this.isOptional.bind(this);
   }
@@ -1035,6 +1031,9 @@ var ZodType = class {
   pipe(target) {
     return ZodPipeline.create(this, target);
   }
+  readonly() {
+    return ZodReadonly.create(this);
+  }
   isOptional() {
     return this.safeParse(void 0).success;
   }
@@ -1044,10 +1043,11 @@ var ZodType = class {
 };
 var cuidRegex = /^c[^\s-]{8,}$/i;
 var cuid2Regex = /^[a-z][a-z0-9]*$/;
-var ulidRegex = /[0-9A-HJKMNP-TV-Z]{26}/;
-var uuidRegex = /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
-var emailRegex = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\])|(\[IPv6:(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))\])|([A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])*(\.[A-Za-z]{2,})+))$/;
-var emojiRegex = /^(\p{Extended_Pictographic}|\p{Emoji_Component})+$/u;
+var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+var uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
+var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_+-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
+var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+var emojiRegex;
 var ipv4Regex = /^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$/;
 var ipv6Regex = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/;
 var datetimeRegex = (args) => {
@@ -1081,27 +1081,6 @@ function isValidIP(ip, version) {
   return false;
 }
 var ZodString = class _ZodString extends ZodType {
-  constructor() {
-    super(...arguments);
-    this._regex = (regex, validation, message) => this.refinement((data) => regex.test(data), {
-      validation,
-      code: ZodIssueCode.invalid_string,
-      ...errorUtil.errToObj(message)
-    });
-    this.nonempty = (message) => this.min(1, errorUtil.errToObj(message));
-    this.trim = () => new _ZodString({
-      ...this._def,
-      checks: [...this._def.checks, { kind: "trim" }]
-    });
-    this.toLowerCase = () => new _ZodString({
-      ...this._def,
-      checks: [...this._def.checks, { kind: "toLowerCase" }]
-    });
-    this.toUpperCase = () => new _ZodString({
-      ...this._def,
-      checks: [...this._def.checks, { kind: "toUpperCase" }]
-    });
-  }
   _parse(input) {
     if (this._def.coerce) {
       input.data = String(input.data);
@@ -1186,6 +1165,9 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "emoji") {
+        if (!emojiRegex) {
+          emojiRegex = new RegExp(_emojiRegex, "u");
+        }
         if (!emojiRegex.test(input.data)) {
           ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
@@ -1322,6 +1304,13 @@ var ZodString = class _ZodString extends ZodType {
     }
     return { status: status.value, value: input.data };
   }
+  _regex(regex, validation, message) {
+    return this.refinement((data) => regex.test(data), {
+      validation,
+      code: ZodIssueCode.invalid_string,
+      ...errorUtil.errToObj(message)
+    });
+  }
   _addCheck(check) {
     return new _ZodString({
       ...this._def,
@@ -1419,6 +1408,31 @@ var ZodString = class _ZodString extends ZodType {
       ...errorUtil.errToObj(message)
     });
   }
+  /**
+   * @deprecated Use z.string().min(1) instead.
+   * @see {@link ZodString.min}
+   */
+  nonempty(message) {
+    return this.min(1, errorUtil.errToObj(message));
+  }
+  trim() {
+    return new _ZodString({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "trim" }]
+    });
+  }
+  toLowerCase() {
+    return new _ZodString({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toLowerCase" }]
+    });
+  }
+  toUpperCase() {
+    return new _ZodString({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toUpperCase" }]
+    });
+  }
   get isDatetime() {
     return !!this._def.checks.find((ch) => ch.kind === "datetime");
   }
@@ -3010,6 +3024,12 @@ var ZodRecord = class _ZodRecord extends ZodType {
   }
 };
 var ZodMap = class extends ZodType {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.map) {
@@ -3204,27 +3224,29 @@ var ZodFunction = class _ZodFunction extends ZodType {
     const params = { errorMap: ctx.common.contextualErrorMap };
     const fn = ctx.data;
     if (this._def.returns instanceof ZodPromise) {
-      return OK(async (...args) => {
+      const me = this;
+      return OK(async function(...args) {
         const error = new ZodError([]);
-        const parsedArgs = await this._def.args.parseAsync(args, params).catch((e) => {
+        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
           error.addIssue(makeArgsIssue(args, e));
           throw error;
         });
-        const result = await fn(...parsedArgs);
-        const parsedReturns = await this._def.returns._def.type.parseAsync(result, params).catch((e) => {
+        const result = await Reflect.apply(fn, this, parsedArgs);
+        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
           error.addIssue(makeReturnsIssue(result, e));
           throw error;
         });
         return parsedReturns;
       });
     } else {
-      return OK((...args) => {
-        const parsedArgs = this._def.args.safeParse(args, params);
+      const me = this;
+      return OK(function(...args) {
+        const parsedArgs = me._def.args.safeParse(args, params);
         if (!parsedArgs.success) {
           throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
         }
-        const result = fn(...parsedArgs.data);
-        const parsedReturns = this._def.returns.safeParse(result, params);
+        const result = Reflect.apply(fn, this, parsedArgs.data);
+        const parsedReturns = me._def.returns.safeParse(result, params);
         if (!parsedReturns.success) {
           throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
         }
@@ -3446,8 +3468,28 @@ var ZodEffects = class extends ZodType {
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
     const effect = this._def.effect || null;
+    const checkCtx = {
+      addIssue: (arg) => {
+        addIssueToContext(ctx, arg);
+        if (arg.fatal) {
+          status.abort();
+        } else {
+          status.dirty();
+        }
+      },
+      get path() {
+        return ctx.path;
+      }
+    };
+    checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
     if (effect.type === "preprocess") {
-      const processed = effect.transform(ctx.data);
+      const processed = effect.transform(ctx.data, checkCtx);
+      if (ctx.common.issues.length) {
+        return {
+          status: "dirty",
+          value: ctx.data
+        };
+      }
       if (ctx.common.async) {
         return Promise.resolve(processed).then((processed2) => {
           return this._def.schema._parseAsync({
@@ -3464,20 +3506,6 @@ var ZodEffects = class extends ZodType {
         });
       }
     }
-    const checkCtx = {
-      addIssue: (arg) => {
-        addIssueToContext(ctx, arg);
-        if (arg.fatal) {
-          status.abort();
-        } else {
-          status.dirty();
-        }
-      },
-      get path() {
-        return ctx.path;
-      }
-    };
-    checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
     if (effect.type === "refinement") {
       const executeRefinement = (acc) => {
         const result = effect.refinement(acc, checkCtx);
@@ -3761,6 +3789,22 @@ var ZodPipeline = class _ZodPipeline extends ZodType {
     });
   }
 };
+var ZodReadonly = class extends ZodType {
+  _parse(input) {
+    const result = this._def.innerType._parse(input);
+    if (isValid(result)) {
+      result.value = Object.freeze(result.value);
+    }
+    return result;
+  }
+};
+ZodReadonly.create = (type, params) => {
+  return new ZodReadonly({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodReadonly,
+    ...processCreateParams(params)
+  });
+};
 var custom = (check, params = {}, fatal) => {
   if (check)
     return ZodAny.create().superRefine((data, ctx) => {
@@ -3814,6 +3858,7 @@ var ZodFirstPartyTypeKind;
   ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
   ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
   ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
+  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
 var instanceOfType = (cls, params = {
   message: `Input not instance of ${cls.name}`
@@ -3928,6 +3973,7 @@ var z = /* @__PURE__ */ Object.freeze({
   BRAND,
   ZodBranded,
   ZodPipeline,
+  ZodReadonly,
   custom,
   Schema: ZodType,
   ZodSchema: ZodType,
@@ -3981,7 +4027,7 @@ var z = /* @__PURE__ */ Object.freeze({
   ZodError
 });
 
-// ../../core/models/book.ts
+// ../../core/types/book.ts
 var BookDesignRequest = class {
   occasion;
   style;
@@ -4023,7 +4069,7 @@ var bookPropsSchema = z.object({
   state: z.enum(states).optional(),
   guid: z.string().optional(),
   cancelled_at: z.string().optional(),
-  mb_client_timeout: z.number().optional(),
+  mb_client_timeout: z.string().optional(),
   user_id: z.string().optional(),
   revision: z.number().optional()
 });
@@ -4046,7 +4092,7 @@ var Book = class {
     this.state = props.state;
     this.guid = props.guid;
     this.cancelled_at = props.cancelled_at;
-    this.timeout = props.mb_client_timeout ? props.mb_client_timeout * 1e3 : void 0;
+    this.timeout = props.mb_client_timeout ? parseInt(props.mb_client_timeout) * 1e3 : void 0;
     this.user_id = props.user_id;
     this.revision = props.revision;
   }
@@ -4060,12 +4106,12 @@ var Book = class {
   toBookProps() {
     return {
       ...this,
-      mb_client_timeout: this.timeout ? this.timeout / 1e3 : void 0
+      mb_client_timeout: this.timeout ? (this.timeout / 1e3).toString() : void 0
     };
   }
 };
 
-// ../../core/models/design-request/image.ts
+// ../../core/types/design-request/image.ts
 var Images = class {
   // eslint-disable-next-line no-unused-vars
   constructor(client, parentId, designRequestState) {
@@ -4085,7 +4131,10 @@ var Images = class {
     } else {
       this.images.push(image);
       this.length = this.images.length;
-      await this.client.engineAPI.images.addToBook(this.parentId, new ImageServer(image));
+      await this.client.engineAPI.images.addToBook({
+        bookId: this.parentId,
+        image: new ImageServer(image)
+      });
       return new Promise((resolve) => {
         resolve(this.length);
       });
@@ -4126,8 +4175,21 @@ var ImageServer = class {
     this.filename = image.filename;
   }
 };
+function imageServerToImage(imageServer) {
+  return {
+    handle: imageServer.handle,
+    url: imageServer.url,
+    width: imageServer.width,
+    height: imageServer.height,
+    rotation: imageServer.orientation,
+    captureTime: imageServer.taken_at,
+    cameraMake: imageServer.camera_make,
+    cameraModel: imageServer.camera,
+    filename: imageServer.filename
+  };
+}
 
-// ../../core/models/design-request/design-options.ts
+// ../../core/types/design-request/design-options.ts
 var imageDensityOptionSchema = z.object({
   maxPageCount: z.number(),
   minPageCount: z.number(),
@@ -4143,23 +4205,8 @@ 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/models/design-request/index.ts
+// ../../core/types/design-request/index.ts
 var DesignRequestOptions = {
   occasion: occasions,
   style: Object.keys(styles).map((key) => parseInt(key)),
@@ -4214,13 +4261,13 @@ var DesignRequest = class {
     }
   }
   async getOptions(imageCount) {
-    const options = designOptionsSchema.parse(snakeCaseObjectKeysToCamelCase(
-      await this.client.engineAPI.designOptions.retrieve(
-        this.bookSize,
-        imageCount || this.images.length,
-        this.imageFilteringLevel
-      )
-    ));
+    const options = designOptionsSchema.parse(
+      await this.client.engineAPI.designOptions.retrieve({
+        bookSize: this.bookSize,
+        imageCount: imageCount || this.images.length,
+        imageFilteringLevel: this.imageFilteringLevel
+      })
+    );
     return options;
   }
   async submit(submitDesignRequestProps) {
@@ -4229,9 +4276,12 @@ var DesignRequest = class {
     } else {
       submitDesignRequestProps && this.updateDesignRequest(submitDesignRequestProps);
       this.webSocket = new WebSocket(`${this.client.webSocketHost}/?book_id=${this.parentId}`);
-      await this.client.engineAPI.books.update(this.parentId, this.toBook());
+      await this.client.engineAPI.books.update({
+        bookId: this.parentId,
+        payload: this.toBook()
+      });
       this.updateDesignRequest(
-        (await this.client.engineAPI.books.design(this.parentId)).toDesignRequestProps()
+        (await this.client.engineAPI.books.design({ bookId: this.parentId })).toDesignRequestProps()
       );
       this.getProgress();
       return this;
@@ -4243,7 +4293,10 @@ var DesignRequest = class {
     } else {
       this.guid = guid;
       this.updateDesignRequest(
-        (await this.client.engineAPI.books.update(this.parentId, this.toBook())).toDesignRequestProps()
+        (await this.client.engineAPI.books.update({
+          bookId: this.parentId,
+          payload: this.toBook()
+        })).toDesignRequestProps()
       );
       return this.guid;
     }
@@ -4257,7 +4310,9 @@ var DesignRequest = class {
       throw new Error("Design request not submitted");
     } else {
       this.updateDesignRequest({
-        ...(await this.client.engineAPI.books.cancel(this.parentId)).toDesignRequestProps(),
+        ...(await this.client.engineAPI.books.cancel({
+          bookId: this.parentId
+        })).toDesignRequestProps(),
         state: "cancelled"
       });
       await this.eventHandler(cancelledEventDetail);
@@ -4266,22 +4321,31 @@ var DesignRequest = class {
   }
   async getJSON() {
     if (this.state === "ready") {
-      return await this.client.engineAPI.books.retrieveGalleon(this.parentId);
+      return await this.client.engineAPI.books.retrieveGalleon({
+        bookId: this.parentId
+      });
     } else {
       throw new Error("Design request not ready");
     }
   }
   async logEvent(name, data) {
-    return await this.client.engineAPI.events.createBookEvent(this.parentId, name, data);
+    return await this.client.engineAPI.events.createBookEvent({
+      bookId: 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(this.parentId, {
-          error: detail.slug === "error" ? "design" : "timeout",
-          step: this.state
+        await this.client.engineAPI.books.report({
+          bookId: this.parentId,
+          report: {
+            error: detail.slug === "error" ? "design" : "timeout",
+            step: this.state
+          }
         });
       }
     }
@@ -4334,7 +4398,7 @@ var DesignRequest = class {
   }
 };
 
-// ../../core/models/galleon.ts
+// ../../core/types/galleon.ts
 var imageAssignmentSchema = z.object({
   photoRefId: z.string(),
   finalCrop: z.array(z.number())
@@ -4413,128 +4477,357 @@ var bookCreationRequestSchema = z.object({
   reportingData: reportingDataSchema
 });
 
-// ../../core/models/engine-api/endpoints/books.ts
+// ../../core/types/engine-api/endpoints/books.ts
 var BooksEndpoints = class {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
-    bindThisToFunctions(this);
   }
-  create(book) {
+  create({ book, qs }) {
     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) {
+  retrieve({ bookId, qs }) {
     return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({ path: `/v1/books/${bookId}` });
-      bookPropsSchema.safeParse(res);
-      return new Book(res);
+      const res = await this.engineAPI.fetcher.call({
+        path: `/v1/books/${bookId}`,
+        qs
+      });
+      const bookProps = bookPropsSchema.parse(res);
+      return new Book(bookProps);
     });
   }
-  update(bookId, book) {
+  update({ bookId, payload, qs }) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/books/${bookId}`,
         options: {
           method: "PUT",
-          body: cleanJSON(book)
-        }
+          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
       });
-      bookPropsSchema.safeParse(res);
-      return new Book(res);
     });
   }
-  design(bookId) {
+  design({ bookId, qs }) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/books/${bookId}/design`,
-        options: { method: "POST" }
+        options: { method: "POST" },
+        qs
       });
-      bookPropsSchema.safeParse(res);
-      return new Book(res);
+      const bookProps = bookPropsSchema.parse(res);
+      return new Book(bookProps);
     });
   }
-  cancel(bookId) {
+  cancel({ bookId, qs }) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/books/${bookId}/cancel`,
-        options: { method: "POST" }
+        options: { method: "POST" },
+        qs
       });
-      bookPropsSchema.safeParse(res);
-      return new Book(res);
+      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);
     });
   }
-  report(bookId, report) {
+  report({ bookId, report, qs }) {
     return handleAsyncFunction(async () => {
       await this.engineAPI.fetcher.call({
         path: `/v1/books/${bookId}/report`,
         options: {
           method: "POST",
           body: cleanJSON(report)
-        }
+        },
+        qs
       });
     });
   }
-  delete(bookId) {
-    return handleAsyncFunction(async () => {
-      await this.engineAPI.fetcher.call({
-        path: `/v1/books/${bookId}`,
-        options: { method: "DELETE" }
-      });
-    });
+};
+
+// ../../core/types/engine-api/endpoints/design-options.ts
+var DesignOptionsEndpoints = class {
+  // eslint-disable-next-line no-unused-vars
+  constructor(engineAPI) {
+    this.engineAPI = engineAPI;
   }
-  retrieveGalleon(bookId) {
+  retrieve(props) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/books/${bookId}/format/galleon`
+        // eslint-disable-next-line max-len
+        path: `/v1/designoptions/booksize/${props.bookSize}/imagecount/${props.imageCount}/imagefilteringlevel/${props.imageFilteringLevel}`,
+        qs: props.qs
       });
-      return bookCreationRequestSchema.parse(res);
+      return designOptionsSchema.parse(snakeCaseObjectKeysToCamelCase(res));
     });
   }
 };
 
-// ../../core/models/engine-api/endpoints/design-options.ts
-var DesignOptionsEndpoints = class {
+// ../../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 {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
-    bindThisToFunctions(this);
   }
-  retrieve(bookSize, imageCount, imageFilteringLevel) {
+  list({ styleSlug, qs }) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        // eslint-disable-next-line max-len
-        path: `/v1/designoptions/booksize/${bookSize}/imagecount/${imageCount}/imagefilteringlevel/${imageFilteringLevel}`
+        path: `/v1/embellishments/style/${styleSlug}`,
+        qs
+      });
+      return embellishmentPaginatedSchema.parse(snakeCaseObjectKeysToCamelCase(res));
+    });
+  }
+  retrieve({ styleSlug, embellishmentId, qs }) {
+    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 }))
+        }
       });
-      return designOptionsServerSchema.parse(res);
+      return embellishmentSchemas.parse(snakeCaseObjectKeysToCamelCase(res));
     });
   }
 };
 
-// ../../core/models/event.ts
+// ../../core/types/event.ts
 var eventContextSchema = z.record(z.string(), z.unknown()).optional();
 var eventSchema = z.object({
   name: z.string(),
-  context: eventContextSchema
+  context: eventContextSchema,
+  bookId: z.string(),
+  createdAt: z.string()
 });
 
-// ../../core/models/engine-api/endpoints/events.ts
+// ../../core/types/engine-api/endpoints/events.ts
+var eventPaginatedSchema = paginatedResponseSchema(eventSchema);
 var EventsEndpoints = class {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
-    bindThisToFunctions(this);
   }
-  createBookEvent(bookId, name, data) {
+  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 }) {
     return handleAsyncFunction(async () => {
       const body = {
         name
@@ -4545,14 +4838,26 @@ 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/models/fetcher.ts
+// ../../core/types/fetcher.ts
 var baseOptions = {
   headers: {
     "Content-Type": "application/json"
@@ -4573,12 +4878,14 @@ var Fetcher = class {
       }
       const baseOptions2 = { ...this.options };
       const options = props.options ? mergeNestedObject(baseOptions2, props.options) : baseOptions2;
-      const res = await fetch(this.cleanUrl(new URL(props.path, this.baseUrl).href), options);
-      if (res.status >= 200 && res.status < 300) {
+      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();
         try {
-          return await res.json();
+          return JSON.parse(result);
         } catch (error) {
-          return {};
+          return result;
         }
       } else {
         let detail = res.statusText;
@@ -4593,70 +4900,102 @@ var Fetcher = class {
     }
   }
   cleanUrl(url) {
-    return url.replaceAll(" ", "").trim();
+    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));
+    });
   }
 };
 
-// ../../core/models/engine-api/endpoints/images.ts
+// ../../core/types/engine-api/endpoints/images.ts
 var ImagesEndpoints = class {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
-    bindThisToFunctions(this);
   }
-  list(bookId) {
+  list({ bookId, qs }) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/images/book/${bookId}`
+        path: `/v1/images/book/${bookId}`,
+        qs
       });
       return z.array(imageServerSchema).parse(res);
     });
   }
-  retrieve(imageId, bookId) {
+  addToBook({ bookId, image, qs }) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/images/${imageId}/book/${bookId}/`
+        path: `/v1/images/book/${bookId}`,
+        options: {
+          method: "POST",
+          body: cleanJSON(image)
+        },
+        qs
       });
       return imageServerSchema.parse(res);
     });
   }
-  update(imageId, bookId, image) {
+  retrieve({ bookId, imageId, qs }) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/images/${imageId}/book/${bookId}/`,
-        options: {
-          method: "PUT",
-          body: cleanJSON(image)
-        }
+        qs
       });
       return imageServerSchema.parse(res);
     });
   }
-  delete(imageId, bookId) {
+  update({ bookId, imageId, payload, qs }) {
     return handleAsyncFunction(async () => {
-      await this.engineAPI.fetcher.call({
+      const res = await this.engineAPI.fetcher.call({
         path: `/v1/images/${imageId}/book/${bookId}/`,
         options: {
-          method: "DELETE"
-        }
+          method: "PUT",
+          body: cleanJSON(payload)
+        },
+        qs
       });
+      return imageServerSchema.parse(res);
     });
   }
-  addToBook(bookId, image) {
+  delete({ bookId, imageId, qs }) {
     return handleAsyncFunction(async () => {
-      const res = await this.engineAPI.fetcher.call({
-        path: `/v1/images/book/${bookId}`,
+      await this.engineAPI.fetcher.call({
+        path: `/v1/images/${imageId}/book/${bookId}/`,
         options: {
-          method: "POST",
-          body: cleanJSON(image)
-        }
+          method: "DELETE"
+        },
+        qs
       });
-      return imageServerSchema.parse(res);
     });
   }
 };
 
-// ../../core/models/spread.ts
+// ../../core/types/spread.ts
 var spreadServerSchema = z.object({
   id: z.string().optional(),
   book_id: z.string(),
@@ -4690,79 +5029,70 @@ var spreadSchema = z.object({
   url: z.string().nullable().optional()
 });
 
-// ../../core/models/engine-api/endpoints/spreads.ts
+// ../../core/types/engine-api/endpoints/spreads.ts
 var SpreadsEndpoints = class {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
-    bindThisToFunctions(this);
   }
-  list(bookId) {
+  list({ bookId, qs }) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/spreads/book/${bookId}`
+        path: `/v1/spreads/book/${bookId}`,
+        qs
       });
-      return z.array(spreadServerSchema).parse(res);
+      return z.array(spreadSchema).parse(snakeCaseObjectKeysToCamelCase(res));
     });
   }
-  create(bookId, spread) {
+  create({ bookId, spread, qs }) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/spreads/book/${bookId}`,
         options: {
           method: "POST",
           body: cleanJSON(spread)
-        }
+        },
+        qs
       });
-      return spreadServerSchema.parse(res);
+      return spreadSchema.parse(snakeCaseObjectKeysToCamelCase(res));
     });
   }
-  retrieve(spreadId, bookId) {
+  retrieve({ bookId, spreadId, qs }) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/spreads/${spreadId}/book/${bookId}`
+        path: `/v1/spreads/${spreadId}/book/${bookId}`,
+        qs
       });
-      return spreadServerSchema.parse(res);
+      return spreadSchema.parse(snakeCaseObjectKeysToCamelCase(res));
     });
   }
-  update(spreadId, bookId, spread) {
+  update({ bookId, spreadId, payload, qs }) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
         path: `/v1/spreads/${spreadId}/book/${bookId}`,
         options: {
           method: "PUT",
-          body: cleanJSON(spread)
-        }
+          body: cleanJSON(payload)
+        },
+        qs
       });
-      return spreadServerSchema.parse(res);
+      return spreadSchema.parse(snakeCaseObjectKeysToCamelCase(res));
     });
   }
-  delete(spreadId, bookId) {
+  delete({ bookId, spreadId, qs }) {
     return handleAsyncFunction(async () => {
       await this.engineAPI.fetcher.call({
         path: `/v1/spreads/${spreadId}/book/${bookId}`,
         options: {
           method: "DELETE"
-        }
+        },
+        qs
       });
     });
   }
 };
 
-// ../../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()
-});
+// ../../core/types/storyboard-item.ts
 var StoryboardItemImageFaceSchema = z.object({
   score: z.number(),
   boundingBox: z.object({
@@ -4776,27 +5106,14 @@ var StoryboardItemImageFaceSchema = z.object({
   smileScore: z.number(),
   facingCameraScore: z.number()
 });
-var StoryboardItemImageServerSchema = z.object({
-  id: z.string(),
-  url: z.string(),
-  category: z.string(),
-  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(),
+  aesthetics: z.object({
+    score: z.number(),
+    scoreWithoutDistance: z.number()
+  }),
   faces: z.array(StoryboardItemImageFaceSchema),
   roi: z.object({
     x: z.number(),
@@ -4808,21 +5125,6 @@ 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(),
@@ -4839,34 +5141,138 @@ var StoryboardItemSchema = z.object({
   image: StoryboardItemImageSchema
 });
 
-// ../../core/models/engine-api/endpoints/storyboard-items.ts
+// ../../core/types/engine-api/endpoints/storyboard-items.ts
 var StoryboardItemsEndpoints = class {
   // eslint-disable-next-line no-unused-vars
   constructor(engineAPI) {
     this.engineAPI = engineAPI;
-    bindThisToFunctions(this);
   }
-  list(bookId) {
+  list(props) {
     return handleAsyncFunction(async () => {
       const res = await this.engineAPI.fetcher.call({
-        path: `/v1/storyboarditems/book/${bookId}`
+        path: `/v1/storyboarditems/book/${props.bookId}`
       });
-      return z.array(StoryboardItemServerSchema).parse(res);
+      return z.array(StoryboardItemSchema).parse(snakeCaseObjectKeysToCamelCase(res));
     });
   }
 };
 
-// ../../core/models/engine-api/index.ts
+// ../../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 }) {
+    return handleAsyncFunction(async () => {
+      const res = await this.engineAPI.fetcher.call({
+        path: `/v1/styles/${styleSlug}`,
+        qs
+      });
+      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));
+    });
+  }
+};
+
+// ../../core/types/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 ${this.apiKey}`
+        "Authorization": `API-Key ${apiKey}`
       }
     };
     this.fetcher = new Fetcher(baseUrl, options);
@@ -4874,16 +5280,19 @@ 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);
-  storyboardItems = new StoryboardItemsEndpoints(this);
   spreads = new SpreadsEndpoints(this);
+  storyboardItems = new StoryboardItemsEndpoints(this);
+  styles = new StylesEndpoints(this);
 };
 
 // ../../core/config.ts
-var defaultApiHost = "https://api.sfly-sls.magicbook.io";
-var defaultWebSocketHost = "wss://socket.sfly-sls.magicbook.io";
+var defaultApiHost = "https://api.dev-sls.magicbook.io";
+var defaultWebSocketHost = "wss://socket.dev-sls.magicbook.io";
 
-// ../../core/models/client.ts
+// ../../core/types/client.ts
 var MagicBookClient = class {
   constructor(apiKey, apiHost = defaultApiHost, webSocketHost = defaultWebSocketHost) {
     this.apiKey = apiKey;
@@ -4894,7 +5303,7 @@ var MagicBookClient = class {
   engineAPI;
   async createDesignRequest(designRequestProps) {
     if (designRequestProps.userId) {
-      const book = await this.engineAPI.books.create(camelCaseObjectKeysToSnakeCase({ ...designRequestProps }));
+      const book = await this.engineAPI.books.create({ book: { user_id: designRequestProps.userId } });
       return new DesignRequest(book.id, this, designRequestProps);
     } else {
       throw new Error("userId is required");
@@ -4906,10 +5315,17 @@ export {
   BookDesignRequest,
   DesignRequest,
   DesignRequestOptions,
+  EmbellishmentsEndpoints,
+  EngineAPI,
   ImageServer,
   Images,
   MagicBookClient,
+  StoryboardItemImageFaceSchema,
+  StoryboardItemImageSchema,
+  StoryboardItemSchema,
+  StylesEndpoints,
   assetSchema,
+  backgroundSchema,
   bookCreationRequestSchema,
   bookDesignRequestSchema,
   bookPropsSchema,
@@ -4917,33 +5333,68 @@ export {
   canSubmitDesignRequest,
   cancelledEventDetail,
   canvasSchema,
+  colorSchema,
+  compatibleBackgroundSchema,
   coverTypes,
   designOptionsSchema,
-  designOptionsServerSchema,
+  embellishmentAnchorsSchema,
+  embellishmentBackgroundListSchema,
+  embellishmentBackgroundSchema,
+  embellishmentBandSchema,
+  embellishmentBaseSchema,
+  embellishmentFrameSchema,
+  embellishmentGraphicStickerSchema,
   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
+  timeoutEventDetail,
+  whitespaceSchema
 };
 //# sourceMappingURL=index.js.map