@interware/content-generator 0.1.4 → 0.2.0

package/dist/server/index.js

@@ -1,27 +1,5 @@
 "use strict";
 const genai = require("@google/genai");
-const slugify = require("slugify");
-const https = require("https");
-const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const slugify__default = /* @__PURE__ */ _interopDefault(slugify);
-const https__namespace = /* @__PURE__ */ _interopNamespace(https);
 const PLUGIN_ID = "strapi-content-generator-gemini";
 const bootstrap = ({ strapi }) => {
   strapi.admin.services.permission.actionProvider.registerMany([
@@ -97,6 +75,30 @@ const controller = ({ strapi }) => {
         auth: ctx.state.auth
       });
     },
+    async getImages(ctx) {
+      const contentType = strapi.contentType("plugin::upload.file");
+      const files = await pluginService().getImagenes();
+      return await strapi.contentAPI.sanitize.output(files, contentType, {
+        auth: ctx.state.auth
+      });
+    },
+    async deleteImage(ctx) {
+      const contentType = strapi.contentType("plugin::upload.file");
+      await strapi.contentAPI.validate.query(ctx.query, contentType, {
+        auth: ctx.state.auth
+      });
+      const sanitizedQueryParams = await strapi.contentAPI.sanitize.query(
+        ctx.query,
+        contentType,
+        {
+          auth: ctx.state.auth
+        }
+      );
+      const file = await pluginService().eliminarImagen(sanitizedQueryParams);
+      return await strapi.contentAPI.sanitize.output(file, contentType, {
+        auth: ctx.state.auth
+      });
+    },
     async generateArticle(ctx) {
       ctx.body = await pluginService().generateArticle(ctx);
     },
@@ -142,10 +144,12 @@ const config = ({ strapi }) => {
       const googleGenAI = await pluginStore.get({ key: "GOOGLE_GEN_AI" });
       const linkedInAccessToken = await pluginStore.get({ key: "LINKEDIN_ACCESS_TOKEN" });
       const linkedInOrganizationId = await pluginStore.get({ key: "LINKEDIN_ORGANIZATION_ID" });
-      ctx.body = { googleGenAI, linkedInAccessToken, linkedInOrganizationId };
+      const facebookClientToken = await pluginStore.get({ key: "FACEBOOK_CLIENT_TOKEN" });
+      const facebookPageId = await pluginStore.get({ key: "FACEBOOK_PAGE_ID" });
+      ctx.body = { googleGenAI, linkedInAccessToken, linkedInOrganizationId, facebookClientToken, facebookPageId };
     },
     async set(ctx) {
-      const { googleGenAI, linkedInAccessToken, linkedInOrganizationId } = ctx.request.body;
+      const { googleGenAI, linkedInAccessToken, linkedInOrganizationId, facebookClientToken, facebookPageId } = ctx.request.body;
       const pluginStore = strapi.store({
         type: "plugin",
         name: "strapi-content-generator-gemini"
@@ -153,6 +157,8 @@ const config = ({ strapi }) => {
       await pluginStore.set({ key: "GOOGLE_GEN_AI", value: googleGenAI });
       await pluginStore.set({ key: "LINKEDIN_ACCESS_TOKEN", value: linkedInAccessToken });
       await pluginStore.set({ key: "LINKEDIN_ORGANIZATION_ID", value: linkedInOrganizationId });
+      await pluginStore.set({ key: "FACEBOOK_CLIENT_TOKEN", value: facebookClientToken });
+      await pluginStore.set({ key: "FACEBOOK_PAGE_ID", value: facebookPageId });
       ctx.body = { ok: true };
     }
   };
@@ -191,6 +197,24 @@ const admin = [
       auth: false
     }
   },
+  {
+    method: "GET",
+    path: "/images",
+    handler: "controller.getImages",
+    config: {
+      policies: [],
+      auth: false
+    }
+  },
+  {
+    method: "DELETE",
+    path: "/delete-image",
+    handler: "controller.deleteImage",
+    config: {
+      policies: [],
+      auth: false
+    }
+  },
   {
     method: "POST",
     path: "/generate-article",
@@ -2721,29 +2745,6 @@ const {
   getAdapter,
   mergeConfig
 } = axios;
-function imageUrlToBase64(url) {
-  return new Promise((resolve, reject) => {
-    https__namespace.get(url, (response) => {
-      if (response.statusCode < 200 || response.statusCode >= 300) {
-        return reject(
-          new Error(
-            `Failed to download image, status code: ${response.statusCode}`
-          )
-        );
-      }
-      const chunks = [];
-      response.on("data", (chunk) => {
-        chunks.push(chunk);
-      });
-      response.on("end", () => {
-        const buffer = Buffer.concat(chunks);
-        resolve(buffer.toString("base64"));
-      });
-    }).on("error", (error) => {
-      reject(error);
-    });
-  });
-}
 const service = ({ strapi }) => {
   return {
     // ───────────────────────────────
@@ -2773,39 +2774,69 @@ const service = ({ strapi }) => {
       return await strapi.entityService.findMany("api::categoria.categoria", sanitizedQueryParams);
     },
     async getUsuarios(sanitizedQueryParams) {
-      return await strapi.entityService.findMany("plugin::users-permissions.user", sanitizedQueryParams);
+      return await strapi.documents("plugin::users-permissions.user").findMany(sanitizedQueryParams);
+    },
+    async getImagenes() {
+      const existingFolders = await strapi.documents("plugin::upload.folder").findMany({
+        filters: {
+          name: "Generated"
+        }
+      });
+      if (existingFolders) {
+        return await strapi.documents("plugin::upload.file").findMany({
+          filters: {
+            folder: {
+              id: {
+                $eq: existingFolders[0].id
+              }
+            }
+          }
+        });
+      }
+      return [];
+    },
+    async eliminarImagen(sanitizedQueryParams) {
+      return await strapi.documents("plugin::upload.file").delete(sanitizedQueryParams);
     },
     // ───────────────────────────────
     // 🧠 Generate Article with AI
     // ───────────────────────────────
     async generateArticle(ctx) {
-      const { titulo, categoria, autor, keywords, instrucciones } = ctx.request.body;
+      const { titulo, categoria, autor, temperatura = 0.2, instrucciones } = ctx.request.body;
       const promptArticulo = `
-      Genera un artículo en español neutro, orientado a SEO, con estructura clara, sin emojis, sin texto fuera del JSON, respetando estrictamente el schema proporcionado.
+        Actúa como un Redactor Técnico Senior experto en tecnología corporativa para la empresa "InterWare"
+
+        Tu tarea es generar un artículo de blog en formato JSON estricto, siguiendo el schema proporcionado.
 
-      Requisitos para "content":
-      - HTML compatible con @_sh/strapi-plugin-ckeditor (DefaultHTML editor)
-      - Debe incluir:
-        - Título en H1
-        - Introducción
-        - Subtítulos H2 (puedes usar hasta H6)
-        - Listas
-        - Tablas (sólo si el contenido lo amerita)
-        - Ejemplo práctico (sólo si el contenido lo amerita)
-        - Conclusión o comentarios finales (no es necesario etiquetarlo con un encabezado)
+        IDENTIDAD Y TONO DE VOZ (Brand Book):
+        - Tono: Profesional, innovador, confiable y empático.
+        - Estilo: Español neutro corporativo. Evita coloquialismos excesivos pero no seas robótico.
+        - Enfoque: Tecnología, Innovación y Soluciones Empresariales.
 
-      SEO:
-      - Incluir metadatos necesarios para Facebook y LinkedIn
-      - Omitir author, publisher, image y robots
-      - og:url es: https:://interware.com.mx/blog/{SLUG DEL TÍTULO}
+        ESTRUCTURA DEL CONTENIDO (HTML para CKEditor):
+        - El campo "content" debe contener HTML válido y limpio.
+        - Estructura obligatoria dentro del HTML:
+          1. <h1>Título del Artículo</h1> (Debe ser impactante y contener la palabra clave principal).
+          2. <p>Introducción</p> (Planteamiento del problema o contexto tecnológico).
+          3. Desarrollo usando <h2> y hasta <h6> para jerarquía.
+          4. Uso de <ul> o <ol> para listar beneficios o características.
+          5. (Opcional) <table> si hay datos comparativos.
+          6. Conclusión o Cierre (Sin subtítulo "Conclusión", intégralo naturalmente).
 
-      Restricciones:
-      - No usar frases como: deja tu opinión, comenta, suscríbete, etc.
+        SEO:
+        - Incluir metadatos necesarios para Facebook y LinkedIn
+        - og:url: Debe ser "https://interware.com.mx/blog/{slug-generado}"
+        - Omitir author, publisher, image y robots
 
-        ${titulo ? `Básate en el título: "${titulo}".` : ""}
-        ${categoria ? `Categoría(s): "${categoria}".` : ""}
-        ${keywords ? `Palabras clave: "${keywords}".` : ""}
-        ${instrucciones ? `Instrucciones adicionales: "${instrucciones}".` : ""}
+        RESTRICCIONES TÉCNICAS Y DE ESTILO:
+        - PROHIBIDO: Emojis, Markdown (no usar **negritas** estilo MD, usar <strong>), bloques de código sin etiqueta <pre>.
+        - PROHIBIDO: Frases de "Youtuber" (ej: "Suscríbete", "Deja tu like", "Comenta abajo").
+        - PROHIBIDO: Texto introductorio fuera del JSON (ej: "Aquí tienes tu JSON..."). Solo devuelve el objeto JSON.
+
+        ENTRADA DE CONTEXTO:
+        ${titulo ? `- Título sugerido: "${titulo}"` : ""}
+        ${categoria ? `- Categoría/Tema: "${categoria}"` : ""}
+        ${instrucciones ? `- Instrucciones extra: "${instrucciones}"` : ""}
       `;
       try {
         const ai = await this.geminiConfig();
@@ -2814,27 +2845,11 @@ const service = ({ strapi }) => {
           contents: promptArticulo,
           config: {
             responseMimeType: "application/json",
-            temperature: 0.2,
+            temperature: temperatura,
             responseSchema: {
               type: "object",
               required: ["titulo", "descripcion", "content", "seo", "minute_read"],
               properties: {
-                titulo: {
-                  type: "string",
-                  minLength: 40,
-                  maxLength: 70,
-                  description: "Título del artículo"
-                },
-                descripcion: {
-                  type: "string",
-                  minLength: 80,
-                  maxLength: 160,
-                  description: "Descripción breve del artículo"
-                },
-                content: {
-                  type: "string",
-                  description: "Contenido HTML compatible con CKEditor"
-                },
                 seo: {
                   type: "object",
                   required: ["metaTitle", "metaDescription", "metadata"],
@@ -2858,11 +2873,46 @@ const service = ({ strapi }) => {
                     }
                   }
                 },
+                titulo: {
+                  type: "string",
+                  minLength: 40,
+                  maxLength: 70,
+                  description: "Título del artículo"
+                },
+                descripcion: {
+                  type: "string",
+                  minLength: 80,
+                  maxLength: 160,
+                  description: "Descripción breve del artículo"
+                },
+                slug: {
+                  type: "string",
+                  minLength: 80,
+                  maxLength: 160,
+                  description: "URL-friendly basado en el título (ej: estrategias-migracion-nube)"
+                },
+                content: {
+                  type: "string",
+                  description: "Contenido HTML compatible con CKEditor"
+                },
                 minute_read: {
                   type: "number",
                   minimum: 1,
                   maximum: 30,
                   description: "Tiempo de lectura calculado usando 200 palabras por minuto"
+                },
+                keywords: {
+                  type: "array",
+                  minItems: 3,
+                  maxItems: 5,
+                  items: {
+                    type: "object",
+                    required: ["name"],
+                    properties: {
+                      name: { type: "string" }
+                    }
+                  },
+                  description: "Hash tags y palabras clave para la publicación en LinkedIn y Facebook"
                 }
               }
             }
@@ -2875,6 +2925,7 @@ const service = ({ strapi }) => {
           );
         }
         const parsed = JSON.parse(rawText);
+        console.log("🚀 ~ service ~ parsed:", parsed);
         const article = await strapi.documents("api::articulo.articulo").create({
           data: {
             titulo: parsed.titulo,
@@ -2882,10 +2933,11 @@ const service = ({ strapi }) => {
             content: parsed.content,
             seo: parsed.seo,
             minute_read: parsed.minute_read,
-            slug: slugify__default.default(parsed.titulo, { lower: true, strict: true }),
+            slug: parsed.slug,
             categoria,
             autor,
-            image: null
+            image: null,
+            keywords: parsed.keywords
           },
           status: "draft"
         });
@@ -2901,7 +2953,7 @@ const service = ({ strapi }) => {
     // 🖼️ Generate Image for Article
     // ───────────────────────────────
     async generateImageForArticle(ctx) {
-      const { articleId, imageInstructions } = ctx.request.body;
+      const { articleId } = ctx.request.body;
       if (!articleId) {
         throw new Error(
           "Se requiere 'articleId' en el cuerpo de la petición."
@@ -2911,66 +2963,59 @@ const service = ({ strapi }) => {
         const article = await strapi.documents("api::articulo.articulo").findOne({
           documentId: articleId
         });
-        const reference_1 = await imageUrlToBase64(
-          "https://api.interware.com.mx/static/images/event.png"
-        );
-        const reference_2 = await imageUrlToBase64(
-          "https://api.interware.com.mx/static/images/info_data.png"
-        );
-        const reference_3 = await imageUrlToBase64(
-          "https://api.interware.com.mx/static/images/Oportunidad_IWRobot.png"
-        );
         const prompt = [
           {
             text: `
-              Ilustración digital editorial para blog 1920x1080.
+              Act as a Corporate Art Director for "InterWare". Generate a high-quality blog header image based on the following article context:
+
+              Article Title: ${article.titulo}
+              Article Summary: ${article.descripcion}
+
+              Creative Direction (Auto-interpret):
+              Analyze the summary above to determine the visual category:
+
+              1. **Technical Topic (Software, Cloud, Data, Security):**
+
+                **CRITICAL:** Do NOT generate a central "atom", "sphere", or "floating ball" structure. Avoid the generic "connected dots" cliché.
+                If the topic is **TECHNICAL (Software, Data, Cloud)**, you must break the repetitive visual pattern.
 
-              REGLA CRÍTICA:
-              La imagen NO debe contener texto de ningún tipo.
-              No incluir palabras, letras, números, tipografía, símbolos tipográficos, rótulos, títulos,
-              ni elementos gráficos que simulen texto.
+                **STRICT PROHIBITION:** Do NOT generate the standard "isometric cluster of glass cubes" or "floating square blocks".
 
-              Estilo:
-              Estilo contemporáneo, corporativo y atemporal.
-              Estética limpia, profesional y coherente.
-              Lenguaje visual sobrio, tecnológico y confiable.
+                Instead, strictly choose ONE of the following distinct visual approaches based on the nuance of the text:
 
-              Paleta de colores:
-              Extraer exclusivamente la paleta cromática principal de las imagenes de referencia.
-              Si vas a usar la ilustración del robot, no cambies ni estilo ni forma.
-              No introducir colores nuevos.
+                *   **OPTION A: "The Stream" (Speed & Flow)**
+                    *   *Visuals:* Long-exposure light trails, fiber optic cables, or liquid data streams moving horizontally.
+                    *   *Camera:* **Side profile or Worm's-eye view**.
+                    *   *Vibe:* Fast, motion-blurred, linear. No cubes.
 
-              Iluminación uniforme y suave.
-              Diseño plano con ligera profundidad.
-              Estilo vectorial semi-realista, no fotográfico, no 3D.
-              Fondo minimalista.
+                *   **OPTION B: "Macro Precision" (Code & Detail)**
+                    *   *Visuals:* Extreme close-up of a single abstract circuit line, a glass edge refraction, or a micro-texture.
+                    *   *Camera:* **Macro lens (f/1.8)** with heavy bokeh.
+                    *   *Vibe:* Minimalist, sharp focus on one detail, blurry background. Abstract.
 
-              Concepto visual a representar:
-              Interpretar visualmente el siguiente tema de forma simbólica y abstracta,
-              usando metáforas gráficas y elementos visuales, SIN TEXTO:
-              ${article.titulo} — ${article.descripcion}
+                *   **OPTION C: "The Network" (Connectivity)**
+                    *   *Visuals:* A vast, flat constellation of small glowing nodes connected by thin lines (plexus effect).
+                    *   *Camera:* **Top-down satellite view** (90 degrees).
+                    *   *Vibe:* Flat, cartographic, expansive.
 
-              Instrucciones adicionales:
-              ${imageInstructions || "Ninguna"}
+                *   **OPTION D: "Abstract Architecture" (Structure)**
+                    *   *Visuals:* Large, towering monoliths (not small cubes) or massive server rack silhouettes fading into fog.
+                    *   *Camera:* **Low angle looking up** (implying scale).
+                    *   *Vibe:* Monumental, heavy, stable.
+
+              2. **Human/Business Topic (Culture, Leadership, Agile, Management):
+                  Create a cinematic photography scene with a randomized composition and moment in time.
+                  Show modern professionals in a clean, contemporary office environment, captured from varying perspectives (back view, side angles, or softly blurred faces to maintain anonymity).
+                  Vary the number of people, their posture and interaction, the lighting conditions, depth of field, and color grading in each generation.
+                  Use natural, candid collaboration moments rather than posed scenes. The result should fe.
+
+                  Brand Identity Guidelines (STRICT):
+                  - **Primary Background:** Deep Corporate Navy Blue (Hex: #1F2A44). The image must feel predominantly dark blue.
+                  - **Accent Color:** Vibrant Red (Hex: #E4002B). Use sparingly for a single focal point (e.g., a dot, a notebook, a graphical node).
+                  - **Tech Glow:** Mint Turquoise (Hex: #00C7B1). Use for subtle lighting edges or digital gradients.
+                  - **Composition:** Asymmetrical balance. Leave **empty negative space on the RIGHT side** specifically for text overlay.
+                  - **Prohibition:** Do NOT generate text inside the image. Do NOT use pure black shadows; use the Navy Blue.
             `
-          },
-          {
-            inlineData: {
-              mimeType: "image/png",
-              data: reference_1
-            }
-          },
-          {
-            inlineData: {
-              mimeType: "image/png",
-              data: reference_2
-            }
-          },
-          {
-            inlineData: {
-              mimeType: "image/png",
-              data: reference_3
-            }
           }
         ];
         const ai = await this.geminiConfig();
@@ -2995,12 +3040,43 @@ const service = ({ strapi }) => {
           throw new Error("No se encontró ninguna imagen en la respuesta del modelo");
         }
         const buffer = Buffer.from(imagePart.inlineData.data, "base64");
+        const existingFolders = await strapi.documents("plugin::upload.folder").findMany({
+          filters: {
+            name: "Generated"
+          }
+        });
+        let folder;
+        let folderPath;
+        if (existingFolders.length === 0) {
+          const folders = await strapi.documents("plugin::upload.folder").findMany(
+            {
+              sort: {
+                pathId: "desc"
+              },
+              limit: 1
+            }
+          );
+          const pathId = Array.isArray(folders) && folders.length > 0 ? folders[0].pathId + 1 : 1;
+          const createdFolder = await strapi.documents("plugin::upload.folder").create({
+            data: {
+              name: "Generated",
+              path: "/generated",
+              pathId
+            }
+          });
+          folder = createdFolder.id;
+          folderPath = createdFolder.path;
+        } else {
+          folder = existingFolders[0].id;
+          folderPath = existingFolders[0].path;
+        }
         const uploadedFiles = await strapi.plugins.upload.services.upload.upload({
           data: {
             fileInfo: {
               name: `article-${articleId}.png`,
               alternativeText: `Imagen para el artículo ${article.titulo}`,
-              caption: `Imagen generada por IA para el artículo ${article.titulo}`
+              caption: `Imagen generada por IA para el artículo ${article.titulo}`,
+              folder
             }
           },
           files: {
@@ -3028,6 +3104,7 @@ const service = ({ strapi }) => {
           image: uploadedFiles[0]
         };
       } catch (err) {
+        console.log("🚀 ~ service ~ err:", err);
         throw new Error("Error al generar la imagen para el artículo.");
       }
     },
@@ -3058,13 +3135,15 @@ const service = ({ strapi }) => {
       try {
         const article = await strapi.documents("api::articulo.articulo").findOne({
           documentId: articleId,
-          populate: {
-            image: true
-          }
+          populate: ["image", "keywords"]
         });
         if (!article) {
           throw new Error(`Artículo con ID ${articleId} no encontrado.`);
         }
+        const hashtags = article.keywords.map(
+          (k) => `#${k.trim().replace(/\s+/g, "").replace(/[^\w]/g, "")}`
+          // limpia caracteres raros
+        ).join(" ");
         const postBody = {
           author: `urn:li:organization:${linkedInOrganizationId}`,
           lifecycleState: "PUBLISHED",
@@ -3073,10 +3152,26 @@ const service = ({ strapi }) => {
               shareCommentary: {
                 text: `${article.titulo}
 
-${article.descripcion}`
+${article.descripcion}
+
+${hashtags}`
               },
               shareMediaCategory: "ARTICLE",
               media: [
+                // Imagen del artículo
+                ...article.image ? [
+                  {
+                    status: "READY",
+                    description: {
+                      text: article.descripcion
+                    },
+                    media: `https://api.interware.com.mx${article.image.formats.small.url}`,
+                    title: {
+                      text: article.titulo
+                    }
+                  }
+                ] : [],
+                // URL del artículo
                 {
                   status: "READY",
                   originalUrl: `https://interware.com.mx/blog/${article.slug}`,
@@ -3116,6 +3211,7 @@ ${article.descripcion}`
           message: "Publicado en LinkedIn correctamente.",
           linkedinResponse: response.data
         };
+        return true;
       } catch (error) {
         console.error(
           "Error al publicar en LinkedIn:",
@@ -3126,8 +3222,74 @@ ${article.descripcion}`
     },
     async publishToFacebook(ctx) {
       const { articleId } = ctx.request.body;
-      console.log("Publishing to Facebook (not implemented):", articleId);
-      return { message: "Publicación en Facebook no implementada aún." };
+      const pluginStore = strapi.store({
+        type: "plugin",
+        name: "strapi-content-generator-gemini"
+      });
+      const facebookAccessToken = await pluginStore.get({ key: "FACEBOOK_CLIENT_TOKEN" });
+      const facebookPageId = await pluginStore.get({ key: "FACEBOOK_PAGE_ID" });
+      if (!articleId) {
+        throw new Error("Se requiere 'articleId' en el cuerpo de la petición.");
+      }
+      if (!facebookAccessToken) {
+        throw new Error(
+          "La variable de entorno FACEBOOK_CLIENT_TOKEN no está configurada."
+        );
+      }
+      if (!facebookPageId) {
+        throw new Error(
+          "La variable de entorno FACEBOOK_PAGE_ID no está configurada."
+        );
+      }
+      try {
+        const article = await strapi.documents("api::articulo.articulo").findOne({
+          documentId: articleId,
+          populate: ["keywords"]
+        });
+        if (!article) {
+          throw new Error(`Artículo con ID ${articleId} no encontrado.`);
+        }
+        const articleUrl = `https://interware.com.mx/blog/${article.slug}`;
+        const hashtags = article.keywords.map(
+          (keyword) => `#${keyword.trim().replace(/\s+/g, "").replace(/[^\w]/g, "")}`
+          // quita caracteres raros
+        ).join(" ");
+        const postBody = {
+          message: `${article.titulo}
+
+${article.descripcion}
+
+${hashtags}`,
+          link: articleUrl,
+          access_token: facebookAccessToken
+        };
+        const response = await axios.post(
+          `https://graph.facebook.com/v24.0/${facebookPageId}/feed`,
+          postBody,
+          {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          }
+        );
+        strapi.log.info("Successfully published to Facebook:", JSON.stringify(response.data));
+        await strapi.documents("api::articulo.articulo").update({
+          documentId: articleId,
+          data: {
+            facebookPostId: response.data.id
+          }
+        });
+        return {
+          message: "Publicado en Facebook correctamente.",
+          facebookResponse: response.data
+        };
+      } catch (error) {
+        console.error(
+          "Error al publicar en Facebook:",
+          error.response ? error.response.data : error.message
+        );
+        throw new Error("Error al publicar en Facebook.");
+      }
     }
   };
 };