diff --git a/.github/contributing/adding-tlg.md b/.github/contributing/adding-tlg.md
new file mode 100644
index 0000000..516fcb1
--- /dev/null
+++ b/.github/contributing/adding-tlg.md
@@ -0,0 +1,64 @@
+# Adding new Tables, Listing and Graphs
+In order to add new TLGs, two things are needed:
+### TLG definition
+Specified in [tlg.yaml](../../inst/shiny/tlg.yaml) file. Entry in that file is responsible for providing some metadata regarding the TLG (like name, descriptions, links), a function reference for creating the resulting TLG and options, taken as arguments by the generating function, that allow for quick and easy definition of widgets to be rendered in the application UI. This then allows the user to customize plots in accordance to their needs.
+
+### `R` function
+The code that creates the actual results.
+
+## Listings
+Currently not implemented.
+
+## Tables
+Currently not implemented
+
+## Graphs
+### yaml
+The `Graph` entry should have the following format. Identifying keys (wrapped in `<>`) should be provided by the creator and be unique within their scope (indentation level).
+ ```yaml
+# unique identifier for given entry
+<entry id>:
+  # true / false whether TLG should be included as default
+  is_default:
+  # type of the TLG, in this case must be Graph
+  type:
+  # name of the dataset
+  dataset:
+  # standarized id of the TLG, e.g. pkcg01     
+  pkid:
+  # short label to be displayed as tab name
+  label:
+  # longer descriptions, to be displayed in the order table
+  description:
+  # link to the documentation of the TLG
+  link:
+  # name of the function exported by the package, responsible for generating TLG, must return a list of plots to be displayed
+  fun:
+  # options that can be passed as arguments to the function    
+  options:
+    # option id, the same as the argument that is passed to the rendering function, must be unique in the scope of the TLG entry
+    <option id>:
+      # type of the option/widget, one of: text, numeric, select
+      type:
+      # label to be displayed in the editing widget
+      label:
+      # default value to be provided in the field;
+      # if provided, will overwrite function argument defaults;
+      # if left empty, function defaults will be applied;
+      # if type is 'select', '.all' keyword can be applied to select all choices;
+      default: 
+      # applicable to 'select' type, whether to allow for multiple values to be selected  
+      multiple:
+      # applicable to 'select' type, choices to pick from the dropdown, either specified outright or using a special keyword:
+      # - '.colnames' keyword will pull the choices from the data column names
+      # - '$COLUMN_NAME' keyword will pull choices from values of a specific column
+      choices:
+    # will create a label to help visually group related widgets; should be a character string; N should be replaced with an integer to uniquely identify the keyword    
+    .group_label_N:
+    
+  template:
+  # You can also specify template definitions. This is a character string with id of another TLG definition. All options will be copied over from template id. Any provided parameters will be a) overwritten if existing in the template or b) added as new.
+```
+
+### function
+Function should be defined within `aNCA` package and accept at least a `data` argument for providing results to be plotted. Should return a list of plots (might be just one plot).
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0402f32..aea46ea 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -73,4 +73,9 @@ Each pull request must be accepted by at least one reviewer before it can be mer
 When the change is done, pull request is open and the description is filled, please move your issue from **In Progress** to **Needs review** status, so it can be picked up by a reviewer. From this point it is up to the contributor and the person validating the change to work out any kinks and lead to merging the changes.
 
 #### For reviewers
-When reviewing a pull request, please do try to follow the [conventional comments](https://conventionalcomments.org/) guidelines. Ideas and labels described in that convention can be very helpful in getting your thoughts across and facilitate meaningful cooperation. That said, they are not applicable in every circumstance and you are free to do whatever you feel is suitable, as long as it aims to provide valid discussion.
\ No newline at end of file
+When reviewing a pull request, please do try to follow the [conventional comments](https://conventionalcomments.org/) guidelines. Ideas and labels described in that convention can be very helpful in getting your thoughts across and facilitate meaningful cooperation. That said, they are not applicable in every circumstance and you are free to do whatever you feel is suitable, as long as it aims to provide valid discussion.
+
+# In-depth guides
+Here are some useful links with in-depth documentation regarding specific parts of the pacakage and how to utilise in-build tools to extend the capabilities of the application:
+
+- [Adding TLGs](.github/contributing/adding-tlg.md)
\ No newline at end of file
diff --git a/DESCRIPTION b/DESCRIPTION
index 2466aac..1727548 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -32,10 +32,13 @@ Imports:
     dplyr,
     DT,
     forcats,
+    ggh4x,
     ggplot2,
+    glue,
     haven,
     htmlwidgets,
     logger,
+    magrittr,
     nestcolor,
     PKNCA,
     plotly,
@@ -43,8 +46,10 @@ Imports:
     reactable.extras,
     rio,
     rmarkdown,
+    scales,
     shiny,
     shinyBS,
+    shinycssloaders,
     shinyFiles,
     shinyjqui,
     shinyjs,
diff --git a/NAMESPACE b/NAMESPACE
index b77cde1..399f082 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -9,11 +9,16 @@ export(create_dose)
 export(filter_breaks)
 export(flexible_violinboxplot)
 export(format_data)
+export(g_pkconc_ind_lin)
+export(g_pkconc_ind_log)
 export(general_lineplot)
 export(general_meanplot)
 export(geometric_mean)
 export(has_label)
 export(lambda_slope_plot)
+export(parse_annotation)
+export(parse_tlg_definitions)
+export(pkcg01)
 export(pptestcd_dict)
 export(reshape_pknca_results)
 export(run_app)
@@ -38,6 +43,7 @@ importFrom(PKNCA,PKNCAdata)
 importFrom(PKNCA,PKNCAdose)
 importFrom(PKNCA,pk.nca)
 importFrom(PKNCA,pknca_units_table)
+importFrom(checkmate,assert_numeric)
 importFrom(dplyr,across)
 importFrom(dplyr,arrange)
 importFrom(dplyr,case_when)
@@ -46,14 +52,17 @@ importFrom(dplyr,filter)
 importFrom(dplyr,group_by)
 importFrom(dplyr,left_join)
 importFrom(dplyr,mutate)
+importFrom(dplyr,n)
 importFrom(dplyr,pull)
 importFrom(dplyr,rename)
 importFrom(dplyr,rename_with)
+importFrom(dplyr,rowwise)
 importFrom(dplyr,select)
 importFrom(dplyr,slice)
 importFrom(dplyr,summarise)
 importFrom(dplyr,ungroup)
 importFrom(dplyr,where)
+importFrom(ggh4x,scale_y_facet)
 importFrom(ggplot2,aes)
 importFrom(ggplot2,facet_wrap)
 importFrom(ggplot2,geom_errorbar)
@@ -63,6 +72,8 @@ importFrom(ggplot2,ggplot)
 importFrom(ggplot2,ggplot_build)
 importFrom(ggplot2,ggplot_gtable)
 importFrom(ggplot2,labs)
+importFrom(ggplot2,scale_x_continuous)
+importFrom(glue,glue)
 importFrom(grid,convertUnit)
 importFrom(htmlwidgets,JS)
 importFrom(logger,log_debug)
@@ -71,10 +82,12 @@ importFrom(logger,log_fatal)
 importFrom(logger,log_info)
 importFrom(logger,log_trace)
 importFrom(logger,log_warn)
+importFrom(magrittr,`%>%`)
 importFrom(plotly,event_data)
 importFrom(plotly,plotlyOutput)
 importFrom(plotly,plotly_build)
 importFrom(plotly,renderPlotly)
+importFrom(purr,imap)
 importFrom(reactable,colDef)
 importFrom(reactable,getReactableState)
 importFrom(reactable,reactable)
@@ -85,19 +98,24 @@ importFrom(reactable.extras,dropdown_extra)
 importFrom(reactable.extras,text_extra)
 importFrom(rio,export_list)
 importFrom(rmarkdown,render)
+importFrom(scales,breaks_log)
+importFrom(scales,label_log)
 importFrom(shinyBS,bsModal)
 importFrom(shinyFiles,shinyDirChoose)
 importFrom(shinyWidgets,dropdown)
 importFrom(shinyWidgets,pickerInput)
 importFrom(shinyWidgets,switchInput)
 importFrom(shinyWidgets,updatePickerInput)
+importFrom(shinycssloaders,withSpinner)
 importFrom(shinyjqui,orderInput)
 importFrom(shinyjqui,updateOrderInput)
 importFrom(stats,sd)
+importFrom(stringi,stri_rand_strings)
 importFrom(tern,g_ipp)
 importFrom(tidyr,pivot_longer)
 importFrom(tidyr,pivot_wider)
 importFrom(tools,file_ext)
 importFrom(utils,read.csv)
 importFrom(utils,write.csv)
+importFrom(yaml,read_yaml)
 importFrom(zip,zipr)
diff --git a/R/g_pkconc_ind.R b/R/g_pkconc_ind.R
new file mode 100644
index 0000000..5612ccb
--- /dev/null
+++ b/R/g_pkconc_ind.R
@@ -0,0 +1,294 @@
+#' Wrapper around aNCA::pkcg01() function. Calls the function with `LIN` scale argument.
+#' @param data Data to be passed into the plotting function.
+#' @param ...  Any other parameters to be passed into the plotting function.
+#' @returns ggplot2 object for pkcg01.
+#' @export
+g_pkconc_ind_lin <- function(data, ...) {
+  pkcg01(adpc = data, scale = "LIN", ...)
+}
+
+#' Wrapper around aNCA::pkcg01() function. Calls the function with `LOG` scale argument.
+#' @param data Data to be passed into the plotting function.
+#' @param ...  Any other parameters to be passed into the plotting function.
+#' @returns ggplot2 object for pkcg01.
+#' @export
+g_pkconc_ind_log <- function(data, ...) {
+  pkcg01(adpc = data, scale = "LOG", ...)
+}
+
+#' Generate PK Concentration-Time Profile Plots
+#'
+#' This function generates a list of ggplots for PK concentration-time profiles.
+#'
+#' @param adpc            A data frame containing the data.
+#' @param xvar            A character string of the variable name for the x-axis.
+#' @param yvar            A character string of the variable name for the y-axis.
+#' @param xvar_unit       A character string of the unit for the x-axis variable.
+#' @param yvar_unit       A character string of the unit for the y-axis variable.
+#' @param color_var       A character string of the variable name for the color.
+#' @param color_var_label A character string of the color label.
+#' @param xbreaks_var     A character string of the x-axis breaks.
+#' @param xmin            A numeric value specifying the minimum x-axis limit.
+#' @param xmax            A numeric value specifying the maximum x-axis limit.
+#' @param ymin            A numeric value for the minimum y-axis limit.
+#' @param ymax            A numeric value for the maximum y-axis limit.
+#' @param xlab            Character for x-axis label. Defaults: `xvar` label & `xvar_unit`.
+#' @param ylab            Character for y-axis label. Defaults: `yvar` label & `yvar_unit`.
+#' @param footnote        A character string of a manual footnote for the plot.
+#' @param plotgroup_vars  A character vector of the variables to group data.
+#' @param plotgroup_names A character vector of the grouping variable names.
+#' @param options         A list of additional options (e.g., display scale).
+#' @param studyid         A character string specifying the study ID variable.
+#' @param trt_var         A character string specifying the treatment variable.
+#' @returns A list of ggplot objects for each unique group.
+#' @importFrom dplyr mutate across rowwise ungroup group_by n
+#' @importFrom ggplot2 aes scale_x_continuous labs
+#' @importFrom tern g_ipp
+#' @importFrom checkmate assert_numeric
+#' @importFrom scales breaks_log label_log
+#' @importFrom ggh4x scale_y_facet
+#'
+#' @examples
+#' \dontrun{
+#'   adpc <- read.csv("inst/shiny/data/DummyRO_ADNCA.csv")
+#'   attr(adpc[["AFRLT"]], "label") <- "Actual time from first dose"
+#'   attr(adpc[["AVAL"]], "label") <- "Analysis val"
+#'
+#'   plots_lin <- pckg01(adpc = adpc, xmax = 1)
+#'   plots_log <- pckg01(adpc = adpc, color_var = "USUBJID", scale = "LOG")
+#'   plots_sbs <- pckg01(
+#'     adpc = adpc,
+#'     color_var = "USUBJID",
+#'     xbreaks_var = "NFRLT",
+#'     xmin = 100,
+#'     xmax = 1000,
+#'     scale = "SBS"
+#'   )
+#' }
+#'
+#' @export
+#' @author Gerardo Rodriguez
+pkcg01 <- function(
+  adpc = data(),
+  xvar = "AFRLT",
+  yvar = "AVAL",
+  xvar_unit = "RRLTU",
+  yvar_unit = "AVALU",
+  color_var = NULL,
+  color_var_label = NULL,
+  xbreaks_var = "NFRLT",
+  xbreaks_mindist = 0.5,
+  xmin = NA,
+  xmax = NA,
+  ymin = NA,
+  ymax = NA,
+  xlab = paste0(xvar, " [", unique(adpc[[xvar_unit]]), "]"),
+  ylab = paste0(yvar, " [", unique(adpc[[yvar_unit]]), "]"),
+  title = NULL,
+  subtitle = NULL,
+  footnote = NULL,
+  # Inputs to split-by/seggregate plots
+  plotgroup_vars = c("ROUTE", "PCSPEC", "PARAM", "USUBJID"),
+  # TODO(mateusz): Refactor when label attributes are implemented.
+  plotgroup_names = list(
+    "ROUTE" = "Route",
+    "PCSPEC" = "Specimen",
+    "PARAM" = "Analyte",
+    "USUBJID" = "Subject ID"
+  ),
+
+  # Specific inputs (needs metadata specification),
+  scale = c("LIN", "LOG", "SBS")[1],
+  studyid = "STUDYID",
+  trt_var = "TRT01A"
+) {
+  xmin <- as.numeric(xmin)
+  xmax <- as.numeric(xmax)
+  ymin <- as.numeric(ymin)
+  ymax <- as.numeric(ymax)
+
+  # save col labels, as further adpc tranformations cause them to be lost #
+  col_labels <- purrr::map(adpc, ~ attr(.x, "label"))
+
+  adpc_grouped <- adpc %>%
+    mutate(across(all_of(plotgroup_vars), as.character)) %>%
+    rowwise() %>%
+    dplyr::mutate(id_plot = interaction(!!!syms(plotgroup_vars)))
+
+  # reapply col labels to grouped data #
+  adpc_grouped <- purrr::map2_dfc(adpc_grouped, names(adpc_grouped), ~ {
+    attr(.x, "label") <- col_labels[[.y]]
+    .x
+  })
+
+  # Construct the reference ggplot object
+  plot_data <- adpc_grouped %>% filter(id_plot == id_plot[1])
+
+  plot <- tern::g_ipp(
+    df = plot_data,
+    xvar = xvar,
+    yvar = yvar,
+    xlab = parse_annotation(plot_data, xlab),
+    ylab = parse_annotation(plot_data, ylab),
+    id_var = "USUBJID",
+    add_baseline_hline = FALSE,
+    yvar_baseline = yvar,
+    plotting_choices = "separate_by_obs"
+  )[[1]]
+
+  # Provide limits and additional potential future aesthetic customizations
+  plot <- plot +
+    aes(color = NULL) +
+    theme(
+      plot.title = element_text(family = "sans", size = 14, color = "black"),
+      plot.subtitle = element_text(family = "sans", size = 11, color = "black")
+    ) +
+    coord_cartesian(xlim = c(xmin, xmax), ylim = c(ymin, ymax))
+
+  # Ensure x breaks labels do not overlap graphically
+  plot <- plot +
+    scale_x_continuous(
+      guide = guide_axis(n.dodge = 1),
+      breaks = filter_breaks(
+        plot_data[[xbreaks_var]],
+        min_cm_distance = xbreaks_mindist,
+        plot = plot
+      ),
+      labels = \(x) ifelse(x %% 1 == 0, as.character(as.integer(x)), as.character(x))
+    )
+
+  # Add color when specified
+  if (!is.null(color_var)) {
+    plot <- plot +
+      aes(color = !!sym(color_var)) +
+      theme(legend.position = "none")
+  }
+
+  # Add color legend only when neccessary
+  if (!is.null(color_var_label) && length(color_var) > 1) {
+    plot <- plot +
+      labs(color = if (!is.null(color_var_label)) color_var_label else color_var) +
+      theme(legend.position = "bottom")
+  }
+
+
+  if (scale == "LOG") {
+    plot <- plot +
+      labs(y = paste0("Log 10 - ", plot$labels$y))
+  }
+
+  if (scale == "SBS") {
+    # Create SBS version of data and plot
+    adpc_grouped <- rbind(adpc_grouped, adpc_grouped) %>%
+      dplyr::mutate(
+        view = c(
+          rep("Linear view", nrow(adpc_grouped)),
+          rep("Semilogarithmic view (Log10)", nrow(adpc_grouped))
+        ),
+        !!sym(yvar) := ifelse(
+          !!sym(yvar) < 1e-3 & view == "Semilogarithmic view (Log10)", yes = 1e-3, no = !!sym(yvar)
+        )
+      )
+
+    plot <- plot %+% dplyr::filter(adpc_grouped, id_plot == unique(id_plot)[1]) +
+      facet_wrap(~ view, scales = "free_y") +
+      ggh4x::scale_y_facet(
+        view == "Semilogarithmic view (Log10)",
+        trans  = "log10",
+        breaks = scales::breaks_log(),
+        labels = scales::label_log()
+      )
+  }
+
+  # Create the list of plots for each unique group
+  lapply(unique(adpc_grouped[["id_plot"]]), \(id_val) {
+    plot_data <- adpc_grouped %>% dplyr::filter(id_plot ==  id_val)
+
+    title <- {
+      if (is.null(title)) {
+        paste0(
+          "Plot of PK Concentration-Time Profile ",
+          dplyr::case_when(
+            scale == "LIN" ~ "linear",
+            scale == "LOG" ~ "logarithmic",
+            TRUE ~ "linear and logarithmic"
+          ),
+          " scale, by Cohort: ", unique(plot_data[[studyid]])
+        )
+      } else {
+        parse_annotation(plot_data, title)
+      }
+    }
+
+    subtitle <- {
+      if (is.null(subtitle)) {
+        paste0(
+          "Treatment Group: ", unique(plot_data[[trt_var]]), " (N=", nrow(plot_data), ")<br>",
+          # TODO(mateusz): Refactor when label attributes are implemented.
+          paste(
+            unlist(unname(plotgroup_names[plotgroup_vars])), ": ",
+            unique(plot_data[, plotgroup_vars]),
+            sep = "",  collapse = ", "
+          )
+        )
+      } else {
+        parse_annotation(plot_data, subtitle)
+      }
+    }
+
+    title_text <- paste0(title, "<br>", "<sup>", subtitle, "</sup>")
+    title_margin <- (0.5 * length(unlist(strsplit(title_text, "\n|<br>"))))
+
+    #' magic numbers for footnote position and margin, work in app up to 4 lines
+    footnote <- {
+      if (is.null(footnote)) {
+        ""
+      } else {
+        parse_annotation(plot_data, footnote)
+      }
+    }
+    footnote_y <- 0.1 + (0.05 * length(unlist(strsplit(footnote, "\n|<br>"))))
+
+    plotly_plot <- plot %+%
+      plot_data %+%
+      theme(
+        # add margin to make space for subtitle and footnote #
+        plot.margin = margin(
+          title_margin,
+          0,
+          footnote_y * 5,
+          0,
+          "cm"
+        )
+      ) %>%
+      ggplotly(
+        tooltip = c("x", "y"),
+        dynamicTicks = TRUE,
+        #' NOTE: might require some fine tuning down the line, looks fine now
+        height = 500 + (footnote_y * 25) + title_margin * 50
+      ) %>%
+      layout(
+        # title and subtitle #
+        title = list(text = title_text),
+        # footnote #
+        annotations = list(
+          x = 0,
+          y =  -footnote_y,
+          text = footnote,
+          showarrow = FALSE,
+          yref = "paper",
+          xref = "paper",
+          align = "left",
+          parse = TRUE
+        )
+      )
+
+    if (scale == "LOG") {
+      plotly_plot <- plotly_plot %>%
+        layout(yaxis = list(type = "log"))
+    }
+
+    plotly_plot
+  }) |>
+    setNames(unique(adpc[["id_plot"]]))
+}
diff --git a/R/run_app.R b/R/run_app.R
index 864c74d..be05fef 100644
--- a/R/run_app.R
+++ b/R/run_app.R
@@ -18,9 +18,11 @@
 #' @importFrom rio export_list
 #' @importFrom rmarkdown render
 #' @importFrom shinyBS bsModal
+#' @importFrom shinycssloaders withSpinner
 #' @importFrom shinyFiles shinyDirChoose
 #' @importFrom shinyjqui orderInput updateOrderInput
 #' @importFrom shinyWidgets dropdown pickerInput switchInput updatePickerInput
+#' @importFrom stringi stri_rand_strings
 #' @importFrom tools file_ext
 #' @importFrom utils read.csv write.csv
 #' @importFrom zip zipr
diff --git a/R/utils-tlg.R b/R/utils-tlg.R
new file mode 100644
index 0000000..333c8b8
--- /dev/null
+++ b/R/utils-tlg.R
@@ -0,0 +1,78 @@
+#' Parses annotations in the context of data. Special characters and syntax are substituted by
+#' actual data and/or substituted for format that is better parsed via rendering functions
+#' (e.g. plotly).
+#'
+#' @details
+#' * `\n` character is substituted for `<br>` tag in order to add new lines in rendered image.
+#' * `$COLNAME` is parsed to provide unique data value from the mentioned column.
+#' * `!COLNAME` is parsed to provide `label` attribute for a given column name.
+#' If any values are missing from the provided data, they are substituted for `ERR` string.
+#'
+#' @param data Data frame containing data to reference. Should include columns and labels referenced
+#'             in the text string. Referenced variables should be able to produce single unique
+#'             result.
+#' @param text Character text to parse.
+#' @returns Parsed annotation text.
+#'
+#' @importFrom magrittr `%>%`
+#' @importFrom glue glue
+#'
+#' @export
+parse_annotation <- function(data, text) {
+  text %>%
+    gsub("\n", "<br>", .) %>%
+    gsub("\\$(\\w+)", "{unique(data[['\\1']])}", .) %>%
+    gsub("!(\\w+)", "{attr(data[['\\1']], 'label')}", .) %>%
+    glue::glue(.na = "ERR", .null = "ERR")
+}
+
+#' Parses the tlg definitions described in yaml file into a list object.
+#' Custom YAML parsing is needed for templating - the user can define templates for a definition.
+#' The function detects appropriate keywords and copies information from specified templates.
+#'
+#' @param path Path to a YAML file containing TLG definitions.
+#' @param defs A list of TLG definitions read from a YAML file.
+#'
+#' @details
+#' If both `path` and `defs` are provided, `path` will be used and definitions will be loaded from
+#' the file. If neither is given, as a default, the function will load system file in
+#' `shiny/tlg.yaml`.
+#'
+#' @returns A full list of available TLG definitions.
+#'
+#' @importFrom purr imap
+#' @importFrom yaml read_yaml
+#'
+#' @export
+parse_tlg_definitions <- function(path = NULL, defs = NULL) {
+  if (is.null(path) && is.null(defs)) {
+    defs <- yaml::read_yaml(system.file("shiny/tlg.yaml", package = "aNCA"))
+  }
+
+  if (!is.null(path)) {
+    defs <- yaml::read_yaml(path)
+  }
+
+  defs <- purrr::imap(defs, \(opt_def, opt_id) {
+    if ("template" %in% names(opt_def)) {
+      template_def <- defs[[opt_def$template]]
+
+      for (d in names(opt_def)) {
+        if (d == "template") next
+
+        if (d == "options") {
+          for (o in names(opt_def$options)) {
+            template_def$options[[o]] <- opt_def$options[[o]]
+          }
+        } else {
+          template_def[[d]] <- opt_def[[d]]
+        }
+      }
+
+      opt_def <- template_def
+    }
+
+    opt_def
+  }) |>
+    setNames(names(defs))
+}
\ No newline at end of file
diff --git a/inst/WORDLIST b/inst/WORDLIST
index 548d118..665c7be 100644
--- a/inst/WORDLIST
+++ b/inst/WORDLIST
@@ -18,20 +18,24 @@ Pre
 RO
 RStudio
 STUDYID
+TLG
 USUBJID
 USUBJIDs
+YAML
 analysing
 analyte
 analytes
 anonymized
 anonymizes
-cheatsheet
 cmax
+codebase
 csv
 customizable
 ggplot
+ggplots
 nca
 pharmacokinetic
+pkcg
 pknca
 plotly
 pptest
@@ -41,7 +45,9 @@ ruleset
 rulesets
 sas
 summarization
+templating
 timepoint
+tlg
 visualizable
 xpt
-codebase
+yaml
diff --git a/inst/shiny/global.R b/inst/shiny/global.R
index adb6198..61918ae 100644
--- a/inst/shiny/global.R
+++ b/inst/shiny/global.R
@@ -4,6 +4,8 @@ source("modules/slope_selector.R")
 
 source("functions/partial_auc_input.R")
 
+source("modules/tlg_plot.R")
+
 source("modules/tab_visuals.R")
 
 source("functions/mapping_selectize_inputs.R")
diff --git a/inst/shiny/modules/tab_tlg.R b/inst/shiny/modules/tab_tlg.R
index 85ca674..caabbca 100644
--- a/inst/shiny/modules/tab_tlg.R
+++ b/inst/shiny/modules/tab_tlg.R
@@ -1,96 +1,58 @@
+.TLG_DEFINITIONS <- parse_tlg_definitions()
+
 tab_tlg_ui <- function(id) {
   ns <- NS(id)
 
-  tabsetPanel(
-    tabPanel(
+  navset_pill(
+    id = ns("tlg_tabs"),
+    nav_panel(
       "Order details",
-      actionButton(ns("add_tlg"), "Add TLG"),
-      actionButton(ns("remove_tlg"), "Remove TLG"),
-      actionButton(ns("submit_tlg_order"), "Submit Order Details"),
-      DTOutput(ns("selected_tlg_table")),
-      actionButton(ns("submit_tlg_order_alt"), "Submit Order Details")
-    ),
-    tabPanel(
-      "Tables",
-      fluidRow(
-        column(
-          2,  # Left column for plot selection
-          radioButtons(
-            inputId = ns("buttons_Tables"),
-            label = "Choose Table\n",
-            choices = ""
-          )
-        ),
-        column(
-          6,  # Middle column for plot output
-          h4("Table to display"),
-          plotOutput(ns("plot_Tables"))
-        ),
-        column(
-          2,  # Right column for plot customization inputs
-          h4("Inputs with selected vals linked to downloadable obj (i.e, tlg_order())"),
-          textInput(ns("footnote_Tables"), label = "Footnote")
+      card(
+        style = "margin-top: 1em;",
+        div(
+          actionButton(ns("add_tlg"), "Add TLG"),
+          actionButton(ns("remove_tlg"), "Remove TLG"),
+          actionButton(ns("submit_tlg_order"), "Submit Order Details", class = "btn-primary")
         )
-      )
-    ),
-    tabPanel(
-      "Listings",
-      fluidRow(
-        column(
-          2,  # Left column for plot selection
-          radioButtons(
-            inputId = ns("buttons_Listings"),
-            label = "Choose List\n",
-            choices = ""
-          )
-        ),
-        column(
-          6,  # Middle column for plot output
-          h4("Listing to display"),
-          plotOutput(ns("plot_Listings"))
-        ),
-        column(
-          2,  # Right column for plot customization inputs
-          h4("Inputs with selected vals linked to downloadable obj (i.e, tlg_order())"),
-          textInput(ns("footnote_Listings"), label = "Footnote")
+      ),
+      card(
+        DTOutput(ns("selected_tlg_table"))
+      ),
+      card(
+        div(
+          actionButton(ns("submit_tlg_order_alt"), "Submit Order Details", class = "btn-primary")
         )
       )
     ),
-    tabPanel(
-      "Graphs",
-      fluidRow(
-        column(
-          2,  # Left column for plot selection
-          radioButtons(
-            inputId = ns("buttons_Graphs"),
-            label = "Choose Graph\n",
-            choices = ""
-          )
-        ),
-        column(
-          6,  # Middle column for plot output
-          h4("Graph to display"),
-          plotOutput(ns("plot_Graphs"))
-        ),
-        column(
-          2,  # Right column for plot customization inputs
-          h4("Inputs with selected vals linked to downloadable obj (i.e, tlg_order())"),
-          textInput(ns("footnote_Graphs"), label = "Footnote")
-        )
-      )
-    )
+    nav_panel("Tables", "To be added"),
+    nav_panel("Listings", "To be added"),
+    nav_panel("Graphs", uiOutput(ns("graphs"), class = "tlg-plot-module"), value = "Graphs"),
+    # disable loader for initial empty UI render #
+    footer = tags$style(HTML(paste0(".tlg-plot-module .load-container {opacity: 0;}")))
   )
 }
 
-tab_tlg_server <- function(id, data) {
+tab_tlg_server <- function(id) {
   moduleServer(id, function(input, output, session) {
-    ns <- session$ns
+    log_trace("{session$ns(id)}: Attaching server.")
 
-    # Make available the CSV file with the TLG list and available links to NEST
-    tlg_order <- reactiveVal(
-      read.csv(system.file("www/data/TLG_order_details.csv", package = "aNCA")) %>%
-        mutate(PKid = paste0("<a href='", Catalog_Link, "' target='_blank'>", PKid, "</a>"))
-    )
+    data <- session$userData$data
+
+    #' Load TLG orders definitions
+    tlg_order <- reactiveVal({
+      purrr::map_dfr(.TLG_DEFINITIONS, ~ dplyr::tibble(
+        Selection = .x$is_default,
+        Type = .x$type,
+        Dataset = .x$dataset,
+        PKid = paste0("<a href='", .x$link, "' target='_blank'>", .x$pkid, "</a>"),
+        Description = .x$description,
+        Footnote = NA_character_,
+        Stratification = NA_character_,
+        Condition = NA_character_,
+        Comment = NA_character_
+      )) %>%
+        dplyr::mutate(id = dplyr::row_number(), .before = dplyr::everything())
+    })
 
     # Based on the TLG list conditions for data() define the preselected rows in $Selection
     observeEvent(list(tlg_order(), data()), {
@@ -112,8 +74,8 @@ tab_tlg_server <- function(id, data) {
 
     # Render the TLG list for the user's inspection
     output$selected_tlg_table <- DT::renderDT({
+      log_trace("Rendering TLG table.")
       datatable(
-        elementId = "selected_tlg_datatable",
         class = "table table-striped table-bordered",
         data = dplyr::filter(tlg_order(), Selection),
         editable = list(
@@ -239,48 +201,66 @@ tab_tlg_server <- function(id, data) {
       }
     })
 
-    # When the user submits the TLG order...
-    observeEvent(list(input$submit_tlg_order, input$submit_tlg_order_alt), {
+    # Toggle submit button depending on whether the data is available #
+    observeEvent(data(), ignoreInit = FALSE, ignoreNULL = FALSE, {
+      shinyjs::toggleState("submit_tlg_order", !is.null(data()))
+      shinyjs::toggleState("submit_tlg_order_alt", !is.null(data()))
+    })
+
+    #' change tab to first populated tab (currently only Graphs)
+    #' for mysterious reasons nav_select() and updateTabsetPanel() were not working,
+    #' so solved this using JavaScript
+    observeEvent(list(input$submit_tlg_order, input$submit_tlg_order_alt), ignoreInit = TRUE, {
+      shinyjs::runjs(
+        paste0("
+          // change the tab to graphs //
+          console.log('HEYAH');
+          $(`#", session$ns("tlg_tabs"), " a[data-value='Graphs']`)[0].click();
+
+          // enable spinner, as it was disabled for initial empty UI render //
+          setTimeout(function() {
+            $('.tlg-plot-module .load-container').css('opacity', 1);
+          }, 500);  
+        ")
+      )
+    })
+
+    # Submit the TLG order, filter selected TLGs
+    tlg_order_filtered <- reactive({
+      req(data())
       tlg_order_filt <- tlg_order()[tlg_order()$Selection, ]
+      log_debug("Submitted TLGs:\n", paste0("* ", tlg_order_filt$Description, collapse = "\n"))
 
-      if (sum(tlg_order_filt$Type == "Table") > 0) {
-        updateRadioButtons(
-          session = session,
-          inputId = "buttons_Tables",
-          label = "Table to display",
-          choices = tlg_order_filt$Label[tlg_order_filt$Type == "Table"]
-        )
-      } else {
-        updateRadioButtons(session = session, inputId = "buttons_Tables", label = "", choices = "")
-      }
+      tlg_order_filt
+    }) |>
+      bindEvent(c(input$submit_tlg_order, input$submit_tlg_order_alt))
 
-      if (sum(tlg_order_filt$Type == "Listing") > 0) {
-        updateRadioButtons(
-          session = session,
-          inputId = "buttons_Listings",
-          label = "Listing to display",
-          choices = tlg_order_filt$Label[tlg_order_filt$Type == "Listing"]
-        )
-      } else {
-        updateRadioButtons(session = session,
-                           inputId = "buttons_Listings",
-                           label = "",
-                           choices = "")
-      }
+    # Create and render Graph interface and modules
+    output$graphs <- renderUI({
+      req(tlg_order_filtered())
+      tlg_order_graphs <- filter(tlg_order_filtered(), Type == "Graph") %>%
+        select("id") %>%
+        pull()
 
-      if (sum(tlg_order_filt$Type == "Graph") > 0) {
-        updateRadioButtons(
-          session = session,
-          inputId = "buttons_Graphs",
-          label = "Graph to display",
-          choices = tlg_order_filt$Label[tlg_order_filt$Type == "Graph"]
-        )
-      } else {
-        updateRadioButtons(session = session,
-                           inputId = "buttons_Graphs",
-                           label = "",
-                           choices = "")
-      }
+      panels <- lapply(tlg_order_graphs, function(g_id) {
+        plot_ui <- {
+          g_def <- .TLG_DEFINITIONS[[g_id]]
+          module_id <- paste0(g_id, stringi::stri_rand_strings(1, 5))
+
+          if (exists(g_def$fun)) {
+            tlg_plot_server(module_id, get(g_def$fun), g_def$options)
+            tlg_plot_ui(session$ns(module_id))
+          } else {
+            tags$div("Plot not implemented yet")
+          }
+        }
+
+        nav_panel(g_def$label, plot_ui)
+      })
+
+      panels$"widths" <- c(2, 10)
+
+      do.call(navset_pill_list, panels)
     })
   })
 }
diff --git a/inst/shiny/modules/tlg_plot.R b/inst/shiny/modules/tlg_plot.R
new file mode 100644
index 0000000..72189e2
--- /dev/null
+++ b/inst/shiny/modules/tlg_plot.R
@@ -0,0 +1,229 @@
+tlg_plot_ui <- function(id) {
+  ns <- NS(id)
+
+  layout_sidebar(
+    sidebar = sidebar(
+      position = "right",
+      div(
+        class = "plot-options-container",
+        dropdown(
+          div(
+            tags$h2("Plot options"),
+            tags$p("
+              You can specify any plot customization options that are supported by the specific
+              plot module.
+            "),
+            tags$p("Leaving a widget empty will allow default behaviour of the plotting function."),
+            tags$p(
+              "In text fields, you can reference values / columns in the dataset by using
+              the dollar sign (", tags$b("$"), ") and providing column name, e.g. ",
+              tags$b("$DOSEU"), "."
+            ),
+            tags$p("
+              You can also reference ", tags$i("label"), " attribute of any column by prefacing the
+              column name by exclamation mark (", tags$b("!"), "), e.g. ", tags$b("!DOSEU"), ".
+            ")
+          ),
+          style = "unite",
+          right = TRUE,
+          icon = icon("question"),
+          status = "primary"
+        ),
+        actionButton(
+          inputId = ns("reset_widgets"),
+          label = "Reset to defaults"
+        ),
+        uiOutput(ns("options"), class = "plot-options-container")
+      )
+    ),
+    div(
+      class = "plot-widgets-container",
+      div(
+        align = "left",
+        tags$span(
+          class = "inline-select-input",
+          style = "margin-right: 5em;",
+          tags$span("Plots per page:"),
+          selectInput(
+            ns("plots_per_page"),
+            "",
+            choices = c("All", 1, 2, 4, 6, 8, 10)
+          )
+        ),
+        shinyjs::disabled(actionButton(ns("previous_page"), "Previous Page", class = "btn-page"))
+      ),
+      div(
+        align = "center",
+        tags$span(
+          class = "inline-select-input",
+          tags$span("Page "),
+          selectInput(
+            inputId = ns("select_page"),
+            label = "",
+            choices = ""
+          ),
+          tags$span(" out of "),
+          uiOutput(ns("page_number"), inline = TRUE),
+        )
+      ),
+      div(align = "right", actionButton(ns("next_page"), "Next Page", class = "btn-page"))
+    ),
+    shinycssloaders::withSpinner(
+      uiOutput(ns("plots"))
+    )
+  )
+}
+
+tlg_plot_server <- function(id, render_plot, options = NULL) {
+  moduleServer(id, function(input, output, session) {
+    data <- session$userData$data
+
+    current_page <- reactiveVal(1)
+
+    #' updating current page based on user input
+    observeEvent(input$next_page, current_page(current_page() + 1))
+    observeEvent(input$previous_page, current_page(current_page() - 1))
+    observeEvent(input$select_page, {
+      if (input$select_page == "") return(NULL)
+      current_page(as.numeric(input$select_page))
+    })
+
+    #' hold reactive information about the page layout
+    num_pages <- reactive({
+      req(plot_list(), plots_per_page())
+      ceiling(length(plot_list()) / plots_per_page())
+    })
+
+    plots_per_page <- reactive({
+      if (is.null(input$plots_per_page)) return(NULL)
+      if (is.null(plot_list())) return(NULL)
+      if (input$plots_per_page == "All") {
+        length(plot_list())
+      } else {
+        as.numeric(input$plots_per_page)
+      }
+    })
+
+    #' updates UI responsible for page change
+    observeEvent(list(current_page(), num_pages()), {
+      req(num_pages(), current_page())
+      shinyjs::toggleState(id = "previous_page", condition = current_page() > 1)
+      shinyjs::toggleState(
+        id = "next_page",
+        condition = num_pages() != 1 && current_page() < num_pages()
+      )
+      updateSelectInput(session = session, inputId = "select_page", selected = current_page())
+    })
+    observeEvent(plots_per_page(), {
+      req(num_pages(), plots_per_page())
+      current_page(1)
+
+      output$page_number <- renderUI(paste0(num_pages(), "."))
+      updateSelectInput(inputId = "select_page", choices = seq_len(num_pages()))
+    })
+
+    #' keeps list of plots to render, with options gathered from the UI and applied
+    plot_list <- reactive({
+      if (length(options_()) == 0) return(NULL)
+
+      plot_options <- purrr::list_modify(list(data = data()), !!!options_())
+
+      purrr::iwalk(plot_options, \(value, name) {
+        if (isTRUE(value %in% c(NULL, "", 0)))
+          plot_options[[name]] <<- NULL
+      })
+
+      do.call(render_plot, plot_options)
+    })
+
+    output$plots <- renderUI({
+      req(plot_list(), plots_per_page(), current_page())
+      num_plots <- length(plot_list())
+      page_end <- current_page() * plots_per_page()
+      page_start <- page_end - plots_per_page() + 1
+      if (page_end > num_plots) page_end <- num_plots
+
+      plot_list()[page_start:page_end]
+    })
+
+    #' resets the options to defaults
+    observeEvent(input$reset_widgets, {
+      purrr::walk(names(options), shinyjs::reset)
+    })
+
+    #' holds options gathered from UI widgets
+    options_ <- reactive({
+      lapply(names(options), \(opt_id) input[[opt_id]]) |>
+        setNames(names(options)) |>
+        purrr::keep(\(x) !is.null(x))
+    }) |>
+      shiny::debounce(750)
+
+    #' creates widgets responsible for custimizing the plots
+    output$options <- renderUI({
+      purrr::imap(options, create_edit_widget)
+    })
+  })
+}
+
+#' Creates editing widget of appropriate type.
+#' @param opt_def Definition of the option
+#' @param opt_id  Id of the option
+#' @param session Session object for namespacing the widgets
+#' @returns Shiny widget with appropriate type, label and options
+create_edit_widget <- function(opt_def, opt_id, session = shiny::getDefaultReactiveDomain()) {
+  if (grepl(".group_label", opt_id)) {
+    return(tags$h1(opt_def, class = "tlg-group-label"))
+  }
+
+  label <- if (is.null(opt_def$label)) opt_id else opt_def$label
+
+  switch(
+    opt_def$type,
+    text = {
+      textInput(
+        session$ns(opt_id),
+        label = label,
+        value = opt_def$default
+      )
+    },
+    numeric = {
+      numericInput(
+        session$ns(opt_id),
+        label = label,
+        value = opt_def$default
+      )
+    },
+    select = {
+      choices <- {
+        if (isTRUE(opt_def$choices == ".colnames")) {
+          names(session$userData$data())
+        } else if (length(opt_def$choices) == 1 && grepl("^\\$", opt_def$choices)) {
+          unique(session$userData$data()[, sub("^\\$", "", opt_def$choices)])
+        } else {
+          opt_def$choices
+        }
+      }
+
+      selected <- {
+        if (!is.null(opt_def$default)) {
+          if (opt_def$default == ".all") {
+            choices
+          } else {
+            opt_def$default
+          }
+        } else {
+          ""
+        }
+      }
+
+      selectInput(
+        session$ns(opt_id),
+        label = label,
+        selected = selected,
+        choices = c("", choices),
+        multiple = isTRUE(opt_def$multiple)
+      )
+    }
+  )
+}
\ No newline at end of file
diff --git a/inst/shiny/server.R b/inst/shiny/server.R
index d900700..c582da2 100644
--- a/inst/shiny/server.R
+++ b/inst/shiny/server.R
@@ -7,13 +7,17 @@ function(input, output, session) {
   data_module <- tab_data_server("data")
   # Data set for analysis
   data <- data_module$data
+  #' Create global data object. This is accessible by all modules, without the need to pass
+  #' data reactive directly.
+  session$userData$data <- reactive(data())
   # Grouping Variables
   grouping_vars <- data_module$grouping_variables
+
   # NCA ----
   source(system.file("shiny/tabs/nca.R", package = "aNCA"), local = TRUE)
   # OUTPUT ----
   tab_visuals_server("visuals", data, grouping_vars, res_nca)
 
   # TLG
-  tab_tlg_server("tlg", data)
+  tab_tlg_server("tlg")
 }
diff --git a/inst/shiny/tlg.yaml b/inst/shiny/tlg.yaml
new file mode 100644
index 0000000..b9d290b
--- /dev/null
+++ b/inst/shiny/tlg.yaml
@@ -0,0 +1,71 @@
+# Configuration file containing TLG definitions.
+# To learn more, please check .github/contributing/adding-tlg.md
+g_pkconc_ind_lin:
+  is_default: true
+  type: Graph
+  dataset: ADPC
+  pkid: pkcg01
+  label: "pkcg01 - linear"
+  description: "Individual plots of concentrations vs. time (one plot per patient/subject) with linear scale"
+  link: https://insightsengineering.github.io/tlg-catalog/stable/graphs/pharmacokinetic/pkcg01.html
+  fun: g_pkconc_ind_lin
+  options:
+    .group_label_1: "General"
+    xvar:
+      type: select
+      label: X axis
+      choices: .colnames
+    plotgroup_vars:
+      type: select
+      label: "Grouping variables"
+      default: .all
+      multiple: true
+      choices:
+        - ROUTE
+        - PCSPEC
+        - PARAM
+        - USUBJID
+    color_var:
+      type: select
+      label: "Color variable"
+      choices: .colnames
+
+    .group_label_2: "Labels"
+    title:
+      type: text
+      label: Title
+    subtitle:
+      type: text
+      label: Subtitle
+    footnote:
+      type: text
+      label: Footnote
+    xlab:
+      type: text
+      label: X axis label
+    ylab:
+      type: text
+      label: Y axis label
+    xbreaks_var:
+      type: select
+      label: "X ticks"
+      choices: .colnames
+      default: "NFRLT"
+    color_var_label:
+      type: text
+      label: Color variable label
+
+    .group_label_3: "Limits"
+    xmin:
+      type: numeric
+    xmax:
+      type: numeric
+    ymin:
+      type: numeric
+    ymax:
+      type: numeric
+g_pkconc_ind_log:
+  template: g_pkconc_ind_lin
+  label: pkcg01 - log
+  description: "Individual plots of concentrations vs. time (one plot per patient/subject) with log10 scale"
+  fun: g_pkconc_ind_log
diff --git a/inst/shiny/www/style.css b/inst/shiny/www/style.css
index fde4db9..92266d7 100644
--- a/inst/shiny/www/style.css
+++ b/inst/shiny/www/style.css
@@ -136,3 +136,70 @@
     top: 3px;
   }
 }
+
+/* custom inline selection module */
+.inline-select-input > div,
+.inline-select-input > div > div {
+  width: 5em !important;
+  text-align: left !important;
+  display: inline-block !important;
+}
+
+
+.tlg-plot-module {
+  margin-top: 1em;
+
+  /* Well containing tabs for each tlg */
+  div.well {
+    height: min-content;
+  }
+
+  .sw-dropdown {
+    font-size: 1em;
+    display: block;
+    position: relative;
+    top: -2.5em;
+    right: -0.5em;
+    margin-bottom: -1.25em;
+    height: 2em;
+    width: 2em;
+    float: right;
+  }
+
+  .sw-dropdown-in {
+    width: 200px;
+  }
+
+  .plot-widgets-container {
+    display: flex;
+    justify-content: space-around;
+    align-items: baseline;
+    margin-bottom: 1em;
+  }
+
+  /* tlg tab */
+  h1.tlg-group-label {
+    font-weight: bold;
+    font-size: 2rem;
+    border-bottom: thin solid #337ab7;
+    border-radius: 0 0 .25em 0;
+    margin-top: 0.75em;
+  }
+
+  .plot-options-container {
+    & > button {
+      width: 75%;
+      margin-left: 15%;
+      margin-top: 1em;
+      padding: 0.75em 0 0.75em 0;
+    }
+
+    .form-group.shiny-input-container {
+      margin-bottom: 0.5em;
+
+      label {
+        margin: 0;
+      }
+    }
+  }
+}
diff --git a/man/g_pkconc_ind_lin.Rd b/man/g_pkconc_ind_lin.Rd
new file mode 100644
index 0000000..08e4817
--- /dev/null
+++ b/man/g_pkconc_ind_lin.Rd
@@ -0,0 +1,19 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/g_pkconc_ind.R
+\name{g_pkconc_ind_lin}
+\alias{g_pkconc_ind_lin}
+\title{Wrapper around aNCA::pkcg01() function. Calls the function with \code{LIN} scale argument.}
+\usage{
+g_pkconc_ind_lin(data, ...)
+}
+\arguments{
+\item{data}{Data to be passed into the plotting function.}
+
+\item{...}{Any other parameters to be passed into the plotting function.}
+}
+\value{
+ggplot2 object for pkcg01.
+}
+\description{
+Wrapper around aNCA::pkcg01() function. Calls the function with \code{LIN} scale argument.
+}
diff --git a/man/g_pkconc_ind_log.Rd b/man/g_pkconc_ind_log.Rd
new file mode 100644
index 0000000..98dfdfd
--- /dev/null
+++ b/man/g_pkconc_ind_log.Rd
@@ -0,0 +1,19 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/g_pkconc_ind.R
+\name{g_pkconc_ind_log}
+\alias{g_pkconc_ind_log}
+\title{Wrapper around aNCA::pkcg01() function. Calls the function with \code{LOG} scale argument.}
+\usage{
+g_pkconc_ind_log(data, ...)
+}
+\arguments{
+\item{data}{Data to be passed into the plotting function.}
+
+\item{...}{Any other parameters to be passed into the plotting function.}
+}
+\value{
+ggplot2 object for pkcg01.
+}
+\description{
+Wrapper around aNCA::pkcg01() function. Calls the function with \code{LOG} scale argument.
+}
diff --git a/man/parse_annotation.Rd b/man/parse_annotation.Rd
new file mode 100644
index 0000000..7e449e3
--- /dev/null
+++ b/man/parse_annotation.Rd
@@ -0,0 +1,33 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/utils-tlg.R
+\name{parse_annotation}
+\alias{parse_annotation}
+\title{Parses annotations in the context of data. Special characters and syntax are substituted by
+actual data and/or substituted for format that is better parsed via rendering functions
+(e.g. plotly).}
+\usage{
+parse_annotation(data, text)
+}
+\arguments{
+\item{data}{Data frame containing data to reference. Should include columns and labels referenced
+in the text string. Referenced variables should be able to produce single unique
+result.}
+
+\item{text}{Character text to parse.}
+}
+\value{
+Parsed annotation text.
+}
+\description{
+Parses annotations in the context of data. Special characters and syntax are substituted by
+actual data and/or substituted for format that is better parsed via rendering functions
+(e.g. plotly).
+}
+\details{
+\itemize{
+\item \verb{\\n} character is substituted for \verb{<br>} tag in order to add new lines in rendered image.
+\item \verb{$COLNAME} is parsed to provide unique data value from the mentioned column.
+\item \code{!COLNAME} is parsed to provide \code{label} attribute for a given column name.
+If any values are missing from the provided data, they are substituted for \code{ERR} string.
+}
+}
diff --git a/man/parse_tlg_definitions.Rd b/man/parse_tlg_definitions.Rd
new file mode 100644
index 0000000..585d444
--- /dev/null
+++ b/man/parse_tlg_definitions.Rd
@@ -0,0 +1,28 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/utils-tlg.R
+\name{parse_tlg_definitions}
+\alias{parse_tlg_definitions}
+\title{Parses the tlg definitions described in yaml file into a list object.
+Custom YAML parsing is needed for templating - the user can define templates for a definition.
+The function detects appropriate keywords and copies information from specified templates.}
+\usage{
+parse_tlg_definitions(path = NULL, defs = NULL)
+}
+\arguments{
+\item{path}{Path to a YAML file containing TLG definitions.}
+
+\item{defs}{A list of TLG definitions read from a YAML file.}
+}
+\value{
+A full list of available TLG definitions.
+}
+\description{
+Parses the tlg definitions described in yaml file into a list object.
+Custom YAML parsing is needed for templating - the user can define templates for a definition.
+The function detects appropriate keywords and copies information from specified templates.
+}
+\details{
+If both \code{path} and \code{defs} are provided, \code{path} will be used and definitions will be loaded from
+the file. If neither is given, as a default, the function will load system file in
+\code{shiny/tlg.yaml}.
+}
diff --git a/man/pkcg01.Rd b/man/pkcg01.Rd
new file mode 100644
index 0000000..ecd0492
--- /dev/null
+++ b/man/pkcg01.Rd
@@ -0,0 +1,104 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/g_pkconc_ind.R
+\name{pkcg01}
+\alias{pkcg01}
+\title{Generate PK Concentration-Time Profile Plots}
+\usage{
+pkcg01(
+  adpc = data(),
+  xvar = "AFRLT",
+  yvar = "AVAL",
+  xvar_unit = "RRLTU",
+  yvar_unit = "AVALU",
+  color_var = NULL,
+  color_var_label = NULL,
+  xbreaks_var = "NFRLT",
+  xbreaks_mindist = 0.5,
+  xmin = NA,
+  xmax = NA,
+  ymin = NA,
+  ymax = NA,
+  xlab = paste0(xvar, " [", unique(adpc[[xvar_unit]]), "]"),
+  ylab = paste0(yvar, " [", unique(adpc[[yvar_unit]]), "]"),
+  title = NULL,
+  subtitle = NULL,
+  footnote = NULL,
+  plotgroup_vars = c("ROUTE", "PCSPEC", "PARAM", "USUBJID"),
+  plotgroup_names = list(ROUTE = "Route", PCSPEC = "Specimen", PARAM = "Analyte", USUBJID
+    = "Subject ID"),
+  scale = c("LIN", "LOG", "SBS")[1],
+  studyid = "STUDYID",
+  trt_var = "TRT01A"
+)
+}
+\arguments{
+\item{adpc}{A data frame containing the data.}
+
+\item{xvar}{A character string of the variable name for the x-axis.}
+
+\item{yvar}{A character string of the variable name for the y-axis.}
+
+\item{xvar_unit}{A character string of the unit for the x-axis variable.}
+
+\item{yvar_unit}{A character string of the unit for the y-axis variable.}
+
+\item{color_var}{A character string of the variable name for the color.}
+
+\item{color_var_label}{A character string of the color label.}
+
+\item{xbreaks_var}{A character string of the x-axis breaks.}
+
+\item{xmin}{A numeric value specifying the minimum x-axis limit.}
+
+\item{xmax}{A numeric value specifying the maximum x-axis limit.}
+
+\item{ymin}{A numeric value for the minimum y-axis limit.}
+
+\item{ymax}{A numeric value for the maximum y-axis limit.}
+
+\item{xlab}{Character for x-axis label. Defaults: \code{xvar} label & \code{xvar_unit}.}
+
+\item{ylab}{Character for y-axis label. Defaults: \code{yvar} label & \code{yvar_unit}.}
+
+\item{footnote}{A character string of a manual footnote for the plot.}
+
+\item{plotgroup_vars}{A character vector of the variables to group data.}
+
+\item{plotgroup_names}{A character vector of the grouping variable names.}
+
+\item{studyid}{A character string specifying the study ID variable.}
+
+\item{trt_var}{A character string specifying the treatment variable.}
+
+\item{options}{A list of additional options (e.g., display scale).}
+}
+\value{
+A list of ggplot objects for each unique group.
+}
+\description{
+This function generates a list of ggplots for PK concentration-time profiles.
+}
+\examples{
+\dontrun{
+  adpc <- read.csv("inst/shiny/data/DummyRO_ADNCA.csv")
+  attr(adpc[["AFRLT"]], "label") <- "Actual time from first dose"
+  attr(adpc[["AVAL"]], "label") <- "Analysis val"
+
+  plots_lin <- pckg01(adpc = adpc, xmax = 1)
+  plots_log <- pckg01(adpc = adpc, color_var = "USUBJID", scale = "LOG")
+  plots_sbs <- pckg01(
+    adpc = adpc,
+    color_var = "USUBJID",
+    xbreaks_var = "NFRLT",
+    xmin = 100,
+    xmax = 1000,
+    scale = "SBS"
+  )
+}
+
+}
+\author{
+Gerardo Rodriguez
+magic numbers for footnote position and margin, work in app up to 4 lines
+NOTE: might require some fine tuning down the line, looks fine now
+}
diff --git a/tests/testthat/test-g_pkconc_ind.R b/tests/testthat/test-g_pkconc_ind.R
new file mode 100644
index 0000000..3185e91
--- /dev/null
+++ b/tests/testthat/test-g_pkconc_ind.R
@@ -0,0 +1,110 @@
+root <- rprojroot::find_root(rprojroot::is_r_package)
+adpc <- read.csv(file.path(root, "inst/shiny/data/DummyRO_ADNCA.csv"))
+attr(adpc$USUBJID, "label") <- "Subject ID"
+attr(adpc$DOSEU, "label") <- "Dose unit"
+adpc_single <- dplyr::filter(adpc, USUBJID == "11101")
+
+#' Converts plotly object to JSON
+#' @param p plotly object
+#' @returns a list with plotly object data
+.get_plotly_json <- function(p) {
+  jsonlite::fromJSON(plotly::plotly_json(p, FALSE))
+}
+
+#' Checks basic expectations for plot list:
+#' - is a list
+#' - length is as expected
+#' - each element is a plotly object
+#' @param p_list plot list
+#' @param list_length expected length of the list
+.expect_plotlist <- function(p_list, list_length) {
+  expect_type(p_list, "list")
+  expect_equal(length(p_list), list_length)
+  purrr::walk(p_list, \(plot) expect_identical(class(plot), c("plotly", "htmlwidget")))
+}
+
+describe("pkcg01", {
+  it("generates valid plot list with default settings", {
+    p_list <- pkcg01(adpc)
+    .expect_plotlist(p_list, 23)
+  })
+
+  it("generates plot with custom labels", {
+    p_list <- pkcg01(
+      adpc_single,
+      "xlab" = "Test custom xlab",
+      "ylab" = "Test custom ylab",
+      "title" = "Test custom title",
+      "subtitle" = "Test custom subtitle",
+      "footnote" = "Test custom footnote"
+    )
+
+    .expect_plotlist(p_list, 1)
+
+    p_json <- .get_plotly_json(p_list[[1]])
+    expect_equal(p_json$layout$xaxis$title$text, "Test custom xlab")
+    expect_equal(p_json$layout$yaxis$title$text, "Test custom ylab")
+    expect_equal(p_json$layout$title$text, "Test custom title<br><sup>Test custom subtitle</sup>")
+    expect_equal(p_json$layout$annotations[1, ]$text, "Test custom footnote")
+  })
+
+  it("generates plot with custom labels that include special syntax", {
+    p_list <- pkcg01(
+      adpc_single,
+      "xlab" = "Test $USUBJID",
+      "ylab" = "Test !USUBJID: $USUBJID",
+      "title" = "Test !DOSEU: $DOSEU",
+      "subtitle" = "Test $DOSEU\n$DOSEU",
+      "footnote" = "Test !USUBJID"
+    )
+
+    .expect_plotlist(p_list, 1)
+
+    p_json <- .get_plotly_json(p_list[[1]])
+    expect_equal(p_json$layout$xaxis$title$text, "Test 11101")
+    expect_equal(p_json$layout$yaxis$title$text, "Test Subject ID: 11101")
+    expect_equal(p_json$layout$title$text, "Test Dose unit: mg<br><sup>Test mg<br>mg</sup>")
+    expect_equal(p_json$layout$annotations[1, ]$text, "Test Subject ID")
+  })
+
+  it("generates plot list in respect to grouping variables", {
+    p_list <- pkcg01(adpc, plotgroup_vars = c("ROUTE", "PCSPEC", "PARAM"))
+    .expect_plotlist(p_list, 1)
+  })
+
+  it("generates plots in respect to provided limits", {
+    p_list <- pkcg01(
+      adpc_single,
+      xmin = 10,
+      xmax = 150,
+      ymin = 1,
+      ymax = 3
+    )
+
+    .expect_plotlist(p_list, 1)
+
+    p_json <- .get_plotly_json(p_list[[1]])
+
+    #' NOTE:
+    #' Actual range expectations differ from values provided in function call since plotly
+    #' adds some margin.
+    expect_equal(p_json$layout$xaxis$range, c(3, 157))
+    expect_equal(p_json$layout$yaxis$range, c(0.9, 3.1))
+  })
+})
+
+describe("g_pkconc_ind_lin", {
+  it("generates plot with linear scale", {
+    p_list <- g_pkconc_ind_lin(adpc_single)
+    p_json <- .get_plotly_json(p_list[[1]])
+    expect_equal(p_json$layout$yaxis$type, "linear")
+  })
+})
+
+describe("g_pkconc_ind_log", {
+  it("generates plot with log scale", {
+    p_list <- g_pkconc_ind_log(adpc_single)
+    p_json <- .get_plotly_json(p_list[[1]])
+    expect_equal(p_json$layout$yaxis$type, "log")
+  })
+})
\ No newline at end of file
diff --git a/tests/testthat/test-utils-tlg.R b/tests/testthat/test-utils-tlg.R
new file mode 100644
index 0000000..4806ac8
--- /dev/null
+++ b/tests/testthat/test-utils-tlg.R
@@ -0,0 +1,90 @@
+describe("parse_annotation", {
+  mock_data <- tibble(
+    GROUP = "XX01",
+    DOSE = "10",
+    DOSEU = "mg"
+  )
+  attr(mock_data[["DOSE"]], "label") <- "Administered dose"
+
+  it("parses title string correctly", {
+    expect_equal(
+      parse_annotation(mock_data, "Group $GROUP\n!DOSE: $DOSE [$DOSEU]"),
+      "Group XX01<br>Administered dose: 10 [mg]"
+    )
+  })
+
+  it("substitutes missing variables with ERR", {
+    expect_equal(
+      parse_annotation(mock_data, "Column: $INVALID"),
+      "Column: ERR"
+    )
+
+    expect_equal(
+      parse_annotation(mock_data, "Label: !GROUP"),
+      "Label: ERR"
+    )
+  })
+})
+
+describe("parse_tlg_definitions", {
+  it("parses TLG definitions correctly", {
+    defs <- list(
+      TLG1 = list(
+        options = list(
+          option1 = "value1"
+        )
+      ),
+      TLG2 = list(
+        option2 = "value2"
+      )
+    )
+
+    # If no special keys are provided, the function should return the same list
+    expect_equal(parse_tlg_definitions(defs = defs), defs)
+  })
+
+  it("deals with templates correctly", {
+    defs <- list(
+      TLG1 = list(
+        is_default = TRUE,
+        type = "Graph",
+        label = "TLG1",
+        options = list(
+          xvar = "X",
+          yvar = "Y"
+        )
+      ),
+      TLG2 = list(
+        template = "TLG1",
+        label = "TLG2",
+        options = list(
+          yvar = "Z"
+        )
+      )
+    )
+
+    expect_equal(
+      parse_tlg_definitions(defs = defs),
+      list(
+        TLG1 = list(
+          is_default = TRUE,
+          type = "Graph",
+          label = "TLG1",
+          options = list(
+            xvar = "X",
+            yvar = "Y"
+          )
+        ),
+        TLG2 = list(
+          is_default = TRUE,
+          type = "Graph",
+          label = "TLG2",
+          options = list(
+            xvar = "X",
+            yvar = "Z"
+          )
+        )
+      )
+    )
+  })
+})
\ No newline at end of file