diff --git a/src/printer_yang.c b/src/printer_yang.c
index 4afc83d..7dc0109 100644
--- a/src/printer_yang.c
+++ b/src/printer_yang.c
@@ -2037,6 +2037,10 @@
         ly_print_(ctx->out, "%*s}\n", INDENT);
     }
     LY_ARRAY_FOR(modp->includes, u) {
+        if (modp->includes[u].injected) {
+            /* do not print the includes injected from submodules */
+            continue;
+        }
         if (modp->includes[u].rev[0] || modp->includes[u].dsc || modp->includes[u].ref || modp->includes[u].exts) {
             ly_print_(ctx->out, "%s%*sinclude %s {\n", u ? "" : "\n",  INDENT, modp->includes[u].name);
             LEVEL++;
diff --git a/src/printer_yin.c b/src/printer_yin.c
index 26a9eb6..8926394 100644
--- a/src/printer_yin.c
+++ b/src/printer_yin.c
@@ -1390,6 +1390,10 @@
         ypr_close(ctx, "import", 1);
     }
     LY_ARRAY_FOR(modp->includes, u) {
+        if (modp->includes[u].injected) {
+            /* do not print the includes injected from submodules */
+            continue;
+        }
         if (modp->includes[u].rev[0] || modp->includes[u].dsc || modp->includes[u].ref || modp->includes[u].exts) {
             ypr_open(ctx, "include", "module", modp->includes[u].name, 1);
             LEVEL++;
diff --git a/src/schema_compile.h b/src/schema_compile.h
index 2dcc835..17f8105 100644
--- a/src/schema_compile.h
+++ b/src/schema_compile.h
@@ -115,7 +115,7 @@
  * @param[out] DUP Where to store the result.
  */
 #define DUP_STRING(CTX, ORIG, DUP, RET) if (ORIG) {RET = lydict_insert(CTX, ORIG, 0, &DUP);}
-
+#define DUP_STRING_RET(CTX, ORIG, DUP) if (ORIG) {LY_ERR __ret = lydict_insert(CTX, ORIG, 0, &DUP); LY_CHECK_RET(__ret);}
 #define DUP_STRING_GOTO(CTX, ORIG, DUP, RET, GOTO) if (ORIG) {LY_CHECK_GOTO(RET = lydict_insert(CTX, ORIG, 0, &DUP), GOTO);}
 
 #define DUP_ARRAY(CTX, ORIG_ARRAY, NEW_ARRAY, DUP_FUNC) \
diff --git a/src/tree_schema.c b/src/tree_schema.c
index 2935a67..324f3f2 100644
--- a/src/tree_schema.c
+++ b/src/tree_schema.c
@@ -751,7 +751,6 @@
 lys_resolve_import_include(struct lys_parser_ctx *pctx, struct lysp_module *pmod)
 {
     struct lysp_import *imp;
-    struct lysp_include *inc;
     LY_ARRAY_COUNT_TYPE u, v;
 
     pmod->parsing = 1;
@@ -768,12 +767,8 @@
             }
         }
     }
-    LY_ARRAY_FOR(pmod->includes, u) {
-        inc = &pmod->includes[u];
-        if (!inc->submodule) {
-            LY_CHECK_RET(lysp_load_submodule(pctx, inc));
-        }
-    }
+    LY_CHECK_RET(lysp_load_submodules(pctx, pmod));
+
     pmod->parsing = 0;
 
     return LY_SUCCESS;
diff --git a/src/tree_schema.h b/src/tree_schema.h
index 418944a..51312ef 100644
--- a/src/tree_schema.h
+++ b/src/tree_schema.h
@@ -462,6 +462,9 @@
     const char *ref;                 /**< reference */
     struct lysp_ext_instance *exts;  /**< list of the extension instances ([sized array](@ref sizedarrays)) */
     char rev[LY_REV_SIZE];           /**< revision-date of the included submodule */
+    ly_bool injected;                /**< flag to mark includes copied into main module from submodules,
+                                          only for backward compatibility with YANG 1.0, which does not require the
+                                          main module to include all submodules. */
 };
 
 /**
diff --git a/src/tree_schema_free.c b/src/tree_schema_free.c
index dbb2d11..0098040 100644
--- a/src/tree_schema_free.c
+++ b/src/tree_schema_free.c
@@ -69,10 +69,22 @@
     FREE_ARRAY(ctx, import->exts, lysp_ext_instance_free);
 }
 
-void
-lysp_include_free(struct ly_ctx *ctx, struct lysp_include *include)
+/**
+ * @brief Common function to erase include record in main module and submodule.
+ *
+ * There is a difference since the main module is expected to have the complete list if the included submodules and
+ * the parsed submodule is shared with any include in a submodule. Therefore, the referenced submodules in the include
+ * record are freed only from main module's records.
+ *
+ * @param[in] ctx libyang context
+ * @param[in] include The include record to be erased, the record itself is not freed.
+ * @param[in] main_module Flag to get know if the include record is placed in main module so also the referenced submodule
+ * is supposed to be freed.
+ */
+static void
+lysp_include_free_(struct ly_ctx *ctx, struct lysp_include *include, ly_bool main_module)
 {
-    if (include->submodule) {
+    if (main_module && include->submodule) {
         lysp_module_free((struct lysp_module *)include->submodule);
     }
     FREE_STRING(ctx, include->name);
@@ -82,6 +94,18 @@
 }
 
 void
+lysp_include_free_submodule(struct ly_ctx *ctx, struct lysp_include *include)
+{
+    return lysp_include_free_(ctx, include, 0);
+}
+
+void
+lysp_include_free(struct ly_ctx *ctx, struct lysp_include *include)
+{
+    return lysp_include_free_(ctx, include, 1);
+}
+
+void
 lysp_revision_free(struct ly_ctx *ctx, struct lysp_revision *rev)
 {
     FREE_STRING(ctx, rev->dsc);
@@ -423,7 +447,7 @@
     ctx = module->mod->ctx;
 
     FREE_ARRAY(ctx, module->imports, lysp_import_free);
-    FREE_ARRAY(ctx, module->includes, lysp_include_free);
+    FREE_ARRAY(ctx, module->includes, module->is_submod ? lysp_include_free_submodule : lysp_include_free);
 
     FREE_ARRAY(ctx, module->revs, lysp_revision_free);
     FREE_ARRAY(ctx, module->extensions, lysp_ext_free);
diff --git a/src/tree_schema_helpers.c b/src/tree_schema_helpers.c
index 5bbe14b..f0b10df 100644
--- a/src/tree_schema_helpers.c
+++ b/src/tree_schema_helpers.c
@@ -929,61 +929,180 @@
     return LY_SUCCESS;
 }
 
-LY_ERR
-lysp_load_submodule(struct lys_parser_ctx *pctx, struct lysp_include *inc)
+/**
+ * @brief Try to find the parsed submodule in main module for the given include record.
+ *
+ * @param[in] pctx main parser context
+ * @param[in] inc The include record with missing parsed submodule. According to include info try to find
+ * the corresponding parsed submodule in main module's includes.
+ * @return LY_SUCCESS - the parsed submodule was found and inserted into the @p inc record
+ * @return LY_ENOT - the parsed module was not found.
+ * @return LY_EVALID - YANG rule violation
+ */
+static LY_ERR
+lysp_get_submodule(struct lys_parser_ctx *pctx, struct lysp_include *inc)
 {
-    struct ly_ctx *ctx = (struct ly_ctx *)(PARSER_CTX(pctx));
-    struct lysp_submodule *submod = NULL;
-    const char *submodule_data = NULL;
-    LYS_INFORMAT format = LYS_IN_UNKNOWN;
+    LY_ARRAY_COUNT_TYPE i;
+    struct lysp_module *main_pmod = pctx->parsed_mod->mod->parsed;
 
-    void (*submodule_data_free)(void *module_data, void *user_data) = NULL;
-    struct lysp_load_module_check_data check_data = {0};
-    struct ly_in *in;
+    LY_ARRAY_FOR(main_pmod->includes, i) {
+        if (strcmp(main_pmod->includes[i].name, inc->name)) {
+            continue;
+        }
 
-    /* submodule not present in the context, get the input data and parse it */
-    if (!(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
-search_clb:
-        if (ctx->imp_clb) {
-            if (ctx->imp_clb(pctx->parsed_mod->mod->name, NULL, inc->name, inc->rev[0] ? inc->rev : NULL, ctx->imp_clb_data,
-                    &format, &submodule_data, &submodule_data_free) == LY_SUCCESS) {
-                LY_CHECK_RET(ly_in_new_memory(submodule_data, &in));
-                check_data.name = inc->name;
-                check_data.revision = inc->rev[0] ? inc->rev : NULL;
-                check_data.submoduleof = pctx->parsed_mod->mod->name;
-                lys_parse_submodule(ctx, in, format, pctx, lysp_load_module_check, &check_data, &submod);
-                ly_in_free(in, 0);
-                if (submodule_data_free) {
-                    submodule_data_free((void *)submodule_data, ctx->imp_clb_data);
+        if (inc->rev[0] && strncmp(inc->rev, main_pmod->includes[i].rev, LY_REV_SIZE)) {
+            LOGVAL(PARSER_CTX(pctx), LYVE_REFERENCE,
+                    "Submodule %s includes different revision (%s) of the submodule %s:%s included by the main module %s.",
+                    ((struct lysp_submodule *)pctx->parsed_mod)->name, inc->rev,
+                    main_pmod->includes[i].name, main_pmod->includes[i].rev, main_pmod->mod->name);
+            return LY_EVALID;
+        }
+
+        inc->submodule = main_pmod->includes[i].submodule;
+        return inc->submodule ? LY_SUCCESS : LY_ENOT;
+    }
+
+    if (main_pmod->version == LYS_VERSION_1_1) {
+        LOGVAL(PARSER_CTX(pctx), LYVE_REFERENCE,
+                "YANG 1.1 requires all submodules to be included from main module. "
+                "But submodule \"%s\" includes submodule \"%s\" which is not included by main module \"%s\".",
+                ((struct lysp_submodule *)pctx->parsed_mod)->name, inc->name, main_pmod->mod->name);
+        return LY_EVALID;
+    } else {
+        return LY_ENOT;
+    }
+}
+
+/**
+ * @brief Make the copy of the given include record into the main module.
+ *
+ * YANG 1.0 does not require the main module to include all the submodules. Therefore, parsing submodules can cause
+ * reallocating and extending the includes array in the main module by the submodules included only in submodules.
+ *
+ * @param[in] pctx main parser context
+ * @param[in] inc Include record to copy into main module taken from @p pctx.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lysp_inject_submodule(struct lys_parser_ctx *pctx, struct lysp_include *inc)
+{
+    LY_ARRAY_COUNT_TYPE i;
+    struct lysp_include *inc_new, *inc_tofill = NULL;
+    struct lysp_module *main_pmod = pctx->parsed_mod->mod->parsed;
+
+    /* first, try to find the corresponding record with missing parsed submodule */
+    LY_ARRAY_FOR(main_pmod->includes, i) {
+        if (strcmp(main_pmod->includes[i].name, inc->name)) {
+            continue;
+        }
+        inc_tofill = &main_pmod->includes[i];
+        break;
+    }
+
+    if (inc_tofill) {
+        inc_tofill->submodule = inc->submodule;
+    } else {
+        LY_ARRAY_NEW_RET(PARSER_CTX(pctx), main_pmod->includes, inc_new, LY_EMEM);
+
+        inc_new->submodule = inc->submodule;
+        DUP_STRING_RET(PARSER_CTX(pctx), inc->name, inc_new->name);
+        DUP_STRING_RET(PARSER_CTX(pctx), inc->dsc, inc_new->dsc);
+        DUP_STRING_RET(PARSER_CTX(pctx), inc->ref, inc_new->ref);
+        /* TODO duplicate extensions */
+        memcpy(inc_new->rev, inc->rev, LY_REV_SIZE);
+        inc_new->injected = 1;
+    }
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lysp_load_submodules(struct lys_parser_ctx *pctx, struct lysp_module *pmod)
+{
+    LY_ARRAY_COUNT_TYPE u;
+    struct ly_ctx *ctx = PARSER_CTX(pctx);
+
+    LY_ARRAY_FOR(pmod->includes, u) {
+        LY_ERR ret = LY_SUCCESS;
+        struct lysp_submodule *submod = NULL;
+        struct lysp_include *inc = &pmod->includes[u];
+
+        if (inc->submodule) {
+            continue;
+        }
+
+        if (pmod->is_submod) {
+            /* try to find the submodule in the main module or its submodules */
+            ret = lysp_get_submodule(pctx, inc);
+            LY_CHECK_RET(ret && ret != LY_ENOT, ret);
+            LY_CHECK_RET(ret == LY_SUCCESS, LY_SUCCESS); /* submodule found in linked with the inc */
+        }
+
+        /* submodule not present in the main module, get the input data and parse it */
+        if (!(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
+    search_clb:
+            if (ctx->imp_clb) {
+                const char *submodule_data = NULL;
+                LYS_INFORMAT format = LYS_IN_UNKNOWN;
+                void (*submodule_data_free)(void *module_data, void *user_data) = NULL;
+                struct lysp_load_module_check_data check_data = {0};
+                struct ly_in *in;
+
+                if (ctx->imp_clb(pctx->parsed_mod->mod->name, NULL, inc->name,
+                        inc->rev[0] ? inc->rev : NULL, ctx->imp_clb_data,
+                        &format, &submodule_data, &submodule_data_free) == LY_SUCCESS) {
+                    LY_CHECK_RET(ly_in_new_memory(submodule_data, &in));
+                    check_data.name = inc->name;
+                    check_data.revision = inc->rev[0] ? inc->rev : NULL;
+                    check_data.submoduleof = pctx->parsed_mod->mod->name;
+                    lys_parse_submodule(ctx, in, format, pctx, lysp_load_module_check, &check_data, &submod);
+
+                    /* update inc pointer - parsing another (YANG 1.0) submodule can cause injecting
+                     * submodule's include into main module, where it is missing */
+                    inc = &pmod->includes[u];
+
+                    ly_in_free(in, 0);
+                    if (submodule_data_free) {
+                        submodule_data_free((void *)submodule_data, ctx->imp_clb_data);
+                    }
                 }
             }
-        }
-        if (!submod && !(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
-            goto search_file;
-        }
-    } else {
-search_file:
-        if (!(ctx->flags & LY_CTX_DISABLE_SEARCHDIRS)) {
-            /* submodule was not received from the callback or there is no callback set */
-            lys_module_localfile(ctx, inc->name, inc->rev[0] ? inc->rev : NULL, NULL, 0, pctx,
-                    pctx->parsed_mod->mod->name, 1, NULL, (void **)&submod);
-        }
-        if (!submod && (ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
-            goto search_clb;
-        }
-    }
-    if (submod) {
-        if (!inc->rev[0] && (submod->latest_revision == 1)) {
-            /* update the latest_revision flag - here we have selected the latest available schema,
-             * consider that even the callback provides correct latest revision */
-            submod->latest_revision = 2;
-        }
+            if (!submod && !(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
+                goto search_file;
+            }
+        } else {
+    search_file:
+            if (!(ctx->flags & LY_CTX_DISABLE_SEARCHDIRS)) {
+                /* submodule was not received from the callback or there is no callback set */
+                lys_module_localfile(ctx, inc->name,
+                        inc->rev[0] ? inc->rev : NULL, NULL, 0, pctx,
+                        pctx->parsed_mod->mod->name, 1, NULL, (void **)&submod);
 
-        inc->submodule = submod;
-    }
-    if (!inc->submodule) {
-        LOGVAL(ctx, LYVE_REFERENCE, "Including \"%s\" submodule into \"%s\" failed.", inc->name, pctx->parsed_mod->mod->name);
-        return LY_EVALID;
+                /* update inc pointer - parsing another (YANG 1.0) submodule can cause injecting
+                 * submodule's include into main module, where it is missing */
+                inc = &pmod->includes[u];
+            }
+            if (!submod && (ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
+                goto search_clb;
+            }
+        }
+        if (submod) {
+            if (!inc->rev[0] && (submod->latest_revision == 1)) {
+                /* update the latest_revision flag - here we have selected the latest available schema,
+                 * consider that even the callback provides correct latest revision */
+                submod->latest_revision = 2;
+            }
+
+            inc->submodule = submod;
+            if (ret == LY_ENOT) {
+                /* the submodule include is not present in YANG 1.0 main module - add it there */
+                LY_CHECK_RET(lysp_inject_submodule(pctx, &pmod->includes[u]));
+            }
+        }
+        if (!inc->submodule) {
+            LOGVAL(ctx, LYVE_REFERENCE, "Including \"%s\" submodule into \"%s\" failed.", inc->name,
+                    pctx->parsed_mod->is_submod ? ((struct lysp_submodule *)pctx->parsed_mod)->name : pctx->parsed_mod->mod->name);
+            return LY_EVALID;
+        }
     }
 
     return LY_SUCCESS;
diff --git a/src/tree_schema_internal.h b/src/tree_schema_internal.h
index dbdf49b..5a2097b 100644
--- a/src/tree_schema_internal.h
+++ b/src/tree_schema_internal.h
@@ -296,14 +296,16 @@
         const char **features, struct lys_glob_unres *unres, struct lys_module **mod);
 
 /**
- * @brief Parse included submodule into the simply parsed YANG module.
+ * @brief Parse included submodules into the simply parsed YANG module.
+ *
+ * YANG 1.0 does not require the main module to include all the submodules. Therefore, parsing submodules can cause
+ * reallocating and extending the includes array in the main module by the submodules included only in submodules.
  *
  * @param[in] pctx main parser context
- * @param[in,out] inc Include structure holding all available information about the include statement, the parsed
- * submodule is stored into this structure.
+ * @param[in] pmod Parsed module with the includes array to be processed.
  * @return LY_ERR value.
  */
-LY_ERR lysp_load_submodule(struct lys_parser_ctx *pctx, struct lysp_include *inc);
+LY_ERR lysp_load_submodules(struct lys_parser_ctx *pctx, struct lysp_module *pmod);
 
 /**
  * @brief Free a parsed restriction.