expeditaea 1.0.0

package/packages/types/app/index.d.ts

@@ -0,0 +1,179 @@
+import { ServerResponse } from 'http'
+import { IncomingMessage, NextFunction } from 'connect'
+import Vue, { ComponentOptions } from 'vue'
+import VueRouter, { Location, Route } from 'vue-router'
+import { Store } from 'vuex'
+
+import { NuxtOptions } from '../config'
+import { NuxtRuntimeConfig } from '../config/runtime'
+
+// augment typings of Vue.js
+import './vue'
+
+// augment typings of Vuex
+import './vuex'
+
+type NuxtState = Record<string, any>
+
+export interface NuxtAppOptions extends ComponentOptions<Vue> {
+  [key: string]: any // TBD
+}
+
+export interface NuxtError {
+  message?: string
+  path?: string
+  statusCode?: number
+}
+
+export interface Context {
+  $config: NuxtRuntimeConfig
+
+  app: NuxtAppOptions
+  base: string
+  /**
+   * @deprecated Use process.client instead
+  */
+  isClient: boolean
+  /**
+   * @deprecated Use process.server instead
+  */
+  isServer: boolean
+  /**
+   * @deprecated Use process.static instead
+  */
+  isStatic: boolean
+  isDev: boolean
+  isHMR: boolean
+  route: Route
+  from: Route
+  store: Store<any>
+  env: Record<string, any>
+  params: Route['params']
+  payload: any
+  query: Route['query']
+  next?: NextFunction
+  req: IncomingMessage
+  res: ServerResponse
+  redirect(status: number, path: string, query?: Route['query']): void
+  redirect(path: string, query?: Route['query']): void
+  redirect(location: Location): void
+  redirect(status: number, location: Location): void
+  ssrContext?: {
+    req: Context['req']
+    res: Context['res']
+    url: string
+    target: NuxtOptions['target']
+    spa?: boolean
+    modern: boolean
+    runtimeConfig: {
+      public: NuxtRuntimeConfig
+      private: NuxtRuntimeConfig
+    }
+    redirected: boolean
+    next: NextFunction
+    beforeRenderFns: Array<() => any>
+    fetchCounters: Record<string, number>
+    nuxt: {
+      layout: string
+      data: Array<Record<string, any>>
+      fetch: Array<Record<string, any>>
+      error: any
+      state: Array<Record<string, any>>
+      serverRendered: boolean
+      routePath: string
+      config: NuxtRuntimeConfig
+    }
+  }
+  error(params: NuxtError): void
+  nuxtState: NuxtState
+  beforeNuxtRender(fn: (params: { Components: VueRouter['getMatchedComponents'], nuxtState: NuxtState }) => void): void
+  enablePreview?: (previewData?: Record<string, any>) => void
+  $preview?: Record<string, any>
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type Middleware = string | ((ctx: Context, cb: Function) => Promise<void> | void)
+export type Inject = (key: string, value: any) => void
+export type Plugin = (ctx: Context, inject: Inject) => Promise<void> | void
+
+export interface Transition {
+  name?: string
+  mode?: string
+  css?: boolean
+  duration?: number
+  type?: string
+  enterClass?: string
+  enterToClass?: string
+  enterActiveClass?: string
+  leaveClass?: string
+  leaveToClass?: string
+  leaveActiveClass?: string
+  beforeEnter?(el: HTMLElement): void
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  enter?(el: HTMLElement, done: Function): void
+  afterEnter?(el: HTMLElement): void
+  enterCancelled?(el: HTMLElement): void
+  beforeLeave?(el: HTMLElement): void
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  leave?(el: HTMLElement, done: Function): void
+  afterLeave?(el: HTMLElement): void
+  leaveCancelled?(el: HTMLElement): void
+}
+
+export interface DefaultNuxtLoading extends Vue {
+  canSucceed: boolean
+  clear(): void
+  continuous: boolean
+  decrease(num: number): DefaultNuxtLoading
+  duration: number
+  fail(): DefaultNuxtLoading
+  finish(): DefaultNuxtLoading
+  increase(num: number): DefaultNuxtLoading
+  get(): number
+  hide(): DefaultNuxtLoading
+  left: number
+  pause(): DefaultNuxtLoading
+  percent: number
+  resume(): DefaultNuxtLoading
+  reversed: boolean
+  rtl: boolean
+  set(num: number): DefaultNuxtLoading
+  skipTimerCount: number
+  show: boolean
+  start(): DefaultNuxtLoading
+  startTimer(): void
+  throttle: number
+}
+
+export interface CustomNuxtLoading extends Vue {
+  fail?(): CustomNuxtLoading
+  finish(): CustomNuxtLoading
+  increase?(num: number): CustomNuxtLoading
+  pause?(): CustomNuxtLoading
+  start(): CustomNuxtLoading
+}
+
+export type NuxtLoading = DefaultNuxtLoading | CustomNuxtLoading
+
+export interface NuxtApp extends Vue {
+  $options: NuxtAppOptions
+  $loading: NuxtLoading
+  nbFetching: number
+  isFetching: boolean
+  context: Context
+  error(params: NuxtError): void
+  isOffline: boolean
+  isOnline: boolean
+  layout: any // TBD
+  layoutName: string
+  loadLayout(layout: string): Promise<any> // TBD
+  refresh(): Promise<void>
+  setLayout(layout: string): any // TBD
+}
+
+// window.$nuxt
+declare global {
+  interface Window {
+    $nuxt: NuxtApp
+  }
+}

package/packages/types/app/vue.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Extends interfaces in Vue.js
+ */
+
+import Vue from 'vue'
+import { MetaInfo } from 'vue-meta'
+import { Route } from 'vue-router'
+import { NuxtRuntimeConfig } from '../config/runtime'
+import { Context, Middleware, Transition, NuxtApp } from './index'
+
+declare module 'vue/types/options' {
+  // eslint-disable-next-line no-unused-vars,@typescript-eslint/no-unused-vars
+  interface ComponentOptions<V extends Vue> {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    asyncData?(ctx: Context): Promise<object | void> | object | void
+    fetch?(ctx: Context): Promise<void> | void
+    fetchKey?: string | ((getKey: (id: string) => number) => string)
+    fetchDelay?: number
+    fetchOnServer?: boolean | (() => boolean)
+    head?: MetaInfo | (() => MetaInfo)
+    key?: string | ((to: Route) => string)
+    layout?: string | ((ctx: Context) => string)
+    loading?: boolean
+    middleware?: Middleware | Middleware[]
+    scrollToTop?: boolean
+    transition?: string | Transition | ((to: Route, from: Route | undefined) => string | Transition)
+    validate?(ctx: Context): Promise<boolean> | boolean
+    watchQuery?: boolean | string[] | ((newQuery: Route['query'], oldQuery: Route['query']) => boolean)
+    meta?: { [key: string]: any }
+  }
+}
+
+declare module 'vue/types/vue' {
+  interface Vue {
+    $config: NuxtRuntimeConfig
+    $nuxt: NuxtApp
+    $fetch(): void
+    $fetchState: {
+      error: Error | null
+      pending: boolean
+      timestamp: number
+    }
+  }
+}

package/packages/types/app/vuex.d.ts

@@ -0,0 +1,10 @@
+import VueRouter from 'vue-router'
+import { NuxtAppOptions } from '.'
+
+declare module 'vuex/types/index' {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-unused-vars
+  interface Store<S> {
+    app: NuxtAppOptions
+    $router: VueRouter
+  }
+}

package/packages/types/cli/index.d.ts

@@ -0,0 +1,8 @@
+import { Configuration } from '../config'
+
+type Command = any // TBD
+
+export interface Hooks {
+  config?(config: Configuration): void
+  'run:before'?(params: { argv: string [], command: Command, rootDir: string }): void
+}

package/packages/types/config/build.d.ts

@@ -0,0 +1,185 @@
+/**
+ * NuxtOptionsBuild
+ * Documentation: https://nuxtjs.org/api/configuration-build
+ */
+
+import { TransformOptions, PluginItem } from '@babel/core'
+import { Options as AutoprefixerOptions } from 'autoprefixer'
+import { Options as FileLoaderOptions } from 'file-loader'
+import { Options as HtmlMinifierOptions } from 'html-minifier'
+import * as Less from 'less'
+import { Options as SassOptions } from 'sass-loader'
+import { Options as OptimizeCssAssetsWebpackPluginOptions } from 'optimize-css-assets-webpack-plugin'
+import { Plugin as PostcssPlugin } from 'postcss'
+import { Options as PugOptions } from 'pug'
+import { TerserPluginOptions } from 'terser-webpack-plugin'
+import { VueLoaderOptions } from 'vue-loader'
+import {
+  Configuration as WebpackConfiguration,
+  Loader as WebpackLoader,
+  loader as WebpackLoaderNamespace,
+  Options as WebpackOptions,
+  Plugin as WebpackPlugin
+} from 'webpack'
+import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer'
+import { Options as WebpackDevMiddlewareOptions } from 'webpack-dev-middleware'
+import { MiddlewareOptions as WebpackHotMiddlewareOptions, ClientOptions as WebpackHotMiddlewareClientOptions } from 'webpack-hot-middleware'
+
+type CssLoaderUrlFunction = (url: string, resourcePath: string) => boolean
+type CssLoaderImportFunction = (url: string, media: string, resourcePath: string) => boolean
+
+type CssLoaderMode = 'global' | 'local' | 'pure'
+interface CssLoaderModulesOptions {
+  compileType?: 'module' | 'icss',
+  mode?: CssLoaderMode,
+  auto?: Boolean | RegExp | ((resourcePath: string) => boolean),
+  exportGlobals?: boolean,
+  localIdentName?: string,
+  context?: string,
+  localIdentHashPrefix?: string,
+  namedExport?: boolean,
+  exportLocalsConvention?: 'asIs' | 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly',
+  exportOnlyLocals?: boolean,
+}
+
+interface CssLoaderOptions {
+  url?: boolean | CssLoaderUrlFunction
+  import?: boolean | CssLoaderImportFunction
+  modules?: boolean | CssLoaderMode | CssLoaderModulesOptions
+  sourceMap?: boolean
+  importLoaders?: number
+  esModule?: boolean
+}
+
+interface UrlLoaderOptions {
+  esModule?: boolean
+  fallback?: WebpackLoader
+  limit?: boolean | number | string
+  mimetype?: string
+}
+
+interface NuxtOptionsLoaders {
+  css?: CssLoaderOptions
+  cssModules?: CssLoaderOptions
+  file?: FileLoaderOptions
+  fontUrl?: UrlLoaderOptions
+  imgUrl?: UrlLoaderOptions
+  less?: Less.Options
+  pugPlain?: PugOptions
+  sass?: SassOptions
+  scss?: SassOptions
+  stylus?: any // TBD
+  vue?: VueLoaderOptions
+  vueStyle?: {
+    manualInject?: boolean
+    ssrId?: boolean
+    shadowMode?: boolean
+  }
+}
+
+interface NuxtWebpackEnv {
+  isClient: boolean
+  isDev: boolean
+  isLegacy: boolean
+  isModern: boolean
+  isServer: boolean
+}
+
+interface NuxtBabelPresetEnv {
+  envName: 'client' | 'modern' | 'server'
+}
+
+interface NuxtBabelOptions extends Pick<TransformOptions, Exclude<keyof TransformOptions, 'presets' | 'plugins'>> {
+  cacheCompression?: boolean
+  cacheDirectory?: boolean
+  cacheIdentifier?: string
+  customize?: string | null
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  presets?: ((env: NuxtBabelPresetEnv & NuxtWebpackEnv, defaultPreset: [string, object]) => PluginItem[] | void) | PluginItem[] | null
+  plugins?: ((env: NuxtBabelPresetEnv & NuxtWebpackEnv) => NonNullable<TransformOptions['plugins']>) | TransformOptions['plugins']
+}
+
+interface Warning {
+  message: string
+  name: string
+}
+
+interface PostcssOrderPresetFunctions {
+  cssnanoLast: (names: string[]) => string[]
+  presetEnvAndCssnanoLast: (names: string[]) => string[]
+  presetEnvLast: (names: string[]) => string[]
+}
+type PostcssOrderPreset = keyof PostcssOrderPresetFunctions
+interface PostcssVariableMap {
+  customMedia: Record<string, string>
+  customProperties: Record<string, string>
+  customSelectors: Record<string, string>
+  environmentVariables?: Record<string, string>
+}
+
+interface PostcssConfiguration {
+  order?: PostcssOrderPreset | string[] | ((names: string[], presets: PostcssOrderPresetFunctions) => string[])
+  plugins?: {
+    [key: string]: false | { [key: string]: any }
+  } | ((loader: WebpackLoaderNamespace.LoaderContext) => PostcssPlugin<any>[]) | Array<[string | PostcssPlugin<any>, any] | string | PostcssPlugin<any>>
+  preset?: {
+    autoprefixer?: false | AutoprefixerOptions
+    browsers?: string
+    exportTo?: string | string[] | Partial<PostcssVariableMap> | ((map: PostcssVariableMap) => Partial<PostcssVariableMap>)
+    features?: {
+      [key: string]: boolean | { [key: string]: any }
+    }
+    importFrom?: string | string[] | Partial<PostcssVariableMap> | (() => Partial<PostcssVariableMap>)
+    insertAfter?: { [key: string]: PostcssPlugin<any> }
+    insertBefore?: { [key: string]: PostcssPlugin<any> }
+    preserve?: boolean
+    stage?: 0 | 1 | 2 | 3 | 4 | false
+  }
+}
+
+export interface NuxtOptionsBuild {
+  additionalExtensions?: string[]
+  analyze?: BundleAnalyzerPlugin.Options | boolean
+  babel?: NuxtBabelOptions
+  cache?: boolean
+  corejs?: 'auto' | 2 | 3
+  crossorigin?: string
+  cssSourceMap?: boolean
+  devMiddleware?: WebpackDevMiddlewareOptions
+  devtools?: boolean
+  extend?(
+    config: WebpackConfiguration,
+    ctx: {
+      loaders: NuxtOptionsLoaders
+    } & NuxtWebpackEnv
+  ): void
+  extractCSS?: boolean | Record<string, any>
+  filenames?: { [key in 'app' | 'chunk' | 'css' | 'img' | 'font' | 'video']?: (ctx: NuxtWebpackEnv) => string }
+  friendlyErrors?: boolean
+  hardSource?: boolean
+  hotMiddleware?: WebpackHotMiddlewareOptions & { client?: WebpackHotMiddlewareClientOptions }
+  html?: { minify: false | HtmlMinifierOptions }
+  indicator?: boolean
+  loaders?: NuxtOptionsLoaders
+  loadingScreen?: boolean | any
+  optimization?: WebpackOptions.Optimization
+  optimizeCSS?: OptimizeCssAssetsWebpackPluginOptions | boolean
+  parallel?: boolean
+  plugins?: WebpackPlugin[]
+  postcss?: string[] | boolean | PostcssConfiguration | (() => PostcssConfiguration)
+  profile?: boolean
+  publicPath?: string
+  quiet?: boolean
+  splitChunks?: {
+    commons?: boolean
+    layouts?: boolean
+    pages?: boolean
+  }
+  ssr?: boolean
+  standalone?: boolean
+  templates?: any
+  terser?: TerserPluginOptions | boolean
+  transpile?: Array<string | RegExp | ((context: NuxtWebpackEnv) => string | RegExp | undefined)>
+  warningIgnoreFilters?: Array<(warn: Warning) => boolean>
+  watch?: string[]
+}

package/packages/types/config/cli.d.ts

@@ -0,0 +1,14 @@
+/**
+ * NuxtOptionsCli
+ * Documentation: https://nuxtjs.org/api/configuration-cli
+ */
+
+import { Chalk } from 'chalk'
+
+type ChalkColor =
+    'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white' | 'blackBright' | 'gray' | 'grey' | 'redBright' | 'greenBright' | 'yellowBright' | 'blueBright' | 'magentaBright' | 'cyanBright' | 'whiteBright' | 'bgBlack' | 'bgRed' | 'bgGreen' | 'bgYellow' | 'bgBlue' | 'bgMagenta' | 'bgCyan' | 'bgWhite' | 'bgBlackBright' | 'bgGray' | 'bgGrey' | 'bgRedBright' | 'bgGreenBright' | 'bgYellowBright' | 'bgBlueBright' | 'bgMagentaBright' | 'bgCyanBright' | 'bgWhiteBright'
+
+export interface NuxtOptionsCli {
+    badgeMessages: string[]
+    bannerColor: keyof Chalk & ChalkColor
+}

package/packages/types/config/env.d.ts

@@ -0,0 +1,6 @@
+/**
+ * NuxtOptionsEnv
+ * Documentation: https://nuxtjs.org/api/configuration-env
+ */
+
+export type NuxtOptionsEnv = Record<string, string>

package/packages/types/config/features.d.ts

@@ -0,0 +1,19 @@
+export interface NuxtOptionsFeatures {
+  asyncData?: boolean
+  clientOnline?: boolean
+  clientPrefetch?: boolean
+  /**
+   * @deprecated
+   */
+  clientUseUrl?: boolean
+  componentAliases?: boolean
+  componentClientOnly?: boolean
+  deprecations?: boolean
+  fetch?: boolean
+  layouts?: boolean
+  meta?: boolean
+  middleware?: boolean
+  store?: boolean
+  transitions?: boolean
+  validate?: boolean
+}

package/packages/types/config/fetch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * NuxtOptionsFetch
+ * Documentation: ?
+ */
+
+export interface NuxtOptionsFetch {
+  client?: boolean
+  server?: boolean
+}

package/packages/types/config/generate.d.ts

@@ -0,0 +1,28 @@
+import { GlobbyOptions } from 'globby'
+
+/**
+ * NuxtOptionsGenerate
+ * Documentation: https://nuxtjs.org/api/configuration-generate
+ */
+
+type NuxtOptionsGenerateRoute = string | { route: string, payload: any }
+
+type NuxtOptionsGenerateRoutesFunction = () => (Promise<NuxtOptionsGenerateRoute[]> | NuxtOptionsGenerateRoute[])
+type NuxtOptionsGenerateRoutesFunctionWithCallback = (callback: (err: Error, routes: NuxtOptionsGenerateRoute[]) => void) => void
+
+export interface NuxtOptionsGenerate {
+  concurrency?: number
+  crawler?: boolean
+  devtools?: boolean
+  dir?: string
+  exclude?: RegExp[]
+  fallback?: string | boolean
+  interval?: number
+  routes?: NuxtOptionsGenerateRoute[] | NuxtOptionsGenerateRoutesFunction | NuxtOptionsGenerateRoutesFunctionWithCallback
+  subFolders?: boolean
+  cache?: false | {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    ignore?: string[] | Function,
+    globbyOptions?: GlobbyOptions
+  }
+}

package/packages/types/config/globals.d.ts

@@ -0,0 +1,7 @@
+/**
+ * NuxtOptionsGlobals
+ * Documentation: https://nuxtjs.org/api/configuration-globals
+ */
+
+type NuxtOptionsCustomizableGlobalName = 'id' | 'nuxt' | 'context' | 'pluginPrefix' | 'readyCallback' | 'loadedCallback'
+export type NuxtOptionsGlobals = { [key in NuxtOptionsCustomizableGlobalName]?: (globalName: string) => string }

package/packages/types/config/head.d.ts

@@ -0,0 +1,9 @@
+/**
+ * NuxtOptionsHead
+ * Documentation: https://nuxtjs.org/api/configuration-head
+ *                https://github.com/declandewet/vue-meta#recognized-metainfo-properties
+ */
+
+import { MetaInfo } from 'vue-meta'
+
+export type NuxtOptionsHead = MetaInfo | (() => MetaInfo)

package/packages/types/config/hooks.d.ts

@@ -0,0 +1,53 @@
+/**
+ * NuxtOptionsHooks
+ * Documentation: https://nuxtjs.org/api/configuration-hooks
+ *                https://nuxtjs.org/api/internals-nuxt#hooks
+ *                https://nuxtjs.org/api/internals-renderer#hooks
+ *                https://nuxtjs.org/api/internals-module-container#hooks
+ *                https://nuxtjs.org/api/internals-builder#hooks
+ *                https://nuxtjs.org/api/internals-generator#hooks
+ */
+
+import { Server as ConnectServer } from 'connect'
+
+export interface NuxtOptionsHooks {
+  build?: {
+    before?(builder: any, buildOptions: any): void
+    compile?(params: { name: 'client' | 'server', compiler: any }): void
+    compiled?(params: { name: 'client' | 'server', compiler: any, stats: any }): void
+    done?(builder: any): void
+    extendRoutes?(routes: any, resolve: any): void
+    templates?(params: { templateFiles: any, templateVars: any, resolve: any }): void
+  }
+  close?(nuxt: any): void
+  error?(error: Error): void
+  generate?: {
+    before?(generator: any, generateOptions: any): void
+    distCopied?(generator: any): void
+    distRemoved?(generator: any): void
+    done?(generator: any): void
+    extendRoutes?(routes: any): void
+    page?(params: { route: any, path: any, html: any }): void
+    routeCreated?(route: any, path: any, errors: any): void
+    routeFailed?(route: any, errors: any): void
+  }
+  listen?(server: any, params: { host: string, port: number | string }): void
+  modules?: {
+    before?(moduleContainer: any, options: any): void
+    done?(moduleContainer: any): void
+  }
+  ready?(nuxt: any): void
+  render?: {
+    before?(renderer: any, options: any): void
+    done?(renderer: any): void
+    errorMiddleware?(app: ConnectServer): void
+    resourcesLoaded?(resources: any): void
+    route?(url: string, result: any, context: any): void
+    routeContext?(context: any): void
+    routeDone?(url: string, result: any, context: any): void
+    beforeResponse?(url: string, result: any, context: any): void
+    setupMiddleware?(app: ConnectServer): void
+  }
+}
+
+// Hooks need too many core typedefs to be 100% defined

package/packages/types/config/index.d.ts

@@ -0,0 +1,77 @@
+import { Transition } from '../app'
+import { NuxtOptionsBuild } from './build'
+import { NuxtOptionsCli } from './cli'
+import { NuxtOptionsEnv } from './env'
+import { NuxtOptionsFeatures } from './features'
+import { NuxtOptionsFetch } from './fetch'
+import { NuxtOptionsGenerate } from './generate'
+import { NuxtOptionsHead } from './head'
+import { NuxtOptionsHooks } from './hooks'
+import { NuxtOptionsGlobals } from './globals'
+import { NuxtOptionsLoading, NuxtOptionsLoadingIndicator } from './loading'
+import { NuxtOptionsModule } from './module'
+import { NuxtOptionsPlugin } from './plugin'
+import { NuxtOptionsRender } from './render'
+import { NuxtOptionsRouter } from './router'
+import { NuxtOptionsRuntimeConfig } from './runtime'
+import { NuxtOptionsServer } from './server'
+import { NuxtOptionsServerMiddleware } from './server-middleware'
+import { NuxtOptionsVueConfiguration } from './vue-configuration'
+import { NuxtOptionsWatchers } from './watchers'
+
+export { Module } from './module'
+export { ServerMiddleware } from './server-middleware'
+
+/**
+ * @deprecated Use NuxtConfig instead
+*/
+export interface Configuration extends Record<string, any> {}
+
+export interface NuxtOptions extends Configuration {
+  build: NuxtOptionsBuild
+  buildDir: string
+  buildModules: NuxtOptionsModule[]
+  cli: NuxtOptionsCli
+  css: string[]
+  dev: boolean
+  dir: { [key in 'app' | 'assets' | 'layouts' | 'middleware' | 'pages' | 'static' | 'store']?: string }
+  env: NuxtOptionsEnv
+  extensions: string[]
+  features: NuxtOptionsFeatures
+  fetch: NuxtOptionsFetch
+  generate: NuxtOptionsGenerate
+  export: NuxtOptionsGenerate
+  globalName: string
+  globals: NuxtOptionsGlobals
+  head: NuxtOptionsHead
+  hooks: NuxtOptionsHooks
+  ignorePrefix: string
+  ignore: string[]
+  layoutTransition: Transition
+  loading: NuxtOptionsLoading | false | string
+  loadingIndicator: NuxtOptionsLoadingIndicator | false | string
+  /** @deprecated Use ssr option instead */
+  mode: 'spa' | 'universal'
+  target: 'server' | 'static'
+  modern: 'client' | 'server' | boolean
+  modules: NuxtOptionsModule[]
+  modulesDir: string[]
+  plugins: NuxtOptionsPlugin[]
+  privateRuntimeConfig: NuxtOptionsRuntimeConfig
+  publicRuntimeConfig: NuxtOptionsRuntimeConfig
+  render: NuxtOptionsRender
+  rootDir: string
+  router: NuxtOptionsRouter
+  server: NuxtOptionsServer
+  serverMiddleware: NuxtOptionsServerMiddleware[]
+  srcDir: string
+  ssr: boolean
+  transition: Transition
+  vue: {
+    config?: NuxtOptionsVueConfiguration
+  }
+  watch: string[]
+  watchers: NuxtOptionsWatchers
+}
+
+export interface NuxtConfig extends Partial<NuxtOptions> {}

package/packages/types/config/loading.d.ts

@@ -0,0 +1,27 @@
+/**
+ * NuxtOptionsLoading
+ * Documentation: https://nuxtjs.org/api/configuration-loading
+ */
+
+export interface NuxtOptionsLoading {
+  color?: string
+  continuous?: boolean
+  css?: boolean
+  duration?: number
+  failedColor?: string
+  height?: string
+  rtl?: boolean
+  throttle?: number
+}
+
+/**
+ * NuxtOptionsLoadingIndicator
+ * Documentation: https://nuxtjs.org/api/configuration-loading-indicator
+ */
+
+export interface NuxtOptionsLoadingIndicator {
+  background?: string
+  color?: string
+  color2?: string
+  name?: string
+}