Options
All
  • Public
  • Public/Protected
  • All
Menu

Index

Namespaces

Enumerations

Enumeration members

Classes

Interfaces

Type aliases

Variables

Functions

Enumeration members

DATA = "DATA"
ENABLED = "ENABLED"
ElectronPreload = 2
ElectronRenderer = 1
MESSAGE = "MESSAGE"
Mapping = "mapping"
STATE = "STATE"
SUBTASK = "SUBTASK"
SandboxedPreload = 3
TITLE = "TITLE"
Tag = "tag"
Web = 0

Type aliases

API<Request_1, Response_1>: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/types/index".Middleware<Request_1, Response_1> & AdditionalMethods<Request_1, Response_1>

Type parameters

AdditionalPropertiesError: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<"additionalProperties", { additionalProperty: string }, AnySchema>
Alias: string | false | string[]
AliasOptionNewRequest: string | false | string[]
AnyOfError: ErrorNoParams<"anyOf", AnySchema[]>

Type parameters

  • T = any

AnymatchFn: (testString: string) => boolean

Type declaration

    • (testString: string): boolean
    • Parameters

      • testString: string

      Returns boolean

AnymatchMatcher: AnymatchPattern | AnymatchPattern[]
AnymatchPattern: string | RegExp | AnymatchFn
Append<T, U>: { 0: [U]; 1: [T[0], U]; 2: [T[0], T[1], U]; 3: [T[0], T[1], T[2], U]; 4: [T[0], T[1], T[2], T[3], U]; 5: [T[0], T[1], T[2], T[3], T[4], U]; 6: [T[0], T[1], T[2], T[3], T[4], T[5], U]; 7: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], U]; 8: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], U] }[Measure<T["length"]>]

Type parameters

  • T: any[]

  • U

Argument: { configs: ArgumentConfig[]; description: string; multiple: boolean; simpleType: "string" | "number" | "boolean" }

Type declaration

  • configs: ArgumentConfig[]
  • description: string
  • multiple: boolean
  • simpleType: "string" | "number" | "boolean"
ArgumentConfig: { description: string; multiple: boolean; path: string; type: "enum" | "string" | "path" | "number" | "boolean" | "RegExp" | "reset"; values?: any[] }

Type declaration

  • description: string
  • multiple: boolean
  • path: string
  • type: "enum" | "string" | "path" | "number" | "boolean" | "RegExp" | "reset"
  • Optional values?: any[]
AsArray<T>: T extends any[] ? T : [T]

Type parameters

  • T

AssetFilterItemTypes: string | RegExp | ((name: string, asset: StatsAsset) => boolean)
AssetInfo: KnownAssetInfo & Record<string, any>
AssignmentOperator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??="
AsyncFormatValidator<T>: (data: T) => Promise<boolean>

Type parameters

  • T: string | number

Type declaration

    • (data: T): Promise<boolean>
    • Parameters

      • data: T

      Returns Promise<boolean>

AuxiliaryComment: string | LibraryCustomUmdCommentObject
BannerPluginArgument: string | BannerPluginOptions | ((data: { chunk: Chunk; filename: string; hash: string }) => string)
BaseSignOptions: Readonly<{ app: string; identity?: string; keychain?: string; platform?: ElectronMacPlatform }>
BinaryOperator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof"
Block: Code | (() => void)
BuildMeta: KnownBuildMeta & Record<string, any>
CacheOptionsNormalized: false | FileCacheOptions | MemoryCacheOptions
Callback<E, T>: (error: E | null, result?: T) => void

Type parameters

  • E

  • T

Type declaration

    • (error: E | null, result?: T): void
    • Parameters

      • error: E | null
      • Optional result: T

      Returns void

Cell<T>: undefined | T

Type parameters

  • T

ChunkGroupOptions: RawChunkGroupOptions & { name?: string }
ChunkId: string | number
ClientConfiguration: { logging?: "none" | "error" | "warn" | "info" | "log" | "verbose"; overlay?: boolean | { errors?: boolean; warnings?: boolean }; progress?: boolean; reconnect?: number | boolean; webSocketTransport?: string; webSocketURL?: string | WebSocketURL }

Type declaration

  • Optional logging?: "none" | "error" | "warn" | "info" | "log" | "verbose"
  • Optional overlay?: boolean | { errors?: boolean; warnings?: boolean }
  • Optional progress?: boolean
  • Optional reconnect?: number | boolean
  • Optional webSocketTransport?: string
  • Optional webSocketURL?: string | WebSocketURL
CodeArg: SafeExpr | string | undefined
CodeItem: Name | string | number | boolean | null
CodeValue: undefined | null | string | number | bigint | boolean | Function | RegExp | RuntimeValue | {} | RecursiveArrayOrRecord<undefined | null | string | number | bigint | boolean | Function | RegExp | RuntimeValue>[]
CodeValuePrimitive: undefined | null | string | number | bigint | boolean | Function | RegExp
Comparison: "<=" | ">=" | "<" | ">"
CompileKeywordFunc: (schema: any, parentSchema: AnySchemaObject, it: SchemaObjCxt) => DataValidateFunction

Type declaration

Configuration: { allowedHosts?: string | string[]; bonjour?: boolean | Record<string, never> | "/home/runner/work/forge/forge/node_modules/bonjour-service/dist/index"; client?: boolean | ClientConfiguration; compress?: boolean; devMiddleware?: DevMiddlewareOptions<Request<"/home/runner/work/forge/forge/node_modules/@types/express-serve-static-core/index", any, any, ParsedQs, Record<string, any>>, Response<any, Record<string, any>>>; headers?: Headers | ((req: Request, res: Response, context: DevMiddlewareContext<Request, Response>) => Headers); historyApiFallback?: boolean | "/home/runner/work/forge/forge/node_modules/@types/connect-history-api-fallback/index"; host?: string; hot?: boolean | "only"; http2?: boolean; https?: boolean | ServerOptions; ipc?: string | boolean; liveReload?: boolean; magicHtml?: boolean; onAfterSetupMiddleware?: (devServer: Server) => void; onBeforeSetupMiddleware?: (devServer: Server) => void; onListening?: (devServer: Server) => void; open?: string | boolean | Open | (string | Open)[]; port?: Port; proxy?: ProxyConfigArrayItem | ProxyConfigMap | ProxyConfigArray; server?: string | ServerConfiguration; setupExitSignals?: boolean; setupMiddlewares?: (middlewares: Middleware[], devServer: Server) => Middleware[]; static?: string | boolean | Static | (string | Static)[]; watchFiles?: string | string[] | WatchFiles | (string | WatchFiles)[]; webSocketServer?: string | boolean | WebSocketServerConfiguration }

Type declaration

ConfigurationFactory: (env: string | Record<string, string | boolean | number> | unknown, args: Record<string, unknown>) => "/home/runner/work/forge/forge/node_modules/webpack/types".Configuration | Promise<"/home/runner/work/forge/forge/node_modules/webpack/types".Configuration>

Type declaration

ConnectionState: boolean | typeof TRANSITIVE_ONLY | typeof CIRCULAR_CONNECTION
Consumes: (string | ConsumesObject)[] | ConsumesObject
ContainerOptionsFormat<T>: Record<string, string | string[] | T> | (string | Record<string, string | string[] | T>)[]

Type parameters

  • T

ContainsError: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<"contains", { maxContains?: number; minContains: number }, AnySchema>
ContextMode: "weak" | "eager" | "lazy" | "lazy-once" | "sync" | "async-weak"
CreateOptions: { dot?: boolean; globOptions?: IOptions; ordering?: string; pattern?: string; unpack?: string; unpackDir?: string; transform?: any }

Type declaration

  • Optional dot?: boolean
  • Optional globOptions?: IOptions
  • Optional ordering?: string
  • Optional pattern?: string
  • Optional unpack?: string
  • Optional unpackDir?: string
  • transform?:function
    • transform(filePath: string): void | ReadWriteStream
    • Parameters

      • filePath: string

      Returns void | ReadWriteStream

CreateStatsOptionsContext: KnownCreateStatsOptionsContext & Record<string, any>

Type parameters

  • Request_1

  • Response_1

Type parameters

  • Request_1

  • Response_1

DiscrErrorObj<E>: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<"discriminator", { error: E; tag: string; tagValue: unknown }, string>

Type parameters

DiscriminatorError: DiscrErrorObj<Tag> | DiscrErrorObj<Mapping>
DllReferencePluginOptions: { context?: string; extensions?: string[]; manifest: string | DllReferencePluginOptionsManifest; name?: string; scope?: string; sourceType?: "var" | "assign" | "this" | "window" | "global" | "commonjs" | "commonjs2" | "commonjs-module" | "amd" | "amd-require" | "umd" | "umd2" | "jsonp" | "system"; type?: "object" | "require" } | { content: DllReferencePluginOptionsContent; context?: string; extensions?: string[]; name: string; scope?: string; sourceType?: "var" | "assign" | "this" | "window" | "global" | "commonjs" | "commonjs2" | "commonjs-module" | "amd" | "amd-require" | "umd" | "umd2" | "jsonp" | "system"; type?: "object" | "require" }
ElectronMacPlatform: "darwin" | "mas"
ElectronProcess: ChildProcess & { restarted: boolean }
EntryItem: string | string[]
EntryNormalized: (() => Promise<EntryStaticNormalized>) | EntryStaticNormalized
EntryOptions: { name?: string } & Omit<EntryDescriptionNormalized, "import">
EntryStatic: string | EntryObject | string[]
EnumError: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<"enum", { allowedValues: any[] }, any[] | { $data: string }>
EnumString<T>: [T] extends [never] ? null : T extends string ? string extends T ? null : T : null

gets only the string literals of a type or null if a type isn't a string literal

Type parameters

  • T

ErrorWithDetail: Error & { details?: string }
EvaluatedItems: number | true
EvaluatedProperties: { [ K in string]?: true } | true
ExportedVariableInfo: string | ScopeInfo | VariableInfo
Exposes: (string | ExposesObject)[] | ExposesObject
Expression: ExpressionMap[keyof ExpressionMap]
Extend: { formatExclusiveMaximum?: boolean; formatExclusiveMinimum?: boolean; formatMaximum?: number; formatMinimum?: number; link?: string; undefinedAsNull?: boolean }

Type declaration

  • Optional formatExclusiveMaximum?: boolean
  • Optional formatExclusiveMinimum?: boolean
  • Optional formatMaximum?: number
  • Optional formatMinimum?: number
  • Optional link?: string
  • Optional undefinedAsNull?: boolean
ExternalItem: string | RegExp | (ExternalItemObjectKnown & ExternalItemObjectUnknown) | ((data: ExternalItemFunctionData, callback: (err?: null | Error, result?: string | boolean | string[] | {}) => void) => void) | ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>)
ExternalsType: "import" | "var" | "module" | "assign" | "this" | "window" | "self" | "global" | "commonjs" | "commonjs2" | "commonjs-module" | "commonjs-static" | "amd" | "amd-require" | "umd" | "umd2" | "jsonp" | "system" | "promise" | "script" | "node-commonjs"
FakeHook<T>: T & FakeHookMarker

Type parameters

  • T

FilterItemTypes: string | RegExp | ((value: string) => boolean)
FinalizePackageTargetsHookFunction: (targets: TargetDefinition[], callback: HookFunctionErrorCallback) => void

Type declaration

FixedSizeArray<T, U>: T extends 0 ? void[] : ReadonlyArray<U> & { 0: U; length: T }

Type parameters

  • T: number

  • U

ForgeHookFn<Hook>: Hook extends keyof ForgeSimpleHookSignatures ? ForgeSimpleHookFn<Hook> : Hook extends keyof ForgeMutatingHookSignatures ? ForgeMutatingHookFn<Hook> : never

Type parameters

ForgeHookMap: { [ S in ForgeHookName]?: ForgeHookFn<S> }
ForgeListrTaskDefinition: ListrTask<never>
ForgeMultiHookMap: { [ S in ForgeHookName]?: ForgeHookFn<S> | ForgeHookFn<S>[] }
ForgeMutatingHookFn<Hook>: (forgeConfig: ResolvedForgeConfig, ...args: ForgeMutatingHookSignatures[Hook]) => Promise<ForgeMutatingHookSignatures[Hook][0] | undefined>

Type parameters

Type declaration

ForgePackagerOptions: Omit<Options, "dir" | "arch" | "platform" | "out" | "electronVersion">
ForgeRebuildOptions: Omit<RebuildOptions, "buildPath" | "electronVersion" | "arch">
ForgeSimpleHookFn<Hook>: (forgeConfig: ResolvedForgeConfig, ...args: ForgeSimpleHookSignatures[Hook]) => Promise<void>

Type parameters

Type declaration

FormatCompare<T>: (data1: T, data2: T) => number | undefined

Type parameters

  • T: string | number

Type declaration

    • (data1: T, data2: T): number | undefined
    • Parameters

      • data1: T
      • data2: T

      Returns number | undefined

FormatError: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<"format", { format: string }, string | { $data: string }>
FormatValidator<T>: (data: T) => boolean

Type parameters

  • T: string | number

Type declaration

    • (data: T): boolean
    • Parameters

      • data: T

      Returns boolean

FullTap: Tap & { fn: Function; type: "sync" | "async" | "promise" }
GetRouteParameter<S>: RemoveTail<RemoveTail<RemoveTail<S, `/${string}`>, `-${string}`>, `.${string}`>

Type parameters

  • S: string

Headers: { key: string; value: string }[] | Record<string, string | string[]>
HookFactory<H>: (key: any, hook?: H) => H

Type parameters

  • H

Type declaration

    • (key: any, hook?: H): H
    • Parameters

      • key: any
      • Optional hook: H

      Returns H

HookFunction: (buildPath: string, electronVersion: string, platform: TargetArch, arch: TargetArch, callback: HookFunctionErrorCallback) => void

Type declaration

    • A function that is called on the completion of a packaging stage.

      By default, the functions are called in parallel (via Promise.all). If you need the functions called serially, there is a utility function provided. Please note that callback-style functions are not supported by serialHooks. For example:

      const packager = require('@electron/packager')
      const { serialHooks } = require('@electron/packager/src/hooks')

      packager({
      // ...
      afterCopy: [serialHooks([
      (buildPath, electronVersion, platform, arch) => {
      return new Promise((resolve, reject) => {
      setTimeout(() => {
      console.log('first function')
      resolve()
      }, 1000)
      })
      },
      (buildPath, electronVersion, platform, arch) => {
      console.log('second function')
      }
      ])],
      // ...
      })

      For real-world examples of HookFunctions, see the list of related plugins.

      Parameters

      Returns void

HookFunction: (fileToSign: string) => void | Promise<void>

Type declaration

    • (fileToSign: string): void | Promise<void>
    • Parameters

      • fileToSign: string

      Returns void | Promise<void>

HookFunctionErrorCallback: (err?: Error | null) => void

Type declaration

    • (err?: Error | null): void
    • Parameters

      • Optional err: Error | null

      Returns void

IPv4Range: IPvXRangeDefaults | "broadcast" | "carrierGradeNat" | "private"
IPv6Range: IPvXRangeDefaults | "uniqueLocal" | "ipv4Mapped" | "rfc6145" | "rfc6052" | "6to4" | "teredo"
IPvXRangeDefaults: "unicast" | "unspecified" | "multicast" | "linkLocal" | "loopback" | "reserved"
IfSet<X>: X extends UnsetAdditionalOptions ? {} : X

Type parameters

  • X

IgnoreFunction: (path: string) => boolean

Type declaration

    • (path: string): boolean
    • A predicate function that, given an absolute file path, returns true if the file should be ignored, or false if the file should be kept. This does not use any of the default ignored files/directories listed for the ignore option.

      Parameters

      • path: string

      Returns boolean

IgnorePluginOptions: { contextRegExp?: RegExp; resourceRegExp: RegExp } | { checkResource: any }
ImportSource: undefined | null | string | SimpleLiteral | RegExpLiteral | BigIntLiteral
InnerCallback<E, T>: (error?: E | null | false, result?: T) => void

Type parameters

  • E

  • T

Type declaration

    • (error?: E | null | false, result?: T): void
    • Parameters

      • Optional error: E | null | false
      • Optional result: T

      Returns void

InnerStartResult: ElectronProcess | string | string[] | false
Interceptor: (buffer: Buffer, proxyRes: http.IncomingMessage, req: http.IncomingMessage, res: http.ServerResponse) => Promise<Buffer | string>

Type declaration

    • (buffer: Buffer, proxyRes: http.IncomingMessage, req: http.IncomingMessage, res: http.ServerResponse): Promise<Buffer | string>
    • Parameters

      • buffer: Buffer
      • proxyRes: http.IncomingMessage
      • req: http.IncomingMessage
      • res: http.ServerResponse

      Returns Promise<Buffer | string>

InternalCell<T>: T | typeof TOMBSTONE | typeof UNDEFINED_MARKER

Type parameters

  • T

IsElements<T>: false extends IsUnion<T> ? [T] extends [readonly unknown[]] ? undefined extends T[0.5] ? false : true : false : false

true only if all types are array types (not tuples)

Type parameters

  • T

IsEnum<T>: null extends EnumString<Exclude<T, null>> ? false : true

true if type is a union of string literals

Type parameters

  • T

IsRecord<T, Union>: Union extends IsUnion<Exclude<T, null>> ? null extends EnumString<keyof Exclude<T, null>> ? false : true : false

true if type is a proeprties type and Union is false, or type is a discriminator type and Union is true

Type parameters

  • T

  • Union: boolean

IsUnion<T>: IsUnion_<T>

Type parameters

  • T

IsUnion_<T, U>: false extends T extends unknown ? [U] extends [T] ? false : true : never ? false : true

type is true if T is a union type

Type parameters

  • T

  • U: T = T

IsValues<T>: false extends IsUnion<Exclude<T, null>> ? TypeEquality<keyof Exclude<T, null>, string> : false

true if the the type is a values type

Type parameters

  • T

JSONType<T, IsPartial>: IsPartial extends true ? T | undefined : T

Type parameters

  • T: string

  • IsPartial: boolean

JTDDataDef<S, D>: (S extends { ref: string } ? D extends { [ K in S["ref"]]: infer V } ? JTDDataDef<V, D> : never : S extends { type: NumberType } ? number : S extends { type: "boolean" } ? boolean : S extends { type: "string" } ? string : S extends { type: "timestamp" } ? string | Date : S extends { enum: readonly infer E[] } ? string extends E ? never : [E] extends [string] ? E : never : S extends { elements: infer E } ? JTDDataDef<E, D>[] : S extends { additionalProperties?: boolean; optionalProperties?: Record<string, unknown>; properties: Record<string, unknown> } ? { -readonly [ K in keyof S["properties"]]-?: JTDDataDef<S["properties"][K], D> } & { -readonly [ K in keyof S["optionalProperties"]]?: JTDDataDef<S["optionalProperties"][K], D> } & ([S["additionalProperties"]] extends [true] ? Record<string, unknown> : unknown) : S extends { additionalProperties?: boolean; optionalProperties: Record<string, unknown>; properties?: Record<string, unknown> } ? { -readonly [ K in keyof S["properties"]]-?: JTDDataDef<S["properties"][K], D> } & { -readonly [ K in keyof S["optionalProperties"]]?: JTDDataDef<S["optionalProperties"][K], D> } & ([S["additionalProperties"]] extends [true] ? Record<string, unknown> : unknown) : S extends { values: infer V } ? Record<string, JTDDataDef<V, D>> : S extends { discriminator: infer M; mapping: Record<string, unknown> } ? [M] extends [string] ? { [ K in keyof S["mapping"]]: JTDDataDef<S["mapping"][K], D> & { [ KM in M]: K } }[keyof S["mapping"]] : never : unknown) | (S extends { nullable: true } ? null : never)

Type parameters

  • S

  • D: Record<string, unknown>

JTDDataType<S>: S extends { definitions: Record<string, unknown> } ? JTDDataDef<S, S["definitions"]> : JTDDataDef<S, Record<string, never>>

Type parameters

  • S

JTDSchemaType<T, D>: ((null extends EnumString<keyof D> ? never : ({ [ K in keyof D]: [T] extends [D[K]] ? { ref: K } : never }[keyof D] & { nullable?: false }) | (null extends T ? { [ K in keyof D]: [Exclude<T, null>] extends [Exclude<D[K], null>] ? { ref: K } : never }[keyof D] & { nullable: true } : never)) | (unknown extends T ? { nullable?: boolean } : never) | ((true extends NullTypeEquality<T, number> ? { type: NumberType } : true extends NullTypeEquality<T, boolean> ? { type: "boolean" } : true extends NullTypeEquality<T, string> ? { type: StringType } : true extends NullTypeEquality<T, Date> ? { type: "timestamp" } : true extends IsEnum<T> ? { enum: EnumString<Exclude<T, null>>[] } : true extends IsElements<Exclude<T, null>> ? T extends readonly infer E[] ? { elements: JTDSchemaType<E, D> } : never : true extends IsValues<T> ? T extends Record<string, infer V> ? { values: JTDSchemaType<V, D> } : never : true extends IsRecord<T, false> ? ([RequiredKeys<Exclude<T, null>>] extends [never] ? { properties?: Record<string, never> } : { properties: { [ K in RequiredKeys<T>]: JTDSchemaType<T[K], D> } }) & ([OptionalKeys<Exclude<T, null>>] extends [never] ? { optionalProperties?: Record<string, never> } : { optionalProperties: { [ K in OptionalKeys<T>]: JTDSchemaType<Exclude<T[K], undefined>, D> } }) & { additionalProperties?: boolean } : true extends IsRecord<T, true> ? { [ K in keyof Exclude<T, null>]-?: Exclude<T, null>[K] extends string ? { discriminator: K; mapping: { [ M in Exclude<T, null>[K]]: JTDSchemaType<Omit<T extends { [ C in K]: M } ? T : never, K>, D> } } : never }[keyof Exclude<T, null>] : never) & (null extends T ? { nullable: true } : { nullable?: false }))) & { definitions?: { [ K in keyof D]: JTDSchemaType<D[K], D> }; metadata?: Record<string, unknown> }

actual schema

Type parameters

  • T

  • D: Record<string, unknown> = Record<string, never>

JsonObject: {} & {}
JsonValue: null | string | number | boolean | JsonObject | JsonValue[]
KeyValue: {}

Type declaration

  • [key: string]: any
KeywordCxtParams: { [ P in string]?: Code | string | number }
Known: {} | [Known, ...Known[]] | Known[] | number | string | boolean | null
Kwd: "maximum" | "minimum" | "exclusiveMaximum" | "exclusiveMinimum"
LibraryExport: string | string[]
LibraryName: string | string[] | LibraryCustomUmdObject
LimitError: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<"maxItems" | "minItems" | "minProperties" | "maxProperties" | "minLength" | "maxLength", { limit: number }, number | { $data: string }>
LimitNumberError: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<Kwd, { comparison: Comparison; limit: number }, number | { $data: string }>
ListrBaseClassOptions<Ctx, Renderer, FallbackRenderer>: ListrOptions<Ctx> & ListrDefaultRendererOptions<Renderer> & ListrDefaultNonTTYRendererOptions<FallbackRenderer>

Parent class options.

Parent class has more options where you can also select the and set renderer and non-tty renderer.

Any subtasks will respect those options so they will be stripped of that properties.

Type parameters

ListrContext: any | undefined

Listr Default Context

ListrDefaultRenderer: typeof DefaultRenderer

Type of default renderer

ListrDefaultRendererValue: "default"

The default renderer value used in Listr2 applications

ListrEvent: { data?: string | boolean; type: Exclude<ListrEventType, "MESSAGE" | "DATA"> } | { data: string; type: DATA } | { data: Task<any, any>["message"]; type: MESSAGE }

The internal communication event.

ListrFallbackRenderer: typeof VerboseRenderer

Type of default fallback renderer

ListrFallbackRendererValue: "verbose"

Name of default fallback renderer

Returns the class type from friendly names of the renderers.

Type parameters

ListrGetRendererOptions<T>: T extends ListrDefaultRendererValue ? ListrDefaultRenderer["rendererOptions"] : T extends ListrSimpleRendererValue ? ListrSimpleRenderer["rendererOptions"] : T extends ListrFallbackRendererValue ? ListrFallbackRenderer["rendererOptions"] : T extends ListrSilentRenderer ? ListrSilentRenderer["rendererOptions"] : T extends ListrRendererFactory ? T["rendererOptions"] : never

Returns renderer global options depending on the renderer type.

Type parameters

ListrGetRendererTaskOptions<T>: T extends ListrDefaultRendererValue ? ListrDefaultRenderer["rendererTaskOptions"] : T extends ListrSimpleRendererValue ? ListrSimpleRenderer : T extends ListrFallbackRendererValue ? ListrFallbackRenderer["rendererTaskOptions"] : T extends ListrSilentRenderer ? ListrSilentRenderer["rendererTaskOptions"] : T extends ListrRendererFactory ? T["rendererTaskOptions"] : never

Returns renderer per task options depending on the renderer type.

Type parameters

ListrRendererFactory: typeof ListrRenderer

A renderer factory from the current type

Listr2 can process either the integrated renderers as string aliases, or utilize a compatible style renderer that extends the ListrRenderer abstract class.

ListrSilentRenderer: typeof SilentRenderer

Typeof silent renderer

ListrSilentRendererValue: "silent"

Silent rendere for internal usage

ListrSimpleRenderer: typeof SimpleRenderer

Typeof simple renderer

ListrSimpleRendererValue: "simple"

Simple renderer that simplifies things

ListrSubClassOptions<Ctx, Renderer>: ListrOptions<Ctx> & Omit<ListrDefaultRendererOptions<Renderer>, "renderer">

Sub class options.

Subtasks has reduced set options where the missing ones are explicitly set by the base class.

Type parameters

ListrTaskResult<Ctx>: string | Promise<any> | Listr<Ctx, ListrRendererValue, any> | Readable | NodeJS.ReadableStream | Observable<any>

Task can be set of sync or async function, an Observable or a stream.

Type parameters

  • Ctx

LocalRefs: { [ Ref in string]?: AnySchemaObject }
LogProviderCallback: (provider: LogProvider) => LogProvider

Type declaration

Logger: (...args: any[]) => void

Type declaration

    • (...args: any[]): void
    • Parameters

      • Rest ...args: any[]

      Returns void

LogicalOperator: "||" | "&&" | "??"
MacroKeywordFunc: (schema: any, parentSchema: AnySchemaObject, it: SchemaCxt) => AnySchema

Type declaration

MakeUniversalOpts: Parameters<typeof makeUniversalApp>[0]
MakeUniversalOpts: { arm64AppPath: string; force?: boolean; infoPlistsToIgnore?: string; mergeASARs?: boolean; outAppPath: string; singleArchFiles?: string; x64AppPath: string; x64ArchFiles?: string }

Type declaration

  • arm64AppPath: string

    Absolute file system path to the arm64 version of your application. E.g. /Foo/bar/MyApp_arm64.app

  • Optional force?: boolean

    Forcefully overwrite any existing files that are in the way of generating the universal application

  • Optional infoPlistsToIgnore?: string

    Minimatch pattern of paths that should not receive an injected ElectronAsarIntegrity value

  • Optional mergeASARs?: boolean

    Merge x64 and arm64 ASARs into one.

  • outAppPath: string

    Absolute file system path you want the universal app to be written to. E.g. /Foo/var/MyApp_universal.app

    If this file exists it will be overwritten ONLY if "force" is set to true

  • Optional singleArchFiles?: string

    Minimatch pattern of paths that are allowed to be present in one of the ASAR files, but not in the other.

  • x64AppPath: string

    Absolute file system path to the x64 version of your application. E.g. /Foo/bar/MyApp_x64.app

  • Optional x64ArchFiles?: string

    Minimatch pattern of binaries that are expected to be the same x64 binary in both of the ASAR files.

Matcher: string | RegExp | (string | RegExp)[]
Measure<T>: T extends 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 ? T : never

Type parameters

  • T: number

Middleware: { middleware: ExpressRequestHandler | ExpressErrorRequestHandler; name?: string; path?: string } | ExpressRequestHandler | ExpressErrorRequestHandler
ModuleFilterItemTypes: string | RegExp | ((name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean)
ModuleType: "prod" | "dev" | "optional"
MultipleOfError: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<"multipleOf", { multipleOf: number }, number | { $data: string }>
NextFunction: (err?: any) => void

Type declaration

    • (err?: any): void
    • Parameters

      • Optional err: any

      Returns void

NextHandleFunction: (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void

Type declaration

Node: false | NodeOptions
NormalizedStatsOptions: KnownNormalizedStatsOptions & Omit<StatsOptions, "context" | "chunkGroups" | "requestShortener" | "chunksSort" | "modulesSort" | "chunkModulesSort" | "nestedModulesSort" | "assetsSort" | "ids" | "cachedAssets" | "groupAssetsByEmitStatus" | "groupAssetsByPath" | "groupAssetsByExtension" | "assetsSpace" | "excludeAssets" | "excludeModules" | "warningsFilter" | "cachedModules" | "orphanModules" | "dependentModules" | "runtimeModules" | "groupModulesByCacheStatus" | "groupModulesByLayer" | "groupModulesByAttributes" | "groupModulesByPath" | "groupModulesByExtension" | "groupModulesByType" | "entrypoints" | "chunkGroupAuxiliary" | "chunkGroupChildren" | "chunkGroupMaxAssets" | "modulesSpace" | "chunkModulesSpace" | "nestedModulesSpace" | "logging" | "loggingDebug" | "loggingTrace" | "_env"> & Record<string, any>
NotKeywordError: ErrorNoParams<"not", AnySchema>
NullTypeEquality<T, E>: TypeEquality<T | null, E | null>

type is true if T or null is identically E or null

Type parameters

  • T

  • E

Nullable<T>: undefined extends T ? { const?: null; default?: T | null; enum?: Readonly<(T | null)[]>; nullable: true } : { const?: T; default?: T; enum?: Readonly<T[]> }

Type parameters

  • T

NumberType: "float32" | "float64" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32"

numeric strings

OfficialArch: "ia32" | "x64" | "armv7l" | "arm64" | "mips64el" | "universal"

Architectures that have been supported by the official Electron prebuilt binaries, past and present.

OfficialPlatform: "linux" | "win32" | "darwin" | "mas"

Platforms that have been supported by the official Electron prebuilt binaries, past and present.

OnCloseCallback: (proxyRes: "/home/runner/work/forge/forge/node_modules/webpack-dev-server/node_modules/http-proxy-middleware/dist/types".Response, proxySocket: net.Socket, proxyHead: any) => void
OnOpenCallback: (proxySocket: net.Socket) => void

Type declaration

    • (proxySocket: net.Socket): void
    • Parameters

      • proxySocket: net.Socket

      Returns void

OnProxyReqWsCallback: (proxyReq: http.ClientRequest, req: "/home/runner/work/forge/forge/node_modules/webpack-dev-server/node_modules/http-proxy-middleware/dist/types".Request, socket: net.Socket, options: ServerOptions, head: any) => void

Type declaration

OnlySignOptions: { binaries?: string[]; identityValidation?: boolean; ignore?: string | string[] | ((file: string) => boolean); preAutoEntitlements?: boolean; preEmbedProvisioningProfile?: boolean; provisioningProfile?: string; strictVerify?: boolean; type?: SigningDistributionType; version?: string; optionsForFile?: any }

Type declaration

  • Optional binaries?: string[]
  • Optional identityValidation?: boolean
  • Optional ignore?: string | string[] | ((file: string) => boolean)
  • Optional preAutoEntitlements?: boolean
  • Optional preEmbedProvisioningProfile?: boolean
  • Optional provisioningProfile?: string
  • Optional strictVerify?: boolean
  • Optional type?: SigningDistributionType
  • Optional version?: string
  • optionsForFile?:function
    • Parameters

      • filePath: string

      Returns PerFileSignOptions

Open: { app?: string | string[] | OpenApp; target?: string | string[] }

Type declaration

  • Optional app?: string | string[] | OpenApp
  • Optional target?: string | string[]
OptionalKeys<T>: { [ K in keyof T]-?: undefined extends T[K] ? K : never }[keyof T]

optional or undifined-able keys of an object

Type parameters

  • T

OsxSignOptions: Omit<SignOptions, "app" | "binaries" | "platform" | "version">

See the documentation for @electron/osx-sign for details.

OsxUniversalOptions: Omit<MakeUniversalOpts, "x64AppPath" | "arm64AppPath" | "outAppPath" | "force">

See the documentation for @electron/universal for details.

PatternError: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<"pattern", { pattern: string }, string | { $data: string }>
PerFileSignOptions: { entitlements?: string | string[]; hardenedRuntime?: boolean; requirements?: string; signatureFlags?: string | string[]; timestamp?: string }

Any missing options will use the default values, providing a partial structure will shallow merge with the default values.

Type declaration

  • Optional entitlements?: string | string[]

    The entitlements file to use when signing this file

  • Optional hardenedRuntime?: boolean

    Whether to enable hardened runtime for this file. Enabled by default.

  • Optional requirements?: string

    The designated requirements to embed when signing this file

  • Optional signatureFlags?: string | string[]

    See --options of the "codesign" command.

  • Optional timestamp?: string

    The timestamp server to use when signing, by default uses the Apple provided timestamp server.

Plugin: undefined | null | false | "" | 0 | { apply: any } | ((this: Resolver, arg1: Resolver) => void)
Port: number | string | "auto"
PostFormatter: (formattedError: string, error: SchemaUtilErrorObject) => string

Type declaration

Problem: { argument: string; expected?: string; index?: number; path: string; type: ProblemType; value?: any }

Type declaration

  • argument: string
  • Optional expected?: string
  • Optional index?: number
  • path: string
  • type: ProblemType
  • Optional value?: any
ProblemType: "unknown-argument" | "unexpected-non-array-in-path" | "unexpected-non-object-in-path" | "multiple-values-unexpected" | "invalid-value"
ProblemType: "unknown-argument" | "unexpected-non-array-in-path" | "unexpected-non-object-in-path" | "multiple-values-unexpected" | "invalid-value"
ProgressPluginArgument: ProgressPluginOptions | ((percentage: number, msg: string, ...args: string[]) => void)
PromptOptions<T>: Unionize<{ [ K in PromptTypes]-?: T extends true ? { type: K } & PromptOptionsType<K> & { name: string | (() => string) } : { type: K } & PromptOptionsType<K> }> | (({ type: string } & T) extends true ? PromptOptionsType<string> & { name: string | (() => string) } : PromptOptionsType<string>)

Returns all the prompt options depending on the type selected.

Type parameters

  • T: boolean = false

PromptOptionsType<T>: T extends keyof PromptOptionsMap ? PromptOptionsMap[T] : T extends string ? BasePromptOptions & Record<PropertyKey, unknown> : any

Type parameters

  • T

PromptTypes: "AutoComplete" | "BasicAuth" | "Confirm" | "Editable" | "Form" | "Input" | "Invisible" | "List" | "MultiSelect" | "Numeral" | "Password" | "Quiz" | "Scale" | "Select" | "Snippet" | "Sort" | "Survey" | "Text" | "Toggle"
PropertyDependencies: { [ K in string]?: string[] }
Provides: (string | ProvidesObject)[] | ProvidesObject
ProxyConfigArray: (ProxyConfigArrayItem | ((req?: Request, res?: Response, next?: Server.NextFunction) => ProxyConfigArrayItem))[]
ProxyConfigArrayItem: { context?: HttpProxyMiddlewareOptionsFilter; path?: HttpProxyMiddlewareOptionsFilter } & { bypass?: ByPass } & HttpProxyMiddlewareOptions
ProxyConfigMap: {}

Type declaration

ProxyTargetUrl: string | Partial<url.Url>
RebuildMode: "sequential" | "parallel"
RecursiveArrayOrRecord<T>: {} | RecursiveArrayOrRecord<T>[] | T

Type parameters

  • T

Remotes: (string | RemotesObject)[] | RemotesObject
RemoveTail<S, Tail>: S extends `${infer P}${Tail}` ? P : S

Type parameters

  • S: string

  • Tail: string

RequiredError: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<"required", { missingProperty: string }, string[] | { $data: string }>
RequiredInstanceOptions: { [ K in "strictSchema" | "strictNumbers" | "strictTypes" | "strictTuples" | "strictRequired" | "inlineRefs" | "loopRequired" | "loopEnum" | "meta" | "messages" | "schemaId" | "addUsedSchema" | "validateSchema" | "validateFormats" | "int32range" | "unicodeRegExp" | "uriResolver"]: NonNullable<"/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".Options[K]> } & { code: InstanceCodeOptions }
RequiredKeys<T>: { [ K in keyof T]-?: undefined extends T[K] ? never : K }[keyof T]

required keys of an object, not undefined

Type parameters

  • T

ResolveOptionsWithDependencyType: "/home/runner/work/forge/forge/node_modules/webpack/types".ResolveOptions & { dependencyType?: string; resolveToContext?: boolean }
ResolveRequest: BaseResolveRequest & Partial<ParsedIdentifier>
ResolverWithOptions: Resolver & WithOptions
ResultInvalid: -2
ResultUnsatisfiable: -1
Rule: string | RegExp
RuleSetConditionOrConditions: string | RegExp | ((value: string) => boolean) | RuleSetLogicalConditions | RuleSetCondition[]
RuntimeCondition: undefined | string | boolean | SortableSet<string>
RuntimeSpec: undefined | string | SortableSet<string>
SafeExpr: Code | number | boolean | null
SafeExpr: Code | number | boolean | null
SchemaRefs: { [ Ref in string]?: SchemaEnv | AnySchema }
SchemaUtilErrorObject: ErrorObject & { children?: ErrorObject[] }
ScopeStore: Record<string, ValueReference[] | undefined>
ScopeValueSets: { [ Prefix in string]?: Set<ValueScopeName> }
ScopeValues: { [ Prefix in string]?: Map<unknown, ValueScopeName> }
ServerConfiguration: { options?: ServerOptions; type?: string }

Type declaration

ServerOptions: ServerOptions & { spdy?: { plain?: boolean; protocol?: string; protocols?: string[]; ssl?: boolean; x-forwarded-for?: string } }
ServerOptionsHttps<Request, Response>: SecureContextOptions & TlsOptions & ServerOptionsImport<Request, Response>

Type parameters

  • Request: typeof IncomingMessage = typeof IncomingMessage

  • Response: typeof ServerResponse = typeof ServerResponse

Shared: (string | SharedObject)[] | SharedObject
SignOptions: Readonly<OnlySignOptions & BaseSignOptions>
SigningDistributionType: "development" | "distribution"
SomeJTDSchemaType: ({ ref: string } | { type: NumberType | StringType | "boolean" } | { enum: string[] } | { elements: SomeJTDSchemaType } | { values: SomeJTDSchemaType } | { additionalProperties?: boolean; optionalProperties?: Record<string, SomeJTDSchemaType>; properties: Record<string, SomeJTDSchemaType> } | { additionalProperties?: boolean; optionalProperties: Record<string, SomeJTDSchemaType>; properties?: Record<string, SomeJTDSchemaType> } | { discriminator: string; mapping: Record<string, SomeJTDSchemaType> } | {}) & { definitions?: Record<string, SomeJTDSchemaType>; metadata?: Record<string, unknown>; nullable?: boolean }

Generic JTD Schema without inference of the represented type

StartResult: InnerStartResult | { result: InnerStartResult; tasks: ForgeListrTaskDefinition[] }
StartupRenderContext: RenderContext & { inlined: boolean }
Static: { directory?: string; publicPath?: string | string[]; serveIndex?: boolean | "/home/runner/work/forge/forge/node_modules/@types/serve-index/index"; staticOptions?: "/home/runner/work/forge/forge/node_modules/@types/serve-static/index"; watch?: boolean | ("/home/runner/work/forge/forge/node_modules/chokidar/types/index" & { aggregateTimeout?: number; ignored?: Server.WatchOptions["ignored"]; poll?: number | boolean }) }

Type declaration

StatsAsset: KnownStatsAsset & Record<string, any>
StatsCompilation: KnownStatsCompilation & Record<string, any>
StatsError: KnownStatsError & Record<string, any>
StatsFactoryContext: KnownStatsFactoryContext & Record<string, any>
StatsModule: KnownStatsModule & Record<string, any>
StatsPrinterContext: KnownStatsPrinterContext & Record<string, any>
StatsValue: boolean | StatsOptions | "none" | "verbose" | "summary" | "errors-only" | "errors-warnings" | "minimal" | "normal" | "detailed"
StrictNullChecksWrapper<Name, Type>: undefined extends null ? `strictNullChecks must be true in tsconfig to use ${Name}` : Type

Type parameters

  • Name: string

  • Type

StringType: "string" | "timestamp"

string strings

Tap: TapOptions & { name: string }
TapOptions: { before?: string; stage?: number }

Type declaration

  • Optional before?: string
  • Optional stage?: number
TargetArch: OfficialArch | string
TargetDefinition: { arch: TargetArch; platform: TargetPlatform }

Type declaration

TargetPlatform: OfficialPlatform | string
TeardownLogic: Subscription | Unsubscribable | (() => void) | void
TraceOptions: { category: string; extraDetails?: Record<string, string>; name: string; newRoot?: boolean }

Type declaration

  • category: string
  • Optional extraDetails?: Record<string, string>
  • name: string
  • Optional newRoot?: boolean
TypeEquality<T, E>: [T] extends [E] ? [E] extends [T] ? true : false : false

type is true if T is identically E

Type parameters

  • T

  • E

UnaryOperator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete"
UncheckedJSONSchemaType<T, IsPartial>: ({ anyOf: readonly UncheckedJSONSchemaType<T, IsPartial>[] } | { oneOf: readonly UncheckedJSONSchemaType<T, IsPartial>[] } | ({ type: readonly (T extends number ? JSONType<"number" | "integer", IsPartial> : T extends string ? JSONType<"string", IsPartial> : T extends boolean ? JSONType<"boolean", IsPartial> : never)[] } & UnionToIntersection<T extends number ? NumberKeywords : T extends string ? StringKeywords : T extends boolean ? {} : never>) | ((T extends number ? { type: JSONType<"number" | "integer", IsPartial> } & NumberKeywords : T extends string ? { type: JSONType<"string", IsPartial> } & StringKeywords : T extends boolean ? { type: JSONType<"boolean", IsPartial> } : T extends readonly [any, ...any[]] ? { items: { readonly [ K in keyof T]-?: UncheckedJSONSchemaType<T[K], false> & Nullable<T[K]> } & { length: T["length"] }; minItems: T["length"]; type: JSONType<"array", IsPartial> } & ({ maxItems: T["length"] } | { additionalItems: false }) : T extends readonly any[] ? { additionalItems?: never; contains?: UncheckedPartialSchema<T[0]>; items: UncheckedJSONSchemaType<T[0], false>; maxContains?: number; maxItems?: number; minContains?: number; minItems?: number; type: JSONType<"array", IsPartial>; uniqueItems?: true } : T extends Record<string, any> ? { additionalProperties?: boolean | UncheckedJSONSchemaType<T[string], false>; dependencies?: { [ K in keyof T]?: Readonly<keyof T[]> | UncheckedPartialSchema<T> }; dependentRequired?: { [ K in keyof T]?: Readonly<keyof T[]> }; dependentSchemas?: { [ K in keyof T]?: UncheckedPartialSchema<T> }; maxProperties?: number; minProperties?: number; patternProperties?: Record<string, UncheckedJSONSchemaType<T[string], false>>; properties?: IsPartial extends true ? Partial<UncheckedPropertiesSchema<T>> : UncheckedPropertiesSchema<T>; propertyNames?: Omit<UncheckedJSONSchemaType<string, false>, "type"> & { type?: "string" }; type: JSONType<"object", IsPartial>; unevaluatedProperties?: boolean | UncheckedJSONSchemaType<T[string], false> } & (IsPartial extends true ? { required: Readonly<keyof T[]> } : [UncheckedRequiredMembers<T>] extends [never] ? { required?: Readonly<UncheckedRequiredMembers<T>[]> } : { required: Readonly<UncheckedRequiredMembers<T>[]> }) : T extends null ? { nullable: true; type: JSONType<"null", IsPartial> } : never) & { allOf?: Readonly<UncheckedPartialSchema<T>[]>; anyOf?: Readonly<UncheckedPartialSchema<T>[]>; else?: UncheckedPartialSchema<T>; if?: UncheckedPartialSchema<T>; not?: UncheckedPartialSchema<T>; oneOf?: Readonly<UncheckedPartialSchema<T>[]>; then?: UncheckedPartialSchema<T> })) & { $defs?: Record<string, UncheckedJSONSchemaType<Known, true>>; $id?: string; $ref?: string; definitions?: Record<string, UncheckedJSONSchemaType<Known, true>> }

Type parameters

  • T

  • IsPartial: boolean

UncheckedPartialSchema<T>: Partial<UncheckedJSONSchemaType<T, true>>

Type parameters

  • T

UncheckedPropertiesSchema<T>: { [ K in keyof T]-?: (UncheckedJSONSchemaType<T[K], false> & Nullable<T[K]>) | { $ref: string } }

Type parameters

  • T

UncheckedRequiredMembers<T>: { [ K in keyof T]-?: undefined extends T[K] ? never : K }[keyof T]

Type parameters

  • T

UnevaluatedPropertiesError: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<"unevaluatedProperties", { unevaluatedProperty: string }, AnySchema>
UnionToIntersection<U>: (U extends any ? (_: U) => void : never) extends (_: infer I) => void ? I : never

Type parameters

  • U

Unionize<T>: { [ P in keyof T]: T[P] }[keyof T]

Type parameters

  • T: Record<PropertyKey, unknown>

UniqueItemsError: "/home/runner/work/forge/forge/node_modules/webpack-dev-middleware/node_modules/ajv/dist/ajv".ErrorObject<"uniqueItems", { i: number; j: number }, boolean | { $data: string }>
UpdateOperator: "++" | "--"
UsageStateType: 0 | 1 | 2 | 3 | 4
UsedNames: Record<string, number | undefined>
UsedScopeValues: { [ Prefix in string]?: Map<ValueScopeName, UsedValueState | undefined> }
ValidationErrorConfiguration: { baseDataPath?: string; name?: string; postFormatter?: PostFormatter }

Type declaration

  • Optional baseDataPath?: string
  • Optional name?: string
  • Optional postFormatter?: PostFormatter
ValueReference: unknown
WarningFilterItemTypes: string | RegExp | ((warning: StatsError, value: string) => boolean)
WatchFiles: { options?: "/home/runner/work/forge/forge/node_modules/chokidar/types/index" & { aggregateTimeout?: number; ignored?: Server.WatchOptions["ignored"]; poll?: number | boolean }; paths: string | string[] }

Type declaration

WebSocketAlias: WebSocket
WebSocketServerConfiguration: { options?: Record<string, any>; type?: string | Function }

Type declaration

  • Optional options?: Record<string, any>
  • Optional type?: string | Function
WebpackMode: "production" | "development"

Type parameters

  • T

__TypeWebpackOptions: (data: object) => string | { ident?: string; loader?: string; options?: string | {} } | __TypeWebpackOptions | __Type_2[]

Type declaration

    • Parameters

      • data: object

      Returns string | { ident?: string; loader?: string