initial commit

Maf-Egypt-Backend/.env.example

+HOST=0.0.0.0
+PORT=1337
+APP_KEYS="toBeModified1,toBeModified2"
+API_TOKEN_SALT=tobemodified
+ADMIN_JWT_SECRET=tobemodified
+TRANSFER_TOKEN_SALT=tobemodified
+JWT_SECRET=tobemodified

Maf-Egypt-Backend/.gitignore

+############################
+# OS X
+############################
+
+.DS_Store
+.AppleDouble
+.LSOverride
+Icon
+.Spotlight-V100
+.Trashes
+._*
+
+
+############################
+# Linux
+############################
+
+*~
+
+
+############################
+# Windows
+############################
+
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+$RECYCLE.BIN/
+*.cab
+*.msi
+*.msm
+*.msp
+
+
+############################
+# Packages
+############################
+
+*.7z
+*.csv
+*.dat
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.seed
+*.so
+*.swo
+*.swp
+*.swn
+*.swm
+*.out
+*.pid
+
+
+############################
+# Logs and databases
+############################
+
+.tmp
+*.log
+*.sql
+*.sqlite
+*.sqlite3
+
+
+############################
+# Misc.
+############################
+
+*#
+ssl
+.idea
+nbproject
+public/uploads/*
+!public/uploads/.gitkeep
+.tsbuildinfo
+.eslintcache
+
+############################
+# Node.js
+############################
+
+lib-cov
+lcov.info
+pids
+logs
+results
+node_modules
+.node_history
+
+############################
+# Package managers
+############################
+
+.yarn/*
+!.yarn/cache
+!.yarn/unplugged
+!.yarn/patches
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+.pnp.*
+yarn-error.log
+
+############################
+# Tests
+############################
+
+coverage
+
+############################
+# Strapi
+############################
+
+.env
+license.txt
+exports
+.strapi
+dist
+build
+.strapi-updater.json
+.strapi-cloud.json
\ No newline at end of file

Maf-Egypt-Backend/README.md

+# 🚀 Getting started with Strapi
+
+Strapi comes with a full featured [Command Line Interface](https://docs.strapi.io/dev-docs/cli) (CLI) which lets you scaffold and manage your project in seconds.
+
+### `develop`
+
+Start your Strapi application with autoReload enabled. [Learn more](https://docs.strapi.io/dev-docs/cli#strapi-develop)
+
+```
+npm run develop
+# or
+yarn develop
+```
+
+### `start`
+
+Start your Strapi application with autoReload disabled. [Learn more](https://docs.strapi.io/dev-docs/cli#strapi-start)
+
+```
+npm run start
+# or
+yarn start
+```
+
+### `build`
+
+Build your admin panel. [Learn more](https://docs.strapi.io/dev-docs/cli#strapi-build)
+
+```
+npm run build
+# or
+yarn build
+```
+
+## ⚙️ Deployment
+
+Strapi gives you many possible deployment options for your project including [Strapi Cloud](https://cloud.strapi.io). Browse the [deployment section of the documentation](https://docs.strapi.io/dev-docs/deployment) to find the best solution for your use case.
+
+```
+yarn strapi deploy
+```
+
+## 📚 Learn more
+
+- [Resource center](https://strapi.io/resource-center) - Strapi resource center.
+- [Strapi documentation](https://docs.strapi.io) - Official Strapi documentation.
+- [Strapi tutorials](https://strapi.io/tutorials) - List of tutorials made by the core team and the community.
+- [Strapi blog](https://strapi.io/blog) - Official Strapi blog containing articles made by the Strapi team and the community.
+- [Changelog](https://strapi.io/changelog) - Find out about the Strapi product updates, new features and general improvements.
+
+Feel free to check out the [Strapi GitHub repository](https://github.com/strapi/strapi). Your feedback and contributions are welcome!
+
+## ✨ Community
+
+- [Discord](https://discord.strapi.io) - Come chat with the Strapi community including the core team.
+- [Forum](https://forum.strapi.io/) - Place to discuss, ask questions and find answers, show your Strapi project and get feedback or just talk with other Community members.
+- [Awesome Strapi](https://github.com/strapi/awesome-strapi) - A curated list of awesome things related to Strapi.
+
+---
+
+<sub>🤫 Psst! [Strapi is hiring](https://strapi.io/careers).</sub>

Maf-Egypt-Backend/config/admin.ts

+export default ({ env }) => ({
+  auth: {
+    secret: env('ADMIN_JWT_SECRET'),
+  },
+  apiToken: {
+    salt: env('API_TOKEN_SALT'),
+  },
+  transfer: {
+    token: {
+      salt: env('TRANSFER_TOKEN_SALT'),
+    },
+  },
+  flags: {
+    nps: env.bool('FLAG_NPS', true),
+    promoteEE: env.bool('FLAG_PROMOTE_EE', true),
+  },
+});

Maf-Egypt-Backend/config/api.ts

+export default {
+  rest: {
+    defaultLimit: 25,
+    maxLimit: 100,
+    withCount: true,
+  },
+};

Maf-Egypt-Backend/config/database.ts

+import path from 'path';
+
+export default ({ env }) => {
+  const client = env('DATABASE_CLIENT', 'sqlite');
+
+  const connections = {
+    mysql: {
+      connection: {
+        host: env('DATABASE_HOST', 'localhost'),
+        port: env.int('DATABASE_PORT', 3306),
+        database: env('DATABASE_NAME', 'strapi'),
+        user: env('DATABASE_USERNAME', 'strapi'),
+        password: env('DATABASE_PASSWORD', 'strapi'),
+        ssl: env.bool('DATABASE_SSL', false) && {
+          key: env('DATABASE_SSL_KEY', undefined),
+          cert: env('DATABASE_SSL_CERT', undefined),
+          ca: env('DATABASE_SSL_CA', undefined),
+          capath: env('DATABASE_SSL_CAPATH', undefined),
+          cipher: env('DATABASE_SSL_CIPHER', undefined),
+          rejectUnauthorized: env.bool('DATABASE_SSL_REJECT_UNAUTHORIZED', true),
+        },
+      },
+      pool: { min: env.int('DATABASE_POOL_MIN', 2), max: env.int('DATABASE_POOL_MAX', 10) },
+    },
+    postgres: {
+      connection: {
+        connectionString: env('DATABASE_URL'),
+        host: env('DATABASE_HOST', 'localhost'),
+        port: env.int('DATABASE_PORT', 5432),
+        database: env('DATABASE_NAME', 'strapi'),
+        user: env('DATABASE_USERNAME', 'strapi'),
+        password: env('DATABASE_PASSWORD', 'strapi'),
+        ssl: env.bool('DATABASE_SSL', false) && {
+          key: env('DATABASE_SSL_KEY', undefined),
+          cert: env('DATABASE_SSL_CERT', undefined),
+          ca: env('DATABASE_SSL_CA', undefined),
+          capath: env('DATABASE_SSL_CAPATH', undefined),
+          cipher: env('DATABASE_SSL_CIPHER', undefined),
+          rejectUnauthorized: env.bool('DATABASE_SSL_REJECT_UNAUTHORIZED', true),
+        },
+        schema: env('DATABASE_SCHEMA', 'public'),
+      },
+      pool: { min: env.int('DATABASE_POOL_MIN', 2), max: env.int('DATABASE_POOL_MAX', 10) },
+    },
+    sqlite: {
+      connection: {
+        filename: path.join(__dirname, '..', '..', env('DATABASE_FILENAME', '.tmp/data.db')),
+      },
+      useNullAsDefault: true,
+    },
+  };
+
+  return {
+    connection: {
+      client,
+      ...connections[client],
+      acquireConnectionTimeout: env.int('DATABASE_CONNECTION_TIMEOUT', 60000),
+    },
+  };
+};

Maf-Egypt-Backend/config/middlewares.ts

+export default [
+  'strapi::logger',
+  'strapi::errors',
+  'strapi::security',
+  'strapi::cors',
+  'strapi::poweredBy',
+  'strapi::query',
+  'strapi::body',
+  'strapi::session',
+  'strapi::favicon',
+  'strapi::public',
+];

Maf-Egypt-Backend/config/plugins.ts

+module.exports = {
+  'populate-deep': {
+    config: {
+      defaultDepth: 5,  // You can set this to your desired default depth
+    },
+  },
+};
\ No newline at end of file

Maf-Egypt-Backend/config/server.ts

+export default ({ env }) => ({
+  host: env('HOST', '0.0.0.0'),
+  port: env.int('PORT', 1337),
+  app: {
+    keys: env.array('APP_KEYS'),
+  },
+});

Maf-Egypt-Backend/package.json

+{
+  "name": "test-strapi-cms",
+  "version": "0.1.0",
+  "private": true,
+  "description": "A Strapi application",
+  "scripts": {
+    "build": "strapi build",
+    "console": "strapi console",
+    "deploy": "strapi deploy",
+    "dev": "strapi develop",
+    "develop": "strapi develop",
+    "seed:example": "node ./scripts/seed.js",
+    "start": "strapi start",
+    "strapi": "strapi",
+    "upgrade": "npx @strapi/upgrade latest",
+    "upgrade:dry": "npx @strapi/upgrade latest --dry"
+  },
+  "dependencies": {
+    "@strapi/plugin-cloud": "5.12.6",
+    "@strapi/plugin-users-permissions": "5.12.6",
+    "@strapi/strapi": "5.12.6",
+    "better-sqlite3": "11.3.0",
+    "fs-extra": "^10.0.0",
+    "mime-types": "^2.1.27",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "react-router-dom": "^6.0.0",
+    "strapi-plugin-config-sync": "^3.1.1",
+    "strapi-plugin-populate-deep": "^3.0.1",
+    "styled-components": "^6.0.0",
+    "yarn": "^1.22.22"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@types/react": "^18",
+    "@types/react-dom": "^18",
+    "typescript": "^5"
+  },
+  "engines": {
+    "node": ">=18.0.0 <=22.x.x",
+    "npm": ">=6.0.0"
+  },
+  "strapi": {
+    "uuid": "f87e7d7a-de26-494a-9029-f121edc534a0"
+  }
+}

Maf-Egypt-Backend/public/robots.txt

+# To prevent search engines from seeing the site altogether, uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

Maf-Egypt-Backend/scripts/seed.js

+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const mime = require('mime-types');
+const { categories, authors, articles, global, about } = require('../data/data.json');
+
+async function seedExampleApp() {
+  const shouldImportSeedData = await isFirstRun();
+
+  if (shouldImportSeedData) {
+    try {
+      console.log('Setting up the template...');
+      await importSeedData();
+      console.log('Ready to go');
+    } catch (error) {
+      console.log('Could not import seed data');
+      console.error(error);
+    }
+  } else {
+    console.log(
+      'Seed data has already been imported. We cannot reimport unless you clear your database first.'
+    );
+  }
+}
+
+async function isFirstRun() {
+  const pluginStore = strapi.store({
+    environment: strapi.config.environment,
+    type: 'type',
+    name: 'setup',
+  });
+  const initHasRun = await pluginStore.get({ key: 'initHasRun' });
+  await pluginStore.set({ key: 'initHasRun', value: true });
+  return !initHasRun;
+}
+
+async function setPublicPermissions(newPermissions) {
+  // Find the ID of the public role
+  const publicRole = await strapi.query('plugin::users-permissions.role').findOne({
+    where: {
+      type: 'public',
+    },
+  });
+
+  // Create the new permissions and link them to the public role
+  const allPermissionsToCreate = [];
+  Object.keys(newPermissions).map((controller) => {
+    const actions = newPermissions[controller];
+    const permissionsToCreate = actions.map((action) => {
+      return strapi.query('plugin::users-permissions.permission').create({
+        data: {
+          action: `api::${controller}.${controller}.${action}`,
+          role: publicRole.id,
+        },
+      });
+    });
+    allPermissionsToCreate.push(...permissionsToCreate);
+  });
+  await Promise.all(allPermissionsToCreate);
+}
+
+function getFileSizeInBytes(filePath) {
+  const stats = fs.statSync(filePath);
+  const fileSizeInBytes = stats['size'];
+  return fileSizeInBytes;
+}
+
+function getFileData(fileName) {
+  const filePath = path.join('data', 'uploads', fileName);
+  // Parse the file metadata
+  const size = getFileSizeInBytes(filePath);
+  const ext = fileName.split('.').pop();
+  const mimeType = mime.lookup(ext || '') || '';
+
+  return {
+    filepath: filePath,
+    originalFileName: fileName,
+    size,
+    mimetype: mimeType,
+  };
+}
+
+async function uploadFile(file, name) {
+  return strapi
+    .plugin('upload')
+    .service('upload')
+    .upload({
+      files: file,
+      data: {
+        fileInfo: {
+          alternativeText: `An image uploaded to Strapi called ${name}`,
+          caption: name,
+          name,
+        },
+      },
+    });
+}
+
+// Create an entry and attach files if there are any
+async function createEntry({ model, entry }) {
+  try {
+    // Actually create the entry in Strapi
+    await strapi.documents(`api::${model}.${model}`).create({
+      data: entry,
+    });
+  } catch (error) {
+    console.error({ model, entry, error });
+  }
+}
+
+async function checkFileExistsBeforeUpload(files) {
+  const existingFiles = [];
+  const uploadedFiles = [];
+  const filesCopy = [...files];
+
+  for (const fileName of filesCopy) {
+    // Check if the file already exists in Strapi
+    const fileWhereName = await strapi.query('plugin::upload.file').findOne({
+      where: {
+        name: fileName.replace(/\..*$/, ''),
+      },
+    });
+
+    if (fileWhereName) {
+      // File exists, don't upload it
+      existingFiles.push(fileWhereName);
+    } else {
+      // File doesn't exist, upload it
+      const fileData = getFileData(fileName);
+      const fileNameNoExtension = fileName.split('.').shift();
+      const [file] = await uploadFile(fileData, fileNameNoExtension);
+      uploadedFiles.push(file);
+    }
+  }
+  const allFiles = [...existingFiles, ...uploadedFiles];
+  // If only one file then return only that file
+  return allFiles.length === 1 ? allFiles[0] : allFiles;
+}
+
+async function updateBlocks(blocks) {
+  const updatedBlocks = [];
+  for (const block of blocks) {
+    if (block.__component === 'shared.media') {
+      const uploadedFiles = await checkFileExistsBeforeUpload([block.file]);
+      // Copy the block to not mutate directly
+      const blockCopy = { ...block };
+      // Replace the file name on the block with the actual file
+      blockCopy.file = uploadedFiles;
+      updatedBlocks.push(blockCopy);
+    } else if (block.__component === 'shared.slider') {
+      // Get files already uploaded to Strapi or upload new files
+      const existingAndUploadedFiles = await checkFileExistsBeforeUpload(block.files);
+      // Copy the block to not mutate directly
+      const blockCopy = { ...block };
+      // Replace the file names on the block with the actual files
+      blockCopy.files = existingAndUploadedFiles;
+      // Push the updated block
+      updatedBlocks.push(blockCopy);
+    } else {
+      // Just push the block as is
+      updatedBlocks.push(block);
+    }
+  }
+
+  return updatedBlocks;
+}
+
+async function importArticles() {
+  for (const article of articles) {
+    const cover = await checkFileExistsBeforeUpload([`${article.slug}.jpg`]);
+    const updatedBlocks = await updateBlocks(article.blocks);
+
+    await createEntry({
+      model: 'article',
+      entry: {
+        ...article,
+        cover,
+        blocks: updatedBlocks,
+        // Make sure it's not a draft
+        publishedAt: Date.now(),
+      },
+    });
+  }
+}
+
+async function importGlobal() {
+  const favicon = await checkFileExistsBeforeUpload(['favicon.png']);
+  const shareImage = await checkFileExistsBeforeUpload(['default-image.png']);
+  return createEntry({
+    model: 'global',
+    entry: {
+      ...global,
+      favicon,
+      // Make sure it's not a draft
+      publishedAt: Date.now(),
+      defaultSeo: {
+        ...global.defaultSeo,
+        shareImage,
+      },
+    },
+  });
+}
+
+async function importAbout() {
+  const updatedBlocks = await updateBlocks(about.blocks);
+
+  await createEntry({
+    model: 'about',
+    entry: {
+      ...about,
+      blocks: updatedBlocks,
+      // Make sure it's not a draft
+      publishedAt: Date.now(),
+    },
+  });
+}
+
+async function importCategories() {
+  for (const category of categories) {
+    await createEntry({ model: 'category', entry: category });
+  }
+}
+
+async function importAuthors() {
+  for (const author of authors) {
+    const avatar = await checkFileExistsBeforeUpload([author.avatar]);
+
+    await createEntry({
+      model: 'author',
+      entry: {
+        ...author,
+        avatar,
+      },
+    });
+  }
+}
+
+async function importSeedData() {
+  // Allow read of application content types
+  await setPublicPermissions({
+    article: ['find', 'findOne'],
+    category: ['find', 'findOne'],
+    author: ['find', 'findOne'],
+    global: ['find', 'findOne'],
+    about: ['find', 'findOne'],
+  });
+
+  // Create all entries
+  await importCategories();
+  await importAuthors();
+  await importArticles();
+  await importGlobal();
+  await importAbout();
+}
+
+async function main() {
+  const { createStrapi, compileStrapi } = require('@strapi/strapi');
+
+  const appContext = await compileStrapi();
+  const app = await createStrapi(appContext).load();
+
+  app.log.level = 'error';
+
+  await seedExampleApp();
+  await app.destroy();
+
+  process.exit(0);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

Maf-Egypt-Backend/src/admin/app.example.tsx

+import type { StrapiApp } from '@strapi/strapi/admin';
+
+export default {
+  config: {
+    locales: [
+      // 'ar',
+      // 'fr',
+      // 'cs',
+      // 'de',
+      // 'dk',
+      // 'es',
+      // 'he',
+      // 'id',
+      // 'it',
+      // 'ja',
+      // 'ko',
+      // 'ms',
+      // 'nl',
+      // 'no',
+      // 'pl',
+      // 'pt-BR',
+      // 'pt',
+      // 'ru',
+      // 'sk',
+      // 'sv',
+      // 'th',
+      // 'tr',
+      // 'uk',
+      // 'vi',
+      // 'zh-Hans',
+      // 'zh',
+    ],
+  },
+  bootstrap(app: StrapiApp) {
+    console.log(app);
+  },
+};

Maf-Egypt-Backend/src/admin/tsconfig.json

+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "useDefineForClassFields": true,
+    "lib": ["DOM", "DOM.Iterable", "ESNext"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "jsx": "react-jsx"
+  },
+  "include": ["../plugins/**/admin/src/**/*", "./"],
+  "exclude": ["node_modules/", "build/", "dist/", "**/*.test.ts"]
+}

Maf-Egypt-Backend/src/admin/vite.config.example.ts

+import { mergeConfig, type UserConfig } from 'vite';
+
+export default (config: UserConfig) => {
+  // Important: always return the modified config
+  return mergeConfig(config, {
+    resolve: {
+      alias: {
+        '@': '/src',
+      },
+    },
+  });
+};

Maf-Egypt-Backend/src/api/contact/content-types/contact/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "contacts",
+  "info": {
+    "singularName": "contact",
+    "pluralName": "contacts",
+    "displayName": "Contact",
+    "description": ""
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "attributes": {
+    "title": {
+      "type": "string"
+    },
+    "firstName": {
+      "type": "string"
+    },
+    "lastName": {
+      "type": "string"
+    },
+    "email": {
+      "type": "email",
+      "unique": true
+    },
+    "mobileNumber": {
+      "type": "string"
+    },
+    "countryCode": {
+      "type": "string"
+    },
+    "countryOfResidence": {
+      "type": "string"
+    },
+    "propertyType": {
+      "type": "string"
+    },
+    "unitSize": {
+      "type": "string"
+    },
+    "budget": {
+      "type": "string"
+    },
+    "terms": {
+      "type": "boolean",
+      "default": false
+    },
+    "buyingPurpose": {
+      "type": "string"
+    },
+    "recaptchaToken": {
+      "type": "string"
+    },
+    "middleName": {
+      "type": "string"
+    },
+    "source": {
+      "type": "string",
+      "default": "WebToLead"
+    },
+    "channelType": {
+      "type": "string",
+      "default": "WebToLead"
+    },
+    "channelName": {
+      "type": "string"
+    },
+    "project": {
+      "type": "string",
+      "default": "JN"
+    },
+    "companyName": {
+      "type": "string"
+    },
+    "formName": {
+      "type": "string"
+    }
+  }
+}

Maf-Egypt-Backend/src/api/contact/controllers/contact.ts

+/**
+ * contact controller
+ */
+
+import { factories } from '@strapi/strapi'
+
+export default factories.createCoreController('api::contact.contact');

Maf-Egypt-Backend/src/api/contact/routes/contact.ts

+/**
+ * contact router
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreRouter('api::contact.contact');

Maf-Egypt-Backend/src/api/contact/services/contact.ts

+/**
+ * contact service
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreService('api::contact.contact');

Maf-Egypt-Backend/src/api/global/content-types/global/schema.json

+{
+  "kind": "singleType",
+  "collectionName": "globals",
+  "info": {
+    "singularName": "global",
+    "pluralName": "globals",
+    "displayName": "Global",
+    "description": "Define global settings"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "siteName": {
+      "type": "string",
+      "required": true
+    },
+    "favicon": {
+      "type": "media",
+      "multiple": false,
+      "required": false,
+      "allowedTypes": [
+        "images",
+        "files",
+        "videos"
+      ]
+    },
+    "siteDescription": {
+      "type": "text",
+      "required": true
+    }
+  }
+}

Maf-Egypt-Backend/src/api/global/controllers/global.ts

+/**
+ *  global controller
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreController('api::global.global');

Maf-Egypt-Backend/src/api/global/routes/global.ts

+/**
+ * global router.
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreRouter('api::global.global');

Maf-Egypt-Backend/src/api/global/services/global.ts

+/**
+ * global service.
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreService('api::global.global');

Maf-Egypt-Backend/src/api/header/content-types/header/schema.json

+{
+  "kind": "singleType",
+  "collectionName": "headers",
+  "info": {
+    "singularName": "header",
+    "pluralName": "headers",
+    "displayName": "Header",
+    "description": ""
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "attributes": {
+    "button": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.links"
+    }
+  }
+}

Maf-Egypt-Backend/src/api/header/controllers/header.ts

+/**
+ * header controller
+ */
+
+import { factories } from '@strapi/strapi'
+
+export default factories.createCoreController('api::header.header');

Maf-Egypt-Backend/src/api/header/routes/header.ts

+/**
+ * header router
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreRouter('api::header.header');

Maf-Egypt-Backend/src/api/header/services/header.ts

+/**
+ * header service
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreService('api::header.header');

Maf-Egypt-Backend/src/api/page/content-types/page/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "pages",
+  "info": {
+    "singularName": "page",
+    "pluralName": "pages",
+    "displayName": "Page",
+    "description": ""
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "attributes": {
+    "components": {
+      "type": "dynamiczone",
+      "components": [
+        "banner.banner",
+        "amenities.amenities",
+        "image-carousel.image-carousel",
+        "gallery.gallery",
+        "master-plan.master-plan",
+        "address-map.address-map",
+        "contact.contact"
+      ]
+    },
+    "slug": {
+      "type": "string",
+      "required": true
+    }
+  }
+}

Maf-Egypt-Backend/src/api/page/controllers/page.ts

+'use strict';
+
+/**
+ * page controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::page.page', ({ strapi }) => ({
+    async find(ctx) {
+        const { data, meta } = await super.find(ctx);
+        const modifiedData = data.map(entry => {
+            const components = Array.isArray(entry === null || entry === void 0 ? void 0 : entry.components)
+                ? entry.components.map(component => {
+                    var _a;
+                    const { __component, ...rest } = component;
+                    const componentName = (_a = __component === null || __component === void 0 ? void 0 : __component.split) === null || _a === void 0 ? void 0 : _a.call(__component, '.')[1];
+                    return {
+                        component: componentName,
+                        ...rest,
+                    };
+                })
+                : [];
+            return {
+                ...entry,
+                components
+            };
+        });
+        return { data: modifiedData, meta };
+    }
+}));
+

Maf-Egypt-Backend/src/api/page/routes/page.ts

+/**
+ * page router
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreRouter('api::page.page');

Maf-Egypt-Backend/src/api/page/services/page.ts

+/**
+ * page service
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreService('api::page.page');

Maf-Egypt-Backend/src/api/terms-and-condition/content-types/terms-and-condition/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "terms_and_conditions",
+  "info": {
+    "singularName": "terms-and-condition",
+    "pluralName": "terms-and-conditions",
+    "displayName": "TermsAndConditions",
+    "description": ""
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "attributes": {
+    "termsAndConditions": {
+      "type": "richtext"
+    },
+    "slug": {
+      "type": "string"
+    }
+  }
+}

Maf-Egypt-Backend/src/api/terms-and-condition/controllers/terms-and-condition.ts

+/**
+ * terms-and-condition controller
+ */
+
+import { factories } from '@strapi/strapi'
+
+export default factories.createCoreController('api::terms-and-condition.terms-and-condition');

Maf-Egypt-Backend/src/api/terms-and-condition/routes/terms-and-condition.ts

+/**
+ * terms-and-condition router
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreRouter('api::terms-and-condition.terms-and-condition');

Maf-Egypt-Backend/src/api/terms-and-condition/services/terms-and-condition.ts

+/**
+ * terms-and-condition service
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreService('api::terms-and-condition.terms-and-condition');

Maf-Egypt-Backend/src/api/unit-size-option/content-types/unit-size-option/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "unit_size_options",
+  "info": {
+    "singularName": "unit-size-option",
+    "pluralName": "unit-size-options",
+    "displayName": "UnitSizeOptions"
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "attributes": {
+    "unitsizeoptions": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.select"
+    }
+  }
+}

Maf-Egypt-Backend/src/api/unit-size-option/controllers/unit-size-option.ts

+/**
+ * unit-size-option controller
+ */
+
+import { factories } from '@strapi/strapi'
+
+export default factories.createCoreController('api::unit-size-option.unit-size-option');

Maf-Egypt-Backend/src/api/unit-size-option/routes/unit-size-option.ts

+/**
+ * unit-size-option router
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreRouter('api::unit-size-option.unit-size-option');

Maf-Egypt-Backend/src/api/unit-size-option/services/unit-size-option.ts

+/**
+ * unit-size-option service
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreService('api::unit-size-option.unit-size-option');

Maf-Egypt-Backend/src/components/address-map/address-map.json

+{
+  "collectionName": "components_address_map_address_maps",
+  "info": {
+    "displayName": "AddressMap",
+    "description": ""
+  },
+  "options": {},
+  "attributes": {
+    "title": {
+      "type": "string"
+    },
+    "phone": {
+      "type": "string"
+    },
+    "email": {
+      "type": "email",
+      "unique": true,
+      "required": true
+    },
+    "address": {
+      "type": "richtext"
+    },
+    "mapData": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.map"
+    },
+    "button": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.links"
+    },
+    "directionButton": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.links"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/amenities/amenities.json

+{
+  "collectionName": "components_amenities_amenities",
+  "info": {
+    "displayName": "Amenities",
+    "description": ""
+  },
+  "options": {},
+  "attributes": {
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "text"
+    },
+    "image": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.amenities"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/banner/banner.json

+{
+  "collectionName": "components_banner_banners",
+  "info": {
+    "displayName": "Banner",
+    "description": ""
+  },
+  "options": {},
+  "attributes": {
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "text"
+    },
+    "button": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.links"
+    },
+    "specifications": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.specifications"
+    },
+    "labels": {
+      "type": "component",
+      "repeatable": false,
+      "component": "banner.labels"
+    },
+    "image": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.image-set"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/banner/labels.json

+{
+  "collectionName": "components_banner_labels",
+  "info": {
+    "displayName": "labels"
+  },
+  "options": {},
+  "attributes": {
+    "scrollDown": {
+      "type": "string"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/contact/contact.json

+{
+  "collectionName": "components_contact_contact",
+  "info": {
+    "displayName": "Contact",
+    "description": ""
+  },
+  "options": {},
+  "attributes": {
+    "title": {
+      "type": "string"
+    },
+    "footerText": {
+      "type": "text"
+    },
+    "titleOptions": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.select"
+    },
+    "budgetOptions": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.select"
+    },
+    "unitTypeOptions": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.select"
+    },
+    "unitSizeOptions": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.select"
+    },
+    "purposeOptions": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.select"
+    },
+    "labels": {
+      "type": "component",
+      "repeatable": false,
+      "component": "contact.labels"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/contact/labels.json

+{
+  "collectionName": "components_contact_labels",
+  "info": {
+    "displayName": "Labels",
+    "description": ""
+  },
+  "options": {},
+  "attributes": {
+    "title": {
+      "type": "string"
+    },
+    "firstName": {
+      "type": "string"
+    },
+    "lastName": {
+      "type": "string"
+    },
+    "mobile": {
+      "type": "string"
+    },
+    "company": {
+      "type": "string"
+    },
+    "date": {
+      "type": "string"
+    },
+    "session": {
+      "type": "string"
+    },
+    "budget": {
+      "type": "string"
+    },
+    "residence": {
+      "type": "string"
+    },
+    "unitSize": {
+      "type": "string"
+    },
+    "unitType": {
+      "type": "string"
+    },
+    "purpose": {
+      "type": "string"
+    },
+    "terms": {
+      "type": "text"
+    },
+    "clearButtonLabel": {
+      "type": "string"
+    },
+    "submitButtonLabel": {
+      "type": "string"
+    },
+    "errorTitleRequired": {
+      "type": "string"
+    },
+    "errorFirstNameRequired": {
+      "type": "string"
+    },
+    "errorFirstNameInvalid": {
+      "type": "string"
+    },
+    "errorLastNameRequired": {
+      "type": "string"
+    },
+    "errorLastNameInvalid": {
+      "type": "string"
+    },
+    "errorEmailRequired": {
+      "type": "string"
+    },
+    "errorEmailInvalid": {
+      "type": "string"
+    },
+    "errorMobileRequired": {
+      "type": "string"
+    },
+    "errorMobileInvalid": {
+      "type": "string"
+    },
+    "errorCompanyRequired": {
+      "type": "string"
+    },
+    "errorTermsRequired": {
+      "type": "string"
+    },
+    "errorDateRequired": {
+      "type": "string"
+    },
+    "errorSessionRequired": {
+      "type": "string"
+    },
+    "errorPurposeRequired": {
+      "type": "string"
+    },
+    "errorUnitTypeRequired": {
+      "type": "string"
+    },
+    "errorRecaptchaRequired": {
+      "type": "string"
+    },
+    "formSuccessText": {
+      "type": "string"
+    },
+    "formErrorText": {
+      "type": "string"
+    },
+    "email": {
+      "type": "string"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/gallery/gallery.json

+{
+  "collectionName": "components_gallery_galleries",
+  "info": {
+    "displayName": "Gallery",
+    "description": ""
+  },
+  "options": {},
+  "attributes": {
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "text"
+    },
+    "subtitle": {
+      "type": "string"
+    },
+    "gallery": {
+      "displayName": "gallery",
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.gallery"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/image-carousel/image-carousel.json

+{
+  "collectionName": "components_image_carousel_image_carousels",
+  "info": {
+    "displayName": "ImageCarousel"
+  },
+  "options": {},
+  "attributes": {
+    "slides": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.amenities"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/master-plan/master-plan.json

+{
+  "collectionName": "components_master_plan_master_plans",
+  "info": {
+    "displayName": "MasterPlan"
+  },
+  "options": {},
+  "attributes": {
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "text"
+    },
+    "image": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.image-set"
+    },
+    "button": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.links"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/shared/amenities.json

+{
+  "collectionName": "components_shared_amenities",
+  "info": {
+    "displayName": "amenities"
+  },
+  "options": {},
+  "attributes": {
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "text"
+    },
+    "image": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.image-set"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/shared/gallery.json

+{
+  "collectionName": "components_shared_galleries",
+  "info": {
+    "displayName": "gallery"
+  },
+  "options": {},
+  "attributes": {
+    "title": {
+      "type": "string"
+    },
+    "image": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.image-set"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/shared/image-set.json

+{
+  "collectionName": "components_shared_image_sets",
+  "info": {
+    "displayName": "ImageSet",
+    "description": ""
+  },
+  "options": {},
+  "attributes": {
+    "url": {
+      "type": "string"
+    },
+    "width": {
+      "type": "biginteger"
+    },
+    "height": {
+      "type": "biginteger"
+    },
+    "alternativeText": {
+      "type": "string"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/shared/links.json

+{
+  "collectionName": "components_shared_links",
+  "info": {
+    "displayName": "Links"
+  },
+  "options": {},
+  "attributes": {
+    "label": {
+      "type": "string"
+    },
+    "url": {
+      "type": "string"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/shared/map.json

+{
+  "collectionName": "components_shared_maps",
+  "info": {
+    "displayName": "Map",
+    "description": ""
+  },
+  "options": {},
+  "attributes": {
+    "latitude": {
+      "type": "decimal"
+    },
+    "longitude": {
+      "type": "decimal"
+    },
+    "zoom": {
+      "type": "decimal"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/shared/select.json

+{
+  "collectionName": "components_shared_selects",
+  "info": {
+    "displayName": "Select"
+  },
+  "options": {},
+  "attributes": {
+    "label": {
+      "type": "string"
+    },
+    "value": {
+      "type": "string"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/shared/specifications.json

+{
+  "collectionName": "components_shared_specifications",
+  "info": {
+    "displayName": "specifications",
+    "description": ""
+  },
+  "options": {},
+  "attributes": {
+    "label": {
+      "type": "string"
+    },
+    "value": {
+      "type": "string"
+    },
+    "image": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.image-set"
+    }
+  }
+}

Maf-Egypt-Backend/src/components/terms-and-conditions/terms-and-conditions.json

+{
+  "collectionName": "components_terms_and_conditions_terms_and_conditions",
+  "info": {
+    "displayName": "TermsAndConditions"
+  },
+  "options": {},
+  "attributes": {
+    "termsAndConditions": {
+      "type": "richtext"
+    }
+  }
+}

Maf-Egypt-Backend/src/index.ts

+// import type { Core } from '@strapi/strapi';
+
+export default {
+  /**
+   * An asynchronous register function that runs before
+   * your application is initialized.
+   *
+   * This gives you an opportunity to extend code.
+   */
+  register(/* { strapi }: { strapi: Core.Strapi } */) {},
+
+  /**
+   * An asynchronous bootstrap function that runs before
+   * your application gets started.
+   *
+   * This gives you an opportunity to set up your data model,
+   * run jobs, or perform some special logic.
+   */
+  bootstrap(/* { strapi }: { strapi: Core.Strapi } */) {},
+};

Maf-Egypt-Backend/tsconfig.json

+{
+  "compilerOptions": {
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "lib": ["ES2020"],
+    "target": "ES2019",
+    "strict": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "incremental": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "noEmitOnError": true,
+    "noImplicitThis": true,
+    "outDir": "dist",
+    "rootDir": "."
+  },
+  "include": [
+    // Include root files
+    "./",
+    // Include all ts files
+    "./**/*.ts",
+    // Include all js files
+    "./**/*.js",
+    // Force the JSON files in the src folder to be included
+    "src/**/*.json"
+  ],
+
+  "exclude": [
+    "node_modules/",
+    "build/",
+    "dist/",
+    ".cache/",
+    ".tmp/",
+
+    // Do not include admin files in the server compilation
+    "src/admin/",
+    // Do not include test files
+    "**/*.test.*",
+    // Do not include plugins in the server compilation
+    "src/plugins/**"
+  ]
+}

Maf-Egypt-Backend/types/generated/components.d.ts

+import type { Schema, Struct } from '@strapi/strapi';
+
+export interface AddressMapAddressMap extends Struct.ComponentSchema {
+  collectionName: 'components_address_map_address_maps';
+  info: {
+    description: '';
+    displayName: 'AddressMap';
+  };
+  attributes: {
+    address: Schema.Attribute.RichText;
+    button: Schema.Attribute.Component<'shared.links', false>;
+    directionButton: Schema.Attribute.Component<'shared.links', false>;
+    email: Schema.Attribute.Email &
+      Schema.Attribute.Required &
+      Schema.Attribute.Unique;
+    mapData: Schema.Attribute.Component<'shared.map', false>;
+    phone: Schema.Attribute.String;
+    title: Schema.Attribute.String;
+  };
+}
+
+export interface AmenitiesAmenities extends Struct.ComponentSchema {
+  collectionName: 'components_amenities_amenities';
+  info: {
+    description: '';
+    displayName: 'Amenities';
+  };
+  attributes: {
+    description: Schema.Attribute.Text;
+    image: Schema.Attribute.Component<'shared.amenities', true>;
+    title: Schema.Attribute.String;
+  };
+}
+
+export interface BannerBanner extends Struct.ComponentSchema {
+  collectionName: 'components_banner_banners';
+  info: {
+    description: '';
+    displayName: 'Banner';
+  };
+  attributes: {
+    button: Schema.Attribute.Component<'shared.links', false>;
+    description: Schema.Attribute.Text;
+    image: Schema.Attribute.Component<'shared.image-set', false>;
+    labels: Schema.Attribute.Component<'banner.labels', false>;
+    specifications: Schema.Attribute.Component<'shared.specifications', true>;
+    title: Schema.Attribute.String;
+  };
+}
+
+export interface BannerLabels extends Struct.ComponentSchema {
+  collectionName: 'components_banner_labels';
+  info: {
+    displayName: 'labels';
+  };
+  attributes: {
+    scrollDown: Schema.Attribute.String;
+  };
+}
+
+export interface ContactContact extends Struct.ComponentSchema {
+  collectionName: 'components_contact_contact';
+  info: {
+    description: '';
+    displayName: 'Contact';
+  };
+  attributes: {
+    budgetOptions: Schema.Attribute.Component<'shared.select', true>;
+    footerText: Schema.Attribute.Text;
+    labels: Schema.Attribute.Component<'contact.labels', false>;
+    purposeOptions: Schema.Attribute.Component<'shared.select', true>;
+    title: Schema.Attribute.String;
+    titleOptions: Schema.Attribute.Component<'shared.select', true>;
+    unitSizeOptions: Schema.Attribute.Component<'shared.select', true>;
+    unitTypeOptions: Schema.Attribute.Component<'shared.select', true>;
+  };
+}
+
+export interface ContactLabels extends Struct.ComponentSchema {
+  collectionName: 'components_contact_labels';
+  info: {
+    description: '';
+    displayName: 'Labels';
+  };
+  attributes: {
+    budget: Schema.Attribute.String;
+    clearButtonLabel: Schema.Attribute.String;
+    company: Schema.Attribute.String;
+    date: Schema.Attribute.String;
+    email: Schema.Attribute.String;
+    errorCompanyRequired: Schema.Attribute.String;
+    errorDateRequired: Schema.Attribute.String;
+    errorEmailInvalid: Schema.Attribute.String;
+    errorEmailRequired: Schema.Attribute.String;
+    errorFirstNameInvalid: Schema.Attribute.String;
+    errorFirstNameRequired: Schema.Attribute.String;
+    errorLastNameInvalid: Schema.Attribute.String;
+    errorLastNameRequired: Schema.Attribute.String;
+    errorMobileInvalid: Schema.Attribute.String;
+    errorMobileRequired: Schema.Attribute.String;
+    errorPurposeRequired: Schema.Attribute.String;
+    errorRecaptchaRequired: Schema.Attribute.String;
+    errorSessionRequired: Schema.Attribute.String;
+    errorTermsRequired: Schema.Attribute.String;
+    errorTitleRequired: Schema.Attribute.String;
+    errorUnitTypeRequired: Schema.Attribute.String;
+    firstName: Schema.Attribute.String;
+    formErrorText: Schema.Attribute.String;
+    formSuccessText: Schema.Attribute.String;
+    lastName: Schema.Attribute.String;
+    mobile: Schema.Attribute.String;
+    purpose: Schema.Attribute.String;
+    residence: Schema.Attribute.String;
+    session: Schema.Attribute.String;
+    submitButtonLabel: Schema.Attribute.String;
+    terms: Schema.Attribute.Text;
+    title: Schema.Attribute.String;
+    unitSize: Schema.Attribute.String;
+    unitType: Schema.Attribute.String;
+  };
+}
+
+export interface GalleryGallery extends Struct.ComponentSchema {
+  collectionName: 'components_gallery_galleries';
+  info: {
+    description: '';
+    displayName: 'Gallery';
+  };
+  attributes: {
+    description: Schema.Attribute.Text;
+    gallery: Schema.Attribute.Component<'shared.gallery', true>;
+    subtitle: Schema.Attribute.String;
+    title: Schema.Attribute.String;
+  };
+}
+
+export interface ImageCarouselImageCarousel extends Struct.ComponentSchema {
+  collectionName: 'components_image_carousel_image_carousels';
+  info: {
+    displayName: 'ImageCarousel';
+  };
+  attributes: {
+    slides: Schema.Attribute.Component<'shared.amenities', true>;
+  };
+}
+
+export interface MasterPlanMasterPlan extends Struct.ComponentSchema {
+  collectionName: 'components_master_plan_master_plans';
+  info: {
+    displayName: 'MasterPlan';
+  };
+  attributes: {
+    button: Schema.Attribute.Component<'shared.links', false>;
+    description: Schema.Attribute.Text;
+    image: Schema.Attribute.Component<'shared.image-set', false>;
+    title: Schema.Attribute.String;
+  };
+}
+
+export interface SharedAmenities extends Struct.ComponentSchema {
+  collectionName: 'components_shared_amenities';
+  info: {
+    displayName: 'amenities';
+  };
+  attributes: {
+    description: Schema.Attribute.Text;
+    image: Schema.Attribute.Component<'shared.image-set', false>;
+    title: Schema.Attribute.String;
+  };
+}
+
+export interface SharedGallery extends Struct.ComponentSchema {
+  collectionName: 'components_shared_galleries';
+  info: {
+    displayName: 'gallery';
+  };
+  attributes: {
+    image: Schema.Attribute.Component<'shared.image-set', false>;
+    title: Schema.Attribute.String;
+  };
+}
+
+export interface SharedImageSet extends Struct.ComponentSchema {
+  collectionName: 'components_shared_image_sets';
+  info: {
+    description: '';
+    displayName: 'ImageSet';
+  };
+  attributes: {
+    alternativeText: Schema.Attribute.String;
+    height: Schema.Attribute.BigInteger;
+    url: Schema.Attribute.String;
+    width: Schema.Attribute.BigInteger;
+  };
+}
+
+export interface SharedLinks extends Struct.ComponentSchema {
+  collectionName: 'components_shared_links';
+  info: {
+    displayName: 'Links';
+  };
+  attributes: {
+    label: Schema.Attribute.String;
+    url: Schema.Attribute.String;
+  };
+}
+
+export interface SharedMap extends Struct.ComponentSchema {
+  collectionName: 'components_shared_maps';
+  info: {
+    description: '';
+    displayName: 'Map';
+  };
+  attributes: {
+    latitude: Schema.Attribute.Decimal;
+    longitude: Schema.Attribute.Decimal;
+    zoom: Schema.Attribute.Decimal;
+  };
+}
+
+export interface SharedSelect extends Struct.ComponentSchema {
+  collectionName: 'components_shared_selects';
+  info: {
+    displayName: 'Select';
+  };
+  attributes: {
+    label: Schema.Attribute.String;
+    value: Schema.Attribute.String;
+  };
+}
+
+export interface SharedSpecifications extends Struct.ComponentSchema {
+  collectionName: 'components_shared_specifications';
+  info: {
+    description: '';
+    displayName: 'specifications';
+  };
+  attributes: {
+    image: Schema.Attribute.Component<'shared.image-set', false>;
+    label: Schema.Attribute.String;
+    value: Schema.Attribute.String;
+  };
+}
+
+export interface TermsAndConditionsTermsAndConditions
+  extends Struct.ComponentSchema {
+  collectionName: 'components_terms_and_conditions_terms_and_conditions';
+  info: {
+    displayName: 'TermsAndConditions';
+  };
+  attributes: {
+    termsAndConditions: Schema.Attribute.RichText;
+  };
+}
+
+declare module '@strapi/strapi' {
+  export module Public {
+    export interface ComponentSchemas {
+      'address-map.address-map': AddressMapAddressMap;
+      'amenities.amenities': AmenitiesAmenities;
+      'banner.banner': BannerBanner;
+      'banner.labels': BannerLabels;
+      'contact.contact': ContactContact;
+      'contact.labels': ContactLabels;
+      'gallery.gallery': GalleryGallery;
+      'image-carousel.image-carousel': ImageCarouselImageCarousel;
+      'master-plan.master-plan': MasterPlanMasterPlan;
+      'shared.amenities': SharedAmenities;
+      'shared.gallery': SharedGallery;
+      'shared.image-set': SharedImageSet;
+      'shared.links': SharedLinks;
+      'shared.map': SharedMap;
+      'shared.select': SharedSelect;
+      'shared.specifications': SharedSpecifications;
+      'terms-and-conditions.terms-and-conditions': TermsAndConditionsTermsAndConditions;
+    }
+  }
+}