app-builder-lib

app-builder-lib

Version 26.15.3
Published 1 month ago
4.41 MB
41 dependencies
MIT license

Install

npm i app-builder-lib

yarn add app-builder-lib

pnpm add app-builder-lib

Overview

electron-builder lib

Index

Variables

variable DEFAULT_TARGET

const DEFAULT_TARGET: string;

variable DIR_TARGET

const DIR_TARGET: string;

Functions

function build

build: (
    options: PackagerOptions & PublishOptions,
    packager?: Packager
) => Promise<Array<string>>;

function buildForge

buildForge: (
    forgeOptions: ForgeOptions,
    options: PackagerOptions
) => Promise<string[]>;

function checkBuildRequestOptions

checkBuildRequestOptions: (options: PackagerOptions & PublishOptions) => void;

Classes

class AppInfo

class AppInfo {}

constructor

constructor(
    info: Packager,
    buildVersion: any,
    platformSpecificOptions?: PlatformSpecificBuildOptions,
    normalizeNfd?: boolean
);

property buildNumber

readonly buildNumber: string;

property buildVersion

readonly buildVersion: string;

property channel

readonly channel: string;

property companyName

readonly companyName: string;

property copyright

readonly copyright: string;

property description

readonly description: string;

property id

readonly id: string;

property linuxPackageName

readonly linuxPackageName: string;

property macBundleIdentifier

readonly macBundleIdentifier: string;

property name

readonly name: string;

property productFilename

readonly productFilename: string;

property productName

readonly productName: string;

property sanitizedName

readonly sanitizedName: string;

property sanitizedProductName

readonly sanitizedProductName: string;

property shortVersion

readonly shortVersion: string;

property shortVersionWindows

readonly shortVersionWindows: string;

property type

readonly type: string;

property updaterCacheDirName

readonly updaterCacheDirName: string;

property version

readonly version: string;

method computePackageUrl

computePackageUrl: () => Promise<string | null>;

method getVersionInWeirdWindowsForm

getVersionInWeirdWindowsForm: (isSetBuildNumber?: boolean) => string;

class LinuxPackager

class LinuxPackager extends PlatformPackager<LinuxConfiguration> {}

constructor

constructor(info: Packager);

property defaultTarget

readonly defaultTarget: string[];

property executableName

readonly executableName: string;

method createTargets

createTargets: (
    targets: Array<string>,
    mapper: (name: string, factory: (outDir: string) => Target) => void
) => void;

class MacPackager

class MacPackager extends PlatformPackager<MacConfiguration | MasConfiguration> {}

constructor

constructor(info: Packager);

property codeSigningInfo

readonly codeSigningInfo: MemoLazy<CreateKeychainOptions, CodeSigningInfo>;

property defaultTarget

readonly defaultTarget: string[];

property helper

readonly helper: MacTargetHelper;

method applyCommonInfo

applyCommonInfo: (appPlist: any, contentsPath: string) => Promise<void>;

method createTargets

createTargets: (
    targets: Array<string>,
    mapper: (name: string, factory: (outDir: string) => Target) => void
) => void;

method doFlat

doFlat: (
    appPath: string,
    outFile: string,
    identity: Identity,
    keychain: string | Nullish
) => Promise<any>;

method doPack

protected doPack: (config: DoPackOptions<MacConfiguration>) => Promise<any>;

method doSign

protected doSign: (
    opts: SignOptions,
    customSignOptions: MacConfiguration | MasConfiguration,
    identity: Identity | null
) => Promise<void>;

method expandArch

expandArch: (pattern: string, arch?: Arch | null) => string[];

method getElectronDestinationDir

getElectronDestinationDir: (appOutDir: string) => string;

method getElectronSrcDir

getElectronSrcDir: (dist: string) => string;

method getIconPath

getIconPath: () => Promise<string | null>;

method pack

pack: (
    outDir: string,
    arch: Arch,
    targets: Array<Target>,
    taskManager: AsyncTaskManager
) => Promise<void>;

method prepareAppInfo

protected prepareAppInfo: (appInfo: AppInfo) => AppInfo;

method signApp

protected signApp: (
    packContext: AfterPackContext,
    isAsar: boolean
) => Promise<boolean>;

class Packager

class Packager {}

constructor

constructor(options: PackagerOptions, cancellationToken?: CancellationToken);

property appDir

readonly appDir: string;

property appInfo

readonly appInfo: AppInfo;

property areNodeModulesHandledExternally

readonly areNodeModulesHandledExternally: boolean;

property buildResourcesDir

readonly buildResourcesDir: string;

property cancellationToken

readonly cancellationToken: CancellationToken;

property config

readonly config: Configuration;

property debugLogger

readonly debugLogger: DebugLogger;

property devMetadata

readonly devMetadata: Metadata;

property framework

readonly framework: Framework;

property isPrepackedAppAsar

readonly isPrepackedAppAsar: boolean;

property isTwoPackageJsonProjectLayoutUsed

isTwoPackageJsonProjectLayoutUsed: boolean;

property metadata

readonly metadata: Metadata;

property nodePackageName

readonly nodePackageName: string;

The "name" field from package.json.

property options

readonly options: PackagerOptions;

property originalMetadata

readonly originalMetadata: Metadata;

property projectDir

readonly projectDir: string;

property relativeBuildResourcesDirname

readonly relativeBuildResourcesDirname: string;

property repositoryInfo

readonly repositoryInfo: Promise<SourceRepositoryInfo>;

property stageDirPathCustomizer

stageDirPathCustomizer: (
    target: Target,
    packager: PlatformPackager<any>,
    arch: Arch
) => string;

property tempDirManager

readonly tempDirManager: TmpDir;

method build

build: (repositoryInfo?: SourceRepositoryInfo) => Promise<BuildResult>;

method clearPackagerEventListeners

clearPackagerEventListeners: () => void;

method disposeOnBuildFinish

disposeOnBuildFinish: (disposer: () => Promise<void>) => void;

method emitAfterExtract

emitAfterExtract: (context: AfterPackContext) => Promise<void>;

method emitAfterPack

emitAfterPack: (context: AfterPackContext) => Promise<void>;

method emitAfterSign

emitAfterSign: (context: AfterPackContext) => Promise<void>;

method emitAppxManifestCreated

emitAppxManifestCreated: (path: string) => Promise<void>;

method emitArtifactBuildCompleted

emitArtifactBuildCompleted: (event: ArtifactCreated) => Promise<void>;

method emitArtifactBuildStarted

emitArtifactBuildStarted: (
    event: ArtifactBuildStarted,
    logFields?: any
) => Promise<void>;

method emitArtifactCreated

emitArtifactCreated: (event: ArtifactCreated) => Promise<void>;

Only for sub artifacts (update info), for main artifacts use callArtifactBuildCompleted.

method emitBeforePack

emitBeforePack: (context: BeforePackContext) => Promise<void>;

method emitMsiProjectCreated

emitMsiProjectCreated: (path: string) => Promise<void>;

method filterPackagerEventListeners

filterPackagerEventListeners: (
    event: keyof PackagerEvents,
    type: HandlerType | undefined
) => { handler: (...args: any[]) => Promise<void> | void; type: HandlerType }[];

method getPackageManager

getPackageManager: () => Promise<PM>;

method getWorkspaceRoot

getWorkspaceRoot: () => Promise<string>;

method installAppDependencies

installAppDependencies: (platform: Platform, arch: Arch) => Promise<any>;

method onAfterPack

onAfterPack: (handler: PackagerEvents['afterPack']) => Packager;

method onArtifactCreated

onArtifactCreated: (handler: PackagerEvents['artifactCreated']) => Packager;

method validateConfig

validateConfig: () => Promise<void>;

class Platform

class Platform {}

constructor

constructor(
    name: string,
    buildConfigurationKey: string,
    nodeName: NodeJS.Platform
);

property buildConfigurationKey

buildConfigurationKey: string;

property LINUX

static LINUX: Platform;

property MAC

static MAC: Platform;

property name

name: string;

property nodeName

nodeName: NodeJS.Platform;

property WINDOWS

static WINDOWS: Platform;

method createTarget

createTarget: (
    type?: string | Array<string> | null,
    ...archs: Array<Arch>
) => Map<Platform, Map<Arch, Array<string>>>;

method current

static current: () => Platform;

method fromString

static fromString: (name: string) => Platform;

method toString

toString: () => string;

class PlatformPackager

abstract class PlatformPackager<DC extends PlatformSpecificBuildOptions> {}

constructor

protected constructor(info: Packager, platform: Platform);

property appInfo

readonly appInfo: AppInfo;

property buildResourcesDir

readonly buildResourcesDir: string;

property compression

readonly compression: CompressionLevel;

property config

readonly config: Configuration;

property debugLogger

readonly debugLogger: DebugLogger;

property defaultTarget

readonly defaultTarget: string[];

property fileAssociations

readonly fileAssociations: FileAssociation[];

property forceCodeSigning

readonly forceCodeSigning: boolean;

property info

readonly info: Packager;

property packagerOptions

readonly packagerOptions: PackagerOptions;

property platform

readonly platform: Platform;

property platformSpecificBuildOptions

readonly platformSpecificBuildOptions: PlatformSpecificBuildOptions;

property projectDir

readonly projectDir: string;

property resourceList

readonly resourceList: Promise<string[]>;

method addElectronFuses

addElectronFuses: (
    context: AfterPackContext,
    fuses: FuseConfig
) => Promise<number>;

Use AfterPackContext here to keep available for public API
Parameter context
Parameter fuses
Can be used in afterPack hook for custom fuse logic like below. It's an alternative approach if one wants to override electron-builder's @electron/fuses version
await context.packager.addElectronFuses(context, { ... })

method artifactPatternConfig

artifactPatternConfig: (
    targetSpecificOptions: TargetSpecificOptions | Nullish,
    defaultPattern: string | undefined
) => { isUserForced: boolean; pattern: string };

method computeAppOutDir

protected computeAppOutDir: (outDir: string, arch: Arch) => string;

method computeSafeArtifactName

computeSafeArtifactName: (
    suggestedName: string | null,
    ext: string,
    arch?: Arch | null,
    skipDefaultArch?: boolean,
    defaultArch?: string,
    safePattern?: string
) => string | null;

method createGetFileMatchersOptions

createGetFileMatchersOptions: (
    outDir: string,
    arch: Arch,
    customBuildOptions: PlatformSpecificBuildOptions
) => GetFileMatchersOptions;

method createTargets

abstract createTargets: (
    targets: Array<string>,
    mapper: (name: string, factory: (outDir: string) => Target) => void
) => void;

method createTransformerForExtraFiles

protected createTransformerForExtraFiles: (
    packContext: AfterPackContext
) => FileTransformer | null;

method doAddElectronFuses

protected doAddElectronFuses: (packContext: AfterPackContext) => Promise<void>;

method doGetCscPassword

doGetCscPassword: () => string | Nullish;

method doPack

protected doPack: (packOptions: DoPackOptions<DC>) => Promise<void>;

method doSignAfterPack

protected doSignAfterPack: (
    outDir: string,
    appOutDir: string,
    platformName: ElectronPlatformName,
    arch: Arch,
    platformSpecificBuildOptions: DC,
    targets: Array<Target>
) => Promise<void>;

method expandArtifactBeautyNamePattern

expandArtifactBeautyNamePattern: (
    targetSpecificOptions: TargetSpecificOptions | Nullish,
    ext: string,
    arch?: Arch | null
) => string;

method expandArtifactNamePattern

expandArtifactNamePattern: (
    targetSpecificOptions: TargetSpecificOptions | Nullish,
    ext: string,
    arch?: Arch | null,
    defaultPattern?: string,
    skipDefaultArch?: boolean,
    defaultArch?: string
) => string;

method expandMacro

expandMacro: (
    pattern: string,
    arch?: string | null,
    extra?: any,
    isProductNameSanitized?: boolean
) => string;

method generateAssetCatalogData

protected generateAssetCatalogData: (
    iconPath: string
) => Promise<AssetCatalogResult>;

method generateIcnsFromIcon

generateIcnsFromIcon: (iconPath: string) => Promise<string>;

method generateName2

generateName2: (
    ext: string | null,
    classifier: string | Nullish,
    deployment: boolean
) => string;

method getCscLink

getCscLink: (extraEnvName?: string | null) => string | Nullish;

method getCscPassword

getCscPassword: () => string;

method getDefaultFrameworkIcon

getDefaultFrameworkIcon: () => string | null;

method getElectronDestinationDir

getElectronDestinationDir: (appOutDir: string) => string;

method getElectronSrcDir

getElectronSrcDir: (dist: string) => string;

method getIconPath

getIconPath: () => Promise<string | null>;

method getMacOsElectronFrameworkResourcesDir

getMacOsElectronFrameworkResourcesDir: (appOutDir: string) => string;

method getMacOsResourcesDir

getMacOsResourcesDir: (appOutDir: string) => string;

method getOrConvertIcon

protected getOrConvertIcon: (format: IconFormat) => Promise<string | null>;

method getResource

getResource: (
    custom: string | Nullish,
    ...names: Array<string>
) => Promise<string | null>;

method getResourcesDir

getResourcesDir: (appOutDir: string) => string;

method getTempFile

getTempFile: (suffix: string) => Promise<string>;

method pack

pack: (
    outDir: string,
    arch: Arch,
    targets: Array<Target>,
    taskManager: AsyncTaskManager
) => Promise<any>;

method packageInDistributableFormat

protected packageInDistributableFormat: (
    appOutDir: string,
    arch: Arch,
    targets: Array<Target>,
    taskManager: AsyncTaskManager
) => void;

method prepareAppInfo

protected prepareAppInfo: (appInfo: AppInfo) => AppInfo;

method resolveIcon

resolveIcon: (
    sources: Array<string>,
    fallbackSources: Array<string>,
    outputFormat: IconFormat
) => Promise<Array<IconInfo>>;

method signApp

protected signApp: (
    packContext: AfterPackContext,
    isAsar: boolean
) => Promise<boolean>;

class PublishManager

class PublishManager implements PublishContext {}

constructor

constructor(
    packager: Packager,
    publishOptions: PublishOptions,
    cancellationToken?: CancellationToken
);

property cancellationToken

readonly cancellationToken: CancellationToken;

property isPublish

readonly isPublish: boolean;

property progress

readonly progress: any;

method awaitTasks

awaitTasks: () => Promise<void>;

method cancelTasks

cancelTasks: () => void;

method getGlobalPublishConfigurations

getGlobalPublishConfigurations: () => Promise<Array<PublishConfiguration> | null>;

method scheduleUpload

scheduleUpload: (
    publishConfig: PublishConfiguration,
    event: UploadTask,
    appInfo: AppInfo
) => Promise<void>;

class Target

abstract class Target {}

constructor

constructor(name: string, isAsyncSupported?: boolean);

property buildQueueManager

readonly buildQueueManager: AsyncTaskManager;

property isAsyncSupported

readonly isAsyncSupported: boolean;

property name

readonly name: string;

property options

abstract readonly options: any;

property outDir

abstract readonly outDir: string;

method build

abstract build: (appOutDir: string, arch: Arch) => Promise<any>;

method checkOptions

checkOptions: () => Promise<any>;

method finishBuild

finishBuild: () => Promise<any>;

class WindowsSignToolManager

class WindowsSignToolManager implements SignManager {}

constructor

constructor(packager: WinPackager);

property computedPublisherName

readonly computedPublisherName: Lazy<string[]>;

property cscInfo

readonly cscInfo: MemoLazy<
    WindowsConfiguration,
    FileCodeSigningInfo | CertificateFromStoreInfo
>;

property lazyCertInfo

readonly lazyCertInfo: MemoLazy<
    MemoLazy<
        WindowsConfiguration,
        FileCodeSigningInfo | CertificateFromStoreInfo
    >,
    CertificateInfo
>;

method computePublisherName

computePublisherName: (target: Target, publisherName: string) => Promise<string>;

method computeSignToolArgs

computeSignToolArgs: (
    options: WindowsSignTaskConfiguration,
    isWin: boolean,
    vm?: VmManager
) => Array<string>;

method doSign

doSign: (
    configuration: CustomWindowsSignTaskConfiguration,
    packager: WinPackager
) => Promise<void>;

method getCertificateFromStoreInfo

getCertificateFromStoreInfo: (
    options: WindowsConfiguration,
    vm: VmManager
) => Promise<CertificateFromStoreInfo>;

method getCertInfo

getCertInfo: (file: string, password: string) => Promise<CertificateInfo>;

method getOutputPath

getOutputPath: (inputPath: string, hash: string) => string;

method getToolPath

getToolPath: (isWin?: boolean) => Promise<ToolInfo>;

method initialize

initialize: () => Promise<void>;

method signFile

signFile: (options: WindowsSignOptions) => Promise<boolean>;

class WinPackager

class WinPackager extends PlatformPackager<WindowsConfiguration> {}

constructor

constructor(info: Packager);

property defaultTarget

readonly defaultTarget: string[];

property isForceCodeSigningVerification

readonly isForceCodeSigningVerification: boolean;

property signingManager

readonly signingManager: Lazy<SignManager>;

property vm

readonly vm: Lazy<VmManager>;

method createTargets

createTargets: (
    targets: Array<string>,
    mapper: (name: string, factory: (outDir: string) => Target) => void
) => void;

method createTransformerForExtraFiles

protected createTransformerForExtraFiles: (
    packContext: AfterPackContext
) => FileTransformer | null;

method doGetCscPassword

doGetCscPassword: () => string | Nullish;

method getIconPath

getIconPath: () => Promise<string | null>;

method signAndEditResources

signAndEditResources: (
    file: string,
    arch: Arch,
    outDir: string,
    internalName?: string | null,
    requestedExecutionLevel?: RequestedExecutionLevel | null
) => Promise<void>;

method signApp

protected signApp: (
    packContext: AfterPackContext,
    isAsar: boolean
) => Promise<boolean>;

method signIf

signIf: (file: string) => Promise<boolean>;

Interfaces

interface AppImageOptions

interface AppImageOptions extends CommonLinuxOptions, TargetSpecificOptions {}

property compression

readonly compression?: 'gzip' | 'xz' | 'zstd' | null;

The compression algorithm passed to the AppImage build tool.
**FUSE2 toolset ("0.0.0" or unset):** only "xz" and "gzip" are forwarded to mksquashfs (-comp <value>); "xz" additionally passes -Xdict-size 100% -b 1048576. "zstd", null, and unset fall through to the root-level compression option: - "maximum" → "xz" - anything else → flag omitted (mksquashfs defaults to gzip)
**Static-runtime toolsets (>= 1.0.0):** "gzip" and "zstd" are forwarded directly. "xz" is mapped to "zstd" (nearest supported equivalent). null or unset falls through to the root-level compression option: - "store" → "gzip" - "normal" / "maximum" / unset → "zstd"

property license

readonly license?: string | null;

The path to EULA license file. Defaults to license.txt or eula.txt (or uppercase variants). Only plain text is supported.

interface AppXOptions

interface AppXOptions extends TargetSpecificOptions {}

property addAutoLaunchExtension

readonly addAutoLaunchExtension?: boolean;

Whether to add auto launch extension. Defaults to true if [electron-winstore-auto-launch](https://github.com/felixrieseberg/electron-winstore-auto-launch) in the dependencies.

property applicationId

readonly applicationId?: string;

The application id. Defaults to identityName. This string contains alpha-numeric fields separated by periods. Each field must begin with an ASCII alphabetic character.

property backgroundColor

readonly backgroundColor?: string | null;

The background color of the app tile. See [Visual Elements](https://msdn.microsoft.com/en-us/library/windows/apps/br211471.aspx). #464646

property capabilities

readonly capabilities?: Array<string> | null;

The list of [capabilities](https://learn.microsoft.com/en-us/windows/uwp/packaging/app-capability-declarations) to be added to an appmanifest.xml. The runFullTrust capability is obligatory for electron apps and will be auto added if not specified here. Defaults to ['runFullTrust'] if omitted Example: ['runFullTrust', 'privateNetworkClientServer', 'webcam']

property customExtensionsPath

readonly customExtensionsPath?: string;

Relative path to custom extensions xml to be included in an appmanifest.xml.

property customManifestPath

readonly customManifestPath?: string;

(Advanced Option) Relative path to custom appmanifest.xml (file name doesn't matter, it'll be renamed) located in build resources directory. Supports the following template macros:
- ${publisher} - ${publisherDisplayName} - ${version} - ${applicationId} - ${identityName} - ${executable} - ${displayName} - ${description} - ${backgroundColor} - ${logo} - ${square150x150Logo} - ${square44x44Logo} - ${lockScreen} - ${defaultTile} - ${splashScreen} - ${arch} - ${resourceLanguages} - ${capabilities} - ${extensions} - ${minVersion} - ${maxVersionTested}

property displayName

readonly displayName?: string | null;

A friendly name that can be displayed to users. Corresponds to [Properties.DisplayName](https://msdn.microsoft.com/en-us/library/windows/apps/br211432.aspx). Defaults to the application product name.

property electronUpdaterAware

readonly electronUpdaterAware?: boolean;

false

property identityName

readonly identityName?: string | null;

The name. Corresponds to [Identity.Name](https://msdn.microsoft.com/en-us/library/windows/apps/br211441.aspx). Defaults to the [application name](https://www.electron.build/configuration#metadata).

property languages

readonly languages?: Array<string> | string | null;

The list of [supported languages](https://docs.microsoft.com/en-us/windows/uwp/globalizing/manage-language-and-region#specify-the-supported-languages-in-the-apps-manifest) that will be listed in the Windows Store. The first entry (index 0) will be the default language. Defaults to en-US if omitted.

property makeappxArgs

readonly makeappxArgs?: Array<string> | null;

property maxVersionTested

readonly maxVersionTested?: string | null;

Set the MaxVersionTested field in the appx manifest.xml arch === Arch.arm64 ? "10.0.16299.0" : "10.0.14316.0"

property minVersion

readonly minVersion?: string | null;

Set the MinVersion field in the appx manifest.xml arch === Arch.arm64 ? "10.0.16299.0" : "10.0.14316.0"

property publisher

readonly publisher?: string | null;

The Windows Store publisher. Not used if AppX is build for testing. See [AppX Package Code Signing](#appx-package-code-signing) below.

property publisherDisplayName

readonly publisherDisplayName?: string | null;

A friendly name for the publisher that can be displayed to users. Corresponds to [Properties.PublisherDisplayName](https://msdn.microsoft.com/en-us/library/windows/apps/br211460.aspx). Defaults to company name from the application metadata.

property setBuildNumber

readonly setBuildNumber?: boolean;

Whether to set build number. See https://github.com/electron-userland/electron-builder/issues/3875 false

property showNameOnTiles

readonly showNameOnTiles?: boolean;

Whether to overlay the app's name on top of tile images on the Start screen. Defaults to false. (https://docs.microsoft.com/en-us/uwp/schemas/appxpackage/uapmanifestschema/element-uap-shownameontiles) in the dependencies. false

interface ArtifactBuildStarted

interface ArtifactBuildStarted {}

property arch

readonly arch: Arch | null;

property file

readonly file: string;

property targetPresentableName

readonly targetPresentableName: string;

interface ArtifactCreated

interface ArtifactCreated extends UploadTask {}

property isWriteUpdateInfo

readonly isWriteUpdateInfo?: boolean;

property packager

readonly packager: PlatformPackager<any>;

property publishConfig

readonly publishConfig?: PublishConfiguration | null;

property safeArtifactName

readonly safeArtifactName?: string | null;

property target

readonly target: Target | null;

property updateInfo

updateInfo?: any;

interface AsarOptions

interface AsarOptions {}

property ordering

ordering?: string | null;

Path to a file containing the order in which files should be packed into the asar archive. Each line of the file is a relative path from the app directory. Files listed first are packed first, which can improve app startup time by front-loading frequently accessed modules. See the [asar documentation](https://github.com/electron/asar) for details.

property smartUnpack

smartUnpack?: boolean;

Whether to automatically unpack executables files. true

interface AuthorMetadata

interface AuthorMetadata {}

property email

readonly email?: string;

property name

readonly name: string;

interface BeforeBuildContext

interface BeforeBuildContext {}

property appDir

readonly appDir: string;

property arch

readonly arch: string;

property electronVersion

readonly electronVersion: string;

property platform

readonly platform: Platform;

interface BuildResult

interface BuildResult {}

property artifactPaths

readonly artifactPaths: Array<string>;

property configuration

readonly configuration: Configuration;

property outDir

readonly outDir: string;

property platformToTargets

readonly platformToTargets: Map<Platform, Map<string, Target>>;

interface CertificateFromStoreInfo

interface CertificateFromStoreInfo {}

property isLocalMachineStore

isLocalMachineStore: boolean;

property store

store: string;

property subject

subject: string;

property thumbprint

thumbprint: string;

interface CommonConfiguration

interface CommonConfiguration {}

Configuration Options

property apk

readonly apk?: LinuxTargetSpecificOptions | null;

Alpine Linux APK package options. Produces an .apk archive installable via apk add.

property appId

readonly appId?: string | null;

The application id. Used as [CFBundleIdentifier](https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/20001431-102070) for MacOS and as [Application User Model ID](https://msdn.microsoft.com/en-us/library/windows/desktop/dd378459(v=vs.85).aspx) for Windows (NSIS target only, Squirrel.Windows not supported). It is strongly recommended that an explicit ID is set. com.electron.${name}

property appImage

readonly appImage?: AppImageOptions | null;

AppImage options. AppImage is a portable application format that bundles the app and its dependencies into a single self-contained executable that runs on most Linux distributions without installation.

property appx

readonly appx?: AppXOptions | null;

Windows Store (AppX) package options.

property buildDependenciesFromSource

buildDependenciesFromSource?: boolean;

Whether to build the application native dependencies from source. false

property buildNumber

readonly buildNumber?: string | null;

The build number. Maps to the --iteration flag for builds using FPM on Linux. If not defined, then it will fallback to BUILD_NUMBER or TRAVIS_BUILD_NUMBER or APPVEYOR_BUILD_NUMBER or CIRCLE_BUILD_NUM or BUILD_BUILDNUMBER or CI_PIPELINE_IID env.

property buildVersion

readonly buildVersion?: string | null;

The build version. Maps to the CFBundleVersion on macOS, and FileVersion metadata property on Windows. Defaults to the version. If buildVersion is not defined and buildNumber (or one of the buildNumber envs) is defined, it will be used as a build version (version.buildNumber).

property concurrency

readonly concurrency?: Concurrency | null;

[Experimental] Configuration for concurrent builds.

property copyright

readonly copyright?: string | null;

The human-readable copyright line for the app. Copyright © year ${author}

property deb

readonly deb?: DebOptions | null;

Debian package options. Targets Debian, Ubuntu, and Debian-based distributions. Produces a .deb archive installable via dpkg -i or apt install.

property directories

readonly directories?: MetadataDirectories | null;

Directories for build resources

property dmg

readonly dmg?: DmgOptions | null;

macOS DMG options.

property downloadAlternateFFmpeg

readonly downloadAlternateFFmpeg?: boolean;

Whether to download the alternate FFmpeg library from Electron's release assets and replace the default FFmpeg library prior to signing

property electronFuses

readonly electronFuses?: FuseOptionsV1 | null;

Options to pass to @electron/fuses Ref: https://github.com/electron/fuses

property extraMetadata

readonly extraMetadata?: any;

Inject properties to package.json.

property flatpak

readonly flatpak?: FlatpakOptions | null;

Flatpak options. Flatpak is a sandboxed application distribution format for Linux that runs in a controlled environment and is distributed via [Flathub](https://flathub.org/) or other Flatpak repositories.

property forceCodeSigning

readonly forceCodeSigning?: boolean;

Whether to fail if the application is not signed (to prevent unsigned app if code signing configuration is not correct). false

property freebsd

readonly freebsd?: LinuxTargetSpecificOptions | null;

FreeBSD package options. Produces a .pkg archive for the FreeBSD pkg package manager.

property includePdb

readonly includePdb?: boolean;

Whether to include PDB files. false

property linux

readonly linux?: LinuxConfiguration | null;

General Linux build options shared across all Linux targets (icon, category, desktop entry, executable name, etc.). Target-specific compression and packaging options live in the per-format interfaces (DebOptions, RpmOptions, PacmanOptions, etc.).

property mac

readonly mac?: MacConfiguration | null;

Options related to how build macOS targets.

property mas

readonly mas?: MasConfiguration | null;

MAS (Mac Application Store) options.

property masDev

readonly masDev?: MasConfiguration | null;

MAS (Mac Application Store) development options (mas-dev target).

property msi

readonly msi?: MsiOptions | null;

MSI package options.

property msiWrapped

readonly msiWrapped?: MsiWrappedOptions | null;

MSI-wrapped installer options.

property nativeRebuilder

readonly nativeRebuilder?: 'legacy' | 'sequential' | 'parallel' | null;

Use legacy app-builder binary for installing native dependencies, or @electron/rebuild in sequential or parallel compilation modes. sequential

property nodeGypRebuild

readonly nodeGypRebuild?: boolean;

Whether to execute node-gyp rebuild before starting to package the app.
Don't [use](https://github.com/electron-userland/electron-builder/issues/683#issuecomment-241214075) [npm](http://electron.atom.io/docs/tutorial/using-native-node-modules/#using-npm) (neither .npmrc) for configuring electron headers. Use electron-builder node-gyp-rebuild instead. false

property npmArgs

readonly npmArgs?: Array<string> | string | null;

Additional command line arguments to use when installing app native deps.

property npmRebuild

readonly npmRebuild?: boolean;

Whether to [rebuild](https://docs.npmjs.com/cli/rebuild) native dependencies before starting to package the app. true

property nsis

readonly nsis?: NsisOptions | null;

NSIS installer options.

property nsisWeb

readonly nsisWeb?: NsisWebOptions | null;

NSIS web installer options (downloads app package at install time).

property p5p

readonly p5p?: LinuxTargetSpecificOptions | null;

Solaris IPS package options. Produces a .p5p archive for the Solaris Image Packaging System (pkg).

property pacman

readonly pacman?: PacmanOptions | null;

Pacman package options. Targets Arch Linux and Arch-based distributions (Manjaro, EndeavourOS, etc.). Produces a .pacman archive installable via pacman -U.

property pkg

readonly pkg?: PkgOptions | null;

macOS PKG options.

property portable

readonly portable?: PortableOptions | null;

Portable executable options (no installation required).

property productName

readonly productName?: string | null;

As [name](#metadata), but allows you to specify a product name for your executable which contains spaces and other special characters not allowed in the [name property](https://docs.npmjs.com/files/package.json#name). If not specified inside of the build configuration, productName property defined at the top level of package.json is used. If not specified at the top level of package.json, [name property](https://docs.npmjs.com/files/package.json#name) is used.

property removePackageKeywords

readonly removePackageKeywords?: boolean;

Whether to remove keywords field from package.json files.
true

property removePackageScripts

readonly removePackageScripts?: boolean;

Whether to remove scripts field from package.json files.
true

property rpm

readonly rpm?: RpmOptions | null;

RPM package options. Targets Fedora, Red Hat Enterprise Linux, SUSE, and related distributions. Produces a .rpm archive installable via rpm or dnf.

property snap

readonly snap?: SnapOptions | null;

Flat snap configuration targeting core22 and older snap bases.
Deprecated
Use snapcraft instead — it supersedes snap when both are present and supports all snap bases including core24. snap will be removed in a future major release. See SnapOptions for available properties.

property snapcraft

readonly snapcraft?: SnapcraftOptions | null;

Snapcraft configuration. Prefer this over the deprecated snap field.
Selects the snapcraft base and provides per-core options: - base: "core18" | "core20" | "core22" — legacy builds; accepts the same options as snap - base: "core24" — modern builds with the GNOME extension (recommended for new apps, requires Electron 25+) - base: "custom" — pass an existing snapcraft.yaml through unchanged; no plugs, extensions, or desktop files are injected
When both snapcraft and snap are set, snapcraft takes precedence.
Example 1
{ "snapcraft": { "base": "core24", "core24": { "useLXD": true } } }
See SnapcraftOptions for all available properties.

property squirrelWindows

readonly squirrelWindows?: SquirrelWindowsOptions | null;

Squirrel.Windows installer options. Requires the electron-builder-squirrel-windows dependency.

property toolsets

readonly toolsets?: ToolsetConfig | null;

Configuration of toolsets utilized by electron-builder

property win

readonly win?: WindowsConfiguration | null;

Options related to how build Windows targets.

interface CommonLinuxOptions

interface CommonLinuxOptions {}

Desktop-entry and runtime fields shared by all Linux targets and all snap core strategies.
Fields set under linux.* in your build config (i.e. on LinuxConfiguration) are automatically cascaded into each snap core's options by LinuxTargetHelper.getSnapCore(). You do not need to duplicate them under snapcraft.core24.*, snapcraft.core22.*, etc. Per-core values always take precedence when both are set.

property category

readonly category?: string | null;

The [application category](https://specifications.freedesktop.org/menu-spec/latest/apa.html#main-category-registry).

property description

readonly description?: string | null;

As [description](https://www.electron.build/configuration#description) from application package.json, but allows you to specify different for Linux.

property desktop

readonly desktop?: LinuxDesktopFile | null;

The [Desktop file](https://developer.gnome.org/documentation/guidelines/maintainer/integrating.html#desktop-files)

property executableArgs

readonly executableArgs?: Array<string> | null;

The executable parameters. Pass to executableName

property mimeTypes

readonly mimeTypes?: Array<string> | null;

The mime types in addition to specified in the file associations. Use it if you don't want to register a new mime type, but reuse existing.

property synopsis

readonly synopsis?: string | null;

The [short description](https://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Description).

interface CommonNsisOptions

interface CommonNsisOptions {}

property customNsisBinary

readonly customNsisBinary?: CustomNsisBinary | null;

Allows you to provide your own makensis, such as one with support for debug logging via LogSet and LogText. (Logging also requires option debugLogging = true)

property customNsisResources

readonly customNsisResources?: CustomNsisResources | null;

Allows you to provide your own nsis-resources

property guid

readonly guid?: string | null;

The GUID for the installer. Used to identify the application for upgrade and uninstall operations. If not specified, a deterministic GUID is generated from the app ID (appId) — but this means changing your appId will break silent upgrades of existing installs.
See Also
- [GUID vs Application Name](https://www.electron.build/docs/nsis#guid-vs-application-name)

property unicode

readonly unicode?: boolean;

Whether to create [Unicode installer](http://nsis.sourceforge.net/Docs/Chapter1.html#intro-unicode). true

property useZip

readonly useZip?: boolean;

Forces zip compression format instead of LZMA. Used internally for differential update packages. false

property warningsAsErrors

readonly warningsAsErrors?: boolean;

If warningsAsErrors is true (default): NSIS will treat warnings as errors. If warningsAsErrors is false: NSIS will allow warnings. true

interface CommonWindowsInstallerConfiguration

interface CommonWindowsInstallerConfiguration {}

property createDesktopShortcut

readonly createDesktopShortcut?: boolean | 'always';

Whether to create desktop shortcut. Set to always if to recreate also on reinstall (even if removed by user). true

property createStartMenuShortcut

readonly createStartMenuShortcut?: boolean;

Whether to create start menu shortcut. true

property menuCategory

readonly menuCategory?: boolean | string;

Whether to create submenu for start menu shortcut and program files directory. If true, company name will be used. Or string value. false

property oneClick

readonly oneClick?: boolean;

property perMachine

readonly perMachine?: boolean;

Whether to install per all users (per-machine). false

property runAfterFinish

readonly runAfterFinish?: boolean;

Whether to run the installed application after finish. For assisted installer corresponding checkbox will be removed. true

property shortcutName

readonly shortcutName?: string | null;

The name that will be used for all shortcuts. Defaults to the application name.

interface Configuration

interface Configuration
    extends CommonConfiguration,
        PlatformSpecificBuildOptions,
        Hooks {}

property disableAsarIntegrity

readonly disableAsarIntegrity?: boolean;

Whether to skip ASAR integrity hash computation. Useful for custom electron forks with encrypted ASAR support where the header is not readable by standard tools. false

property disableSanityCheckAsar

readonly disableSanityCheckAsar?: boolean;

Whether to disable sanity check asar package (useful for custom electron forks that implement their own encrypted integrity validation) false

property electronBranding

readonly electronBranding?: ElectronBrandingOptions;

The branding used by Electron's distributables. This is needed if a fork has modified Electron's BRANDING.json file.

property electronCompile

readonly electronCompile?: boolean;

Whether to use [electron-compile](http://github.com/electron/electron-compile) to compile app. Defaults to true if electron-compile in the dependencies. And false if in the devDependencies or doesn't specified.
Deprecated
electron-compile is no longer maintained. Compile your app with a modern bundler (webpack, vite, etc.) instead.

property electronDownload

readonly electronDownload?: ElectronDownloadOptions | ElectronGetOptions | null;

The [electron-download](https://github.com/electron-userland/electron-download#usage) options. (legacy) Alternatively, you can use [electron/get](https://github.com/electron/get#usage) options.

property electronVersion

electronVersion?: string | null;

The version of electron you are packaging for. Defaults to version of electron, electron-prebuilt or electron-prebuilt-compile dependency.

property extends

extends?: Array<string> | string | null;

The name of a built-in configuration preset (currently, only react-cra is supported) or any number of paths to config files (relative to project dir).
The latter allows to mixin a config from multiple other configs, as if you Object.assign them, but properly combine files glob patterns.
If react-scripts in the app dependencies, react-cra will be set automatically. Set to null to disable automatic detection.

property framework

readonly framework?: string | null;

The framework name. One of electron, proton, libui. Defaults to electron.
Deprecated
proton and libui framework support is no longer actively maintained. Use electron (the default).

property launchUiVersion

readonly launchUiVersion?: boolean | string | null;

*libui-based frameworks only* The version of LaunchUI you are packaging for. Applicable for Windows only. Defaults to version suitable for used framework version.
Deprecated
libui-based frameworks (proton-native, etc.) are no longer actively maintained. This option has no effect when using Electron.

property nodeVersion

readonly nodeVersion?: string | null;

*libui-based frameworks only* The version of NodeJS you are packaging for. You can set it to current to set the Node.js version that you use to run.
Deprecated
libui-based frameworks (proton-native, etc.) are no longer actively maintained. This option has no effect when using Electron.

interface CustomNsisBinary

interface CustomNsisBinary {}

property checksum

readonly checksum?: string | null;

VKMiizYdmNdJOWpRGz4trl4lD++BvYP2irAXpMilheUP0pc93iKlWAoP843Vlraj8YG19CVn0j+dCo/hURz9+Q==

property debugLogging

readonly debugLogging?: boolean | null;

Whether or not to enable NSIS logging for debugging. Note: Requires a debug-enabled NSIS build. electron-builder's included makensis does not natively support debug-enabled NSIS installers currently, you must supply your own via customNsisBinary?: CustomNsisBinary In your custom nsis scripts, you can leverage this functionality via LogSet and LogText

property url

readonly url: string | null;

https://github.com/electron-userland/electron-builder-binaries/releases/download/nsis-3.0.4.1/nsis-3.0.4.1.7z

property version

readonly version?: string | null;

3.0.4.1

interface CustomWindowsSignTaskConfiguration

interface CustomWindowsSignTaskConfiguration extends WindowsSignTaskConfiguration {}

method computeSignToolArgs

computeSignToolArgs: (isWin: boolean) => Array<string>;

interface DebOptions

interface DebOptions extends LinuxTargetSpecificOptions {}

property compression

readonly compression?: 'gz' | 'bzip2' | 'xz' | 'zst' | null;

property depends

readonly depends?: Array<string> | null;

Package dependencies. If need to support Debian, libappindicator1 should be removed, it is [deprecated in Debian](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=895037). If need to support KDE, gconf2 and gconf-service should be removed as it's no longer used [by GNOME](https://packages.debian.org/bullseye/gconf2). ["libgtk-3-0", "libnotify4", "libnss3", "libxss1", "libxtst6", "xdg-utils", "libatspi2.0-0", "libuuid1", "libsecret-1-0"]

property packageCategory

readonly packageCategory?: string | null;

The [package category](https://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Section).

property priority

readonly priority?: string | null;

The [Priority](https://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Priority) attribute.

property recommends

readonly recommends?: Array<string> | null;

The [recommended package dependencies](https://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps). ["libappindicator3-1"]

interface DmgContent

interface DmgContent {}

property name

name?: string;

The name of the file within the DMG. Defaults to basename of path.

property path

path?: string;

The path of the file within the DMG.

property type

type?: 'link' | 'file' | 'dir';

property x

x: number;

The device-independent pixel offset from the left of the window to the **center** of the icon.

property y

y: number;

The device-independent pixel offset from the top of the window to the **center** of the icon.

interface DmgOptions

interface DmgOptions extends TargetSpecificOptions {}

property background

background?: string | null;

The path to background image (default: build/background.tiff or build/background.png if exists). The resolution of this file determines the resolution of the installer window. If background is not specified, use window.size. Default locations expected background size to be 540x380.
See Also
- [DMG with Retina background support](http://stackoverflow.com/a/11204769/1910191).

property backgroundColor

backgroundColor?: string | null;

The background color (accepts css colors). Used when no background image is set. #ffffff

property badgeIcon

badgeIcon?: string | null;

The path to DMG icon (badge icon), which will be shown when mounted, relative to the [build resources](https://www.electron.build/contents#extraresources) or to the project directory.

property contents

contents?: Array<DmgContent>;

The content — to customize icon locations. The x and y coordinates refer to the position of the **center** of the icon (at 1x scale), and do not take the label into account.

property filesystem

readonly filesystem?: 'HFS+' | 'APFS' | null;

The filesystem for the DMG volume (e.g. "APFS" or "HFS+") This will be changed to APFS in the next major release, so it is recommended to set it explicitly to HFS+ if you want to keep using HFS+ (e.g. for better compatibility with older macOS versions). HFS+

property format

format?: 'UDRW' | 'UDRO' | 'UDCO' | 'UDZO' | 'UDBZ' | 'ULFO';

The disk image format. ULFO (lzfse-compressed image (OS X 10.11+ only)). UDZO

property icon

icon?: string | null;

The path to DMG icon (volume icon), which will be shown when mounted, relative to the [build resources](https://www.electron.build/contents#extraresources) or to the project directory. Defaults to the application icon (build/icon.icns).

property iconSize

readonly iconSize?: number | null;

The size of all the icons inside the DMG. 80

property iconTextSize

readonly iconTextSize?: number | null;

The size of all the icon texts inside the DMG. 12

property internetEnabled

readonly internetEnabled?: boolean;

Whether to create internet-enabled disk image (when it is downloaded using a browser it will automatically decompress the image, put the application on the desktop, unmount and remove the disk image file). false

property license

license?: string | Record<string, string> | null;

License agreement to display when the DMG is mounted.
Accepts a single file path (.rtf, .txt, or .html) used as the English/default license, or a language-code → file-path map for multi-language builds.
When set, this takes precedence over the file-naming convention (license_en.txt, etc. in the build resources directory). Paths are resolved relative to the build resources directory or project root.
Example 1
Single language
dmg: license: "build/license.rtf"
Example 2
Multi-language
dmg: license: en_US: "build/license.rtf" de_DE: "build/license_de.txt" ja_JP: "build/license_ja.txt"
If not set, electron-builder scans the build resources directory for license_LANG.{rtf,txt,html} files automatically.

property shrink

readonly shrink?: boolean;

Whether to shrink the DMG filesystem to the minimum size after copying files. Set to false to preserve the explicit size you specified. true

property sign

readonly sign?: boolean;

Whether to sign the DMG or not. Signing is not required and will lead to unwanted errors in combination with notarization requirements. false

property size

readonly size?: string | null;

The initial size of the DMG filesystem. Accepts the same syntax as the -size argument to hdiutil, e.g. "150m", "4g". If not specified, the size is calculated automatically. Set this explicitly for large apps or apps with sparse files to avoid "No space left on device" errors.

property title

readonly title?: string | null;

The title of the produced DMG, which will be shown when mounted (volume name).
Macro ${productName}, ${version} and ${name} are supported. ${productName} ${version}

property window

window?: DmgWindow;

The DMG window position and size. With y co-ordinates running from bottom to top.
The Finder makes sure that the window will be on the user’s display, so if you want your window at the top left of the display you could use "x": 0, "y": 100000 as the x, y co-ordinates. It is not to be possible to position the window relative to the [top left](https://github.com/electron-userland/electron-builder/issues/3990#issuecomment-512960957) or relative to the center of the user’s screen.

property writeUpdateInfo

writeUpdateInfo?: boolean;

true

interface DmgWindow

interface DmgWindow {}

property height

height?: number;

The height. Defaults to background image height or 380.

property width

width?: number;

The width. Defaults to background image width or 540.

property x

x?: number;

The X position relative to left of the screen. 400

property y

y?: number;

The Y position relative to bottom of the screen. 100

interface ElectronBrandingOptions

interface ElectronBrandingOptions {}

Electron distributables branding options.
See Also
- [Electron BRANDING.json](https://github.com/electron/electron/blob/master/shell/app/BRANDING.json).

property productName

productName?: string;

property projectName

projectName?: string;

interface ElectronDownloadOptions

interface ElectronDownloadOptions {}

property arch

arch?: string;

property cache

cache?: string | null;

The [cache location](https://github.com/electron-userland/electron-download#cache-location).

property customDir

customDir?: string | null;

property customFilename

customFilename?: string | null;

property isVerifyChecksum

isVerifyChecksum?: boolean;

property mirror

mirror?: string | null;

The mirror.

property platform

platform?: ElectronPlatformName;

property strictSSL

strictSSL?: boolean;

property version

version?: string;

interface FileAssociation

interface FileAssociation {}

File associations.
macOS (corresponds to [CFBundleDocumentTypes](https://developer.apple.com/library/content/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/20001431-101685)), NSIS, and MSI only.
On Windows (NSIS) works only if [nsis.perMachine](https://www.electron.build/nsis) is set to true.

property description

readonly description?: string | null;

*windows-only.* The description.

property ext

readonly ext: string | Array<string>;

The extension (minus the leading period). e.g. png.

property icon

readonly icon?: string | null;

The path to icon (.icns for MacOS and .ico for Windows), relative to build (build resources directory). Defaults to ${firstExt}.icns/${firstExt}.ico (if several extensions specified, first is used) or to application icon.
Not supported on Linux, file issue if need (default icon will be x-office-document). Not supported on MSI.

property isPackage

readonly isPackage?: boolean;

*macOS-only* Whether the document is distributed as a bundle. If set to true, the bundle directory is treated as a file. Corresponds to LSTypeIsPackage.

property mimeType

readonly mimeType?: string | null;

*linux-only.* The mime-type.

property name

readonly name?: string | null;

The name. e.g. PNG. Defaults to ext.

property rank

readonly rank?: string;

*macOS-only* The app’s rank with respect to the type. The value can be Owner, Default, Alternate, or None. Corresponds to LSHandlerRank. Default

property role

readonly role?: string;

*macOS-only* The app’s role with respect to the type. The value can be Editor, Viewer, Shell, or None. Corresponds to CFBundleTypeRole. Editor

interface FileCodeSigningInfo

interface FileCodeSigningInfo {}

property file

readonly file: string;

property password

readonly password: string | null;

interface FilesBuildOptions

interface FilesBuildOptions {}

property extraFiles

extraFiles?: Array<FileSet | string> | FileSet | string | null;

The same as [extraResources](#extraresources) but copy into the app's content directory (Contents for MacOS, root directory for Linux and Windows).

property extraResources

extraResources?: Array<FileSet | string> | FileSet | string | null;

A [glob patterns](https://www.electron.build/file-patterns) relative to the project directory, when specified, copy the file or directory with matching names directly into the app's resources directory (Contents/Resources for MacOS, resources for Linux and Windows).
File patterns (and support for from and to fields) the same as for [files](#files).

property files

files?: Array<FileSet | string> | FileSet | string | null;

A [glob patterns](https://www.electron.build/file-patterns) relative to the [app directory](https://www.electron.build/configuration#directories), which specifies which files to include when copying files to create the package.
Defaults to: ```json [ "**/*", "!**/node_modules/*/{CHANGELOG.md,README.md,README,readme.md,readme}", "!**/node_modules/*/{test,__tests__,tests,powered-test,example,examples}", "!**/node_modules/*.d.ts", "!**/node_modules/.bin", "!**/*.{iml,o,hprof,orig,pyc,pyo,rbc,swp,csproj,sln,xproj}", "!.editorconfig", "!**/._*", "!**/{.DS_Store,.git,.hg,.svn,CVS,RCS,SCCS,.gitignore,.gitattributes}", "!**/{__pycache__,thumbs.db,.flowconfig,.idea,.vs,.nyc_output}", "!**/{appveyor.yml,.travis.yml,circle.yml}", "!**/{npm-debug.log,yarn.lock,.yarn-integrity,.yarn-metadata.json}" ] ```
Development dependencies are never copied in any case. You don't need to ignore it explicitly. Hidden files are not ignored by default, but all files that should be ignored, are ignored by default.
Default pattern `**/*` **is not added to your custom** if some of your patterns is not ignore (i.e. not starts with !). package.json and `**/node_modules/**/*` (only production dependencies will be copied) is added to your custom in any case. All default ignores are added in any case — you don't need to repeat it if you configure own patterns.
May be specified in the platform options (e.g. in the [mac](https://www.electron.build/mac)).
You may also specify custom source and destination directories by using FileSet objects instead of simple glob patterns.
```json [ { "from": "path/to/source", "to": "path/to/destination", "filter": ["**/*", "!foo/*.js"] } ] ```
You can use [file macros](https://www.electron.build/file-patterns#file-macros) in the from and to fields as well. from and to can be files and you can use this to [rename](https://github.com/electron-userland/electron-builder/issues/1119) a file while packaging.

interface FileSet

interface FileSet {}

property filter

filter?: Array<string> | string;

The [glob patterns](https://www.electron.build/file-patterns). Defaults to "**/*"

property from

from?: string;

The source path relative to and defaults to:
- the [app directory](https://www.electron.build/configuration#directories) for files, - the project directory for extraResources and extraFiles. If you don't use two-package.json structure and don't set custom app directory, app directory equals to project directory.

property to

to?: string;

The destination path relative to and defaults to:
- the asar archive root for files, - the app's content directory for extraFiles, - the app's resource directory for extraResources.

interface FlatpakOptions

interface FlatpakOptions extends CommonLinuxOptions, TargetSpecificOptions {}

property base

readonly base?: string;

Start with the files from the specified application. This can be used to create applications that extend another application. Defaults to [org.electronjs.Electron2.BaseApp](https://github.com/flathub/org.electronjs.Electron2.BaseApp).
See [flatpak manifest documentation](https://docs.flatpak.org/en/latest/flatpak-builder-command-reference.html#flatpak-manifest).

property baseVersion

readonly baseVersion?: string;

Use this specific version of the application specified in base. Defaults to 20.08.
See [flatpak manifest documentation](https://docs.flatpak.org/en/latest/flatpak-builder-command-reference.html#flatpak-manifest).

property branch

readonly branch?: string;

The branch to use when exporting the application. Defaults to master.
See [flatpak manifest documentation](https://docs.flatpak.org/en/latest/flatpak-builder-command-reference.html#flatpak-manifest).

property files

readonly files?: [string, string][];

Files to copy directly into the app. Should be a list of [source, dest] tuples. Source should be a relative/absolute path to a file/directory to copy into the flatpak, and dest should be the path inside the app install prefix (e.g. /share/applications/).
See [@malept/flatpak-bundler documentation](https://github.com/malept/flatpak-bundler#build-options).

property finishArgs

readonly finishArgs?: string[];

An array of arguments passed to the flatpak build-finish command. Defaults to:

[
  // Wayland/X11 Rendering
  "--socket=wayland",
  "--socket=x11",
  "--share=ipc",
  // Open GL
  "--device=dri",
  // Audio output
  "--socket=pulseaudio",
  // Read/write home directory access
  "--filesystem=home",
  // Allow communication with network
  "--share=network",
  // System notifications with libnotify
  "--talk-name=org.freedesktop.Notifications",
]

See [flatpak manifest documentation](https://docs.flatpak.org/en/latest/flatpak-builder-command-reference.html#flatpak-manifest).

property license

readonly license?: string | null;

The path to EULA license file. Defaults to license.txt or eula.txt (or uppercase variants). Only plain text is supported.

property modules

readonly modules?: (string | any)[];

An array of objects specifying the modules to be built in order.
See [flatpak manifest documentation](https://docs.flatpak.org/en/latest/flatpak-builder-command-reference.html#flatpak-manifest).

property runtime

readonly runtime?: string;

The name of the runtime that the application uses. Defaults to org.freedesktop.Platform.
See [flatpak manifest documentation](https://docs.flatpak.org/en/latest/flatpak-builder-command-reference.html#flatpak-manifest).

property runtimeVersion

readonly runtimeVersion?: string;

The version of the runtime that the application uses. Defaults to 20.08.
See [flatpak manifest documentation](https://docs.flatpak.org/en/latest/flatpak-builder-command-reference.html#flatpak-manifest).

property sdk

readonly sdk?: string;

The name of the development runtime that the application builds with. Defaults to org.freedesktop.Sdk.
See [flatpak manifest documentation](https://docs.flatpak.org/en/latest/flatpak-builder-command-reference.html#flatpak-manifest).

property symlinks

readonly symlinks?: [string, string][];

Symlinks to create in the app files. Should be a list of [target, location] symlink tuples. Target can be either a relative or absolute path inside the app install prefix, and location should be a absolute path inside the prefix to create the symlink at.
See [@malept/flatpak-bundler documentation](https://github.com/malept/flatpak-bundler#build-options).

property useWaylandFlags

readonly useWaylandFlags?: boolean;

Whether to enable the Wayland specific flags (--enable-features=UseOzonePlatform --ozone-platform=wayland) in the wrapper script. These flags are only available starting with Electron version 12. Defaults to false.

interface ForgeOptions

interface ForgeOptions {}

property dir

readonly dir: string;

interface Framework

interface Framework {}

property defaultAppIdPrefix

readonly defaultAppIdPrefix: string;

property distMacOsAppName

readonly distMacOsAppName: string;

property isCopyElevateHelper

readonly isCopyElevateHelper: boolean;

property isNpmRebuildRequired

readonly isNpmRebuildRequired: boolean;

property macOsDefaultTargets

readonly macOsDefaultTargets: Array<string>;

property name

readonly name: string;

property version

readonly version: string;

method afterPack

afterPack: (context: AfterPackContext) => Promise<any>;

method beforeCopyExtraFiles

beforeCopyExtraFiles: (options: BeforeCopyExtraFilesOptions) => Promise<any>;

method createTransformer

createTransformer: () => FileTransformer | null;

method getDefaultIcon

getDefaultIcon: (platform: Platform) => string | null;

method getExcludedDependencies

getExcludedDependencies: (platform: Platform) => Array<string> | null;

method getMainFile

getMainFile: (platform: Platform) => string | null;

method prepareApplicationStageDirectory

prepareApplicationStageDirectory: (
    options: PrepareApplicationStageDirectoryOptions
) => Promise<any>;

interface FuseOptionsV1

interface FuseOptionsV1 {}

All options come from [@electron/fuses](https://github.com/electron/fuses) Ref: https://raw.githubusercontent.com/electron/electron/refs/heads/main/docs/tutorial/fuses.md

property enableCookieEncryption

enableCookieEncryption?: boolean;

The cookieEncryption fuse toggles whether the cookie store on disk is encrypted using OS level cryptography keys. By default the sqlite database that Chromium uses to store cookies stores the values in plaintext. If you wish to ensure your apps cookies are encrypted in the same way Chrome does then you should enable this fuse. Please note it is a one-way transition, if you enable this fuse existing unencrypted cookies will be encrypted-on-write but if you then disable the fuse again your cookie store will effectively be corrupt and useless. Most apps can safely enable this fuse.

property enableEmbeddedAsarIntegrityValidation

enableEmbeddedAsarIntegrityValidation?: boolean;

The embeddedAsarIntegrityValidation fuse toggles an experimental feature on macOS that validates the content of the app.asar file when it is loaded. This feature is designed to have a minimal performance impact but may marginally slow down file reads from inside the app.asar archive. Currently, ASAR integrity checking is supported on:
- macOS as of electron>=16.0.0 - Windows as of electron>=30.0.0
For more information on how to use asar integrity validation please read the [Asar Integrity](https://github.com/electron/electron/blob/main/docs/tutorial/asar-integrity.md) documentation.

property enableNodeCliInspectArguments

enableNodeCliInspectArguments?: boolean;

The nodeCliInspect fuse toggles whether the --inspect, --inspect-brk, etc. flags are respected or not. When disabled it also ensures that SIGUSR1 signal does not initialize the main process inspector. Most apps can safely disable this fuse.

property enableNodeOptionsEnvironmentVariable

enableNodeOptionsEnvironmentVariable?: boolean;

The nodeOptions fuse toggles whether the [NODE_OPTIONS](https://nodejs.org/api/cli.html#node_optionsoptions) and [NODE_EXTRA_CA_CERTS](https://github.com/nodejs/node/blob/main/doc/api/cli.md#node_extra_ca_certsfile) environment variables are respected. The NODE_OPTIONS environment variable can be used to pass all kinds of custom options to the Node.js runtime and isn't typically used by apps in production. Most apps can safely disable this fuse.

property grantFileProtocolExtraPrivileges

grantFileProtocolExtraPrivileges?: boolean;

The grantFileProtocolExtraPrivileges fuse changes whether pages loaded from the file:// protocol are given privileges beyond what they would receive in a traditional web browser. This behavior was core to Electron apps in original versions of Electron but is no longer required as apps should be [serving local files from custom protocols](https://github.com/electron/electron/blob/main/docs/tutorial/security.md#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) now instead. If you aren't serving pages from file:// you should disable this fuse. The extra privileges granted to the file:// protocol by this fuse are incompletely documented below:
- file:// protocol pages can use fetch to load other assets over file:// - file:// protocol pages can use service workers - file:// protocol pages have universal access granted to child frames also running on file:// protocols regardless of sandbox settings

property loadBrowserProcessSpecificV8Snapshot

loadBrowserProcessSpecificV8Snapshot?: boolean;

The loadBrowserProcessSpecificV8Snapshot fuse changes which V8 snapshot file is used for the browser process. By default Electron's processes will all use the same V8 snapshot file. When this fuse is enabled the browser process uses the file called browser_v8_context_snapshot.bin for its V8 snapshot. The other processes will use the V8 snapshot file that they normally do.

property onlyLoadAppFromAsar

onlyLoadAppFromAsar?: boolean;

The onlyLoadAppFromAsar fuse changes the search system that Electron uses to locate your app code. By default Electron will search in the following order app.asar -> app -> default_app.asar. When this fuse is enabled the search order becomes a single entry app.asar thus ensuring that when combined with the embeddedAsarIntegrityValidation fuse it is impossible to load non-validated code.

property resetAdHocDarwinSignature

resetAdHocDarwinSignature?: boolean;

Resets the app signature, specifically used for macOS. Note: This should be unneeded since electron-builder signs the app directly after flipping the fuses. Ref: https://github.com/electron/fuses?tab=readme-ov-file#apple-silicon

property runAsNode

runAsNode?: boolean;

The runAsNode fuse toggles whether the ELECTRON_RUN_AS_NODE environment variable is respected or not. Please note that if this fuse is disabled then process.fork in the main process will not function as expected as it depends on this environment variable to function. Instead, we recommend that you use [Utility Processes](https://github.com/electron/electron/blob/main/docs/api/utility-process.md), which work for many use cases where you need a standalone Node.js process (like a Sqlite server process or similar scenarios).

interface Hooks

interface Hooks {}

property afterAllArtifactBuild

readonly afterAllArtifactBuild?:
    | Hook<BuildResult, Array<string>>
    | string
    | null;

The function (or path to file or module id) to be run after all artifacts are built. Receives a BuildResult. May return an array of additional file paths to publish.
For file/module setup, see beforePack.
Example 1
exports.default = function () { // return additional files to publish return ["/path/to/additional/result/file"] }

property afterExtract

readonly afterExtract?: Hook<AfterExtractContext, void> | string | null;

The function (or path to file or module id) to be run after the prebuilt Electron binary has been extracted to the output directory. Receives an AfterExtractContext. For file/module setup, see beforePack.

property afterPack

readonly afterPack?: Hook<AfterPackContext, void> | string | null;

The function (or path to file or module id) to be run after pack but before pack into distributable format and sign. Receives an AfterPackContext. For file/module setup, see beforePack.

property afterSign

readonly afterSign?: Hook<AfterPackContext, void> | string | null;

The function (or path to file or module id) to be run after pack and sign but before pack into distributable format. Receives an AfterPackContext. For file/module setup, see beforePack.

property appxManifestCreated

readonly appxManifestCreated?: Hook<string, void> | string | null;

The function (or path to file or module id) to be run after Appx manifest created on disk - not packed into .appx package yet.

property artifactBuildCompleted

readonly artifactBuildCompleted?: Hook<ArtifactCreated, void> | string | null;

The function (or path to file or module id) to be run when an individual artifact build completes. Receives an ArtifactCreated. For file/module setup, see beforePack.

property artifactBuildStarted

readonly artifactBuildStarted?: Hook<ArtifactBuildStarted, void> | string | null;

The function (or path to file or module id) to be run when an individual artifact build starts. Receives an ArtifactBuildStarted. For file/module setup, see beforePack.

property beforeBuild

readonly beforeBuild?: Hook<BeforeBuildContext, boolean | void> | string | null;

The function (or path to file or module id) to be run before dependencies are installed or rebuilt. Works when npmRebuild is set to true. Resolving to false will skip dependencies install or rebuild.
If provided and node_modules are missing, it will not invoke production dependencies check.

property beforePack

readonly beforePack?: Hook<BeforePackContext, void> | string | null;

The function (or path to file or module id) to be run before pack. Receives a BeforePackContext.

Can be specified inline as a function in JavaScript configs:

// electron-builder.config.js
module.exports = {
  beforePack: async (context) => {
    // your code
  }
}

Or as a path to a module that exports the function as its default export:

{ "build": { "beforePack": "./myBeforePackHook.js" } }

// myBeforePackHook.js
exports.default = async function(context) {
  // your custom code
}

property electronDist

readonly electronDist?:
    | Hook<PrepareApplicationStageDirectoryOptions, string>
    | string
    | null;

The function (or path to file or module id) to be run when staging the electron artifact environment. Returns the path to custom Electron build (e.g. ~/electron/out/R) or folder of electron zips.
Zip files must follow the pattern electron-v${version}-${platformName}-${arch}.zip, otherwise it will be assumed to be an unpacked Electron app directory

property msiProjectCreated

readonly msiProjectCreated?: Hook<string, void> | string | null;

The function (or path to file or module id) to be run after MSI project created on disk - not packed into .msi package yet.

property onNodeModuleFile

readonly onNodeModuleFile?: Hook<string, void | boolean> | string | null;

The function (or path to file or module id) to be [run on each node module](#onnodemodulefile) file. Returning true/false will determine whether to force include or to use the default copier logic

interface LinuxConfiguration

interface LinuxConfiguration
    extends CommonLinuxOptions,
        PlatformSpecificBuildOptions {}

property icon

readonly icon?: string;

The path to icon set directory or one png file, relative to the [build resources](https://www.electron.build/contents#extraresources) or to the project directory. The icon filename must contain the size (e.g. 32x32.png) of the icon. By default will be generated automatically based on the macOS icns file.

property maintainer

readonly maintainer?: string | null;

The maintainer. Defaults to [author](https://www.electron.build/configuration#author).

property syncDesktopName

readonly syncDesktopName?: boolean;

When true, the installed .desktop filename is derived from desktopName in package.json (minus the .desktop suffix) so that it matches StartupWMClass and Electron's app_id. Falls back to executableName when desktopName is absent.
false
Remarks
In v27 the default will change to true.
See Also
- https://github.com/electron-userland/electron-builder/issues/9103

property target

readonly target?: TargetConfigType;

Target package type: list of AppImage, flatpak, snap, deb, rpm, freebsd, pacman, p5p, apk, 7z, zip, tar.xz, tar.lz, tar.gz, tar.bz2, dir.
electron-builder [docker image](https://www.electron.build/multi-platform-build#docker) can be used to build Linux targets on any platform.
Please [do not put an AppImage into another archive](https://github.com/probonopd/AppImageKit/wiki/Creating-AppImages#common-mistake) like a .zip or .tar.gz. AppImage

property vendor

readonly vendor?: string | null;

The vendor. Defaults to [author](https://www.electron.build/configuration#author).

interface LinuxDesktopFile

interface LinuxDesktopFile {}

Example Spec: https://specifications.freedesktop.org/desktop-entry-spec/latest/example.html

property desktopActions

desktopActions?: {
    [ActionName: string]: any;
} | null;

[Desktop Actions <ActionName>] metadata entries (name to value).

Config Example:

desktopActions: {
   NewWindow: {
      Name: 'New Window',
      Exec: 'app --new-window',
   }
}

property entry

entry?: {
    [k: string]: string;
} | null;

[Desktop Entry] metadata entries (name to value). Overwrites default values calculated by electron-builder

interface LinuxTargetSpecificOptions

interface LinuxTargetSpecificOptions
    extends CommonLinuxOptions,
        TargetSpecificOptions {}

property afterInstall

readonly afterInstall?: string | null;

File path to script to be passed to FPM for --after-install arg.

property afterRemove

readonly afterRemove?: string | null;

File path to script to be passed to FPM for --after-remove arg.

property appArmorProfile

readonly appArmorProfile?: string | null;

File path to custom AppArmor profile (Ubuntu 24+)

property compression

readonly compression?:
    | 'gz'
    | 'bzip2'
    | 'xz'
    | 'xzmt'
    | 'gzip'
    | 'zst'
    | 'zstd'
    | null;

The compression type passed to fpm. For deb, rpm, and pacman targets prefer the typed per-format interfaces (DebOptions, RpmOptions, PacmanOptions) which narrow this to only the values that fpm actually accepts for that format. xz

property depends

readonly depends?: Array<string> | null;

Package dependencies. rpm defaults to ["gtk3", "libnotify", "nss", "libXScrnSaver", "(libXtst or libXtst6)", "xdg-utils", "at-spi2-core", "(libuuid or libuuid1)"] pacman defaults to ["c-ares", "ffmpeg", "gtk3", "http-parser", "libevent", "libvpx", "libxslt", "libxss", "minizip", "nss", "re2", "snappy", "libnotify", "libappindicator-gtk3"]

property fpm

readonly fpm?: Array<string> | null;

*Advanced only* The [fpm](https://fpm.readthedocs.io/en/latest/cli-reference.html) options.
Example: ["--before-install=build/deb-preinstall.sh", "--after-upgrade=build/deb-postinstall.sh"]

property icon

readonly icon?: string;

property maintainer

readonly maintainer?: string | null;

property packageCategory

readonly packageCategory?: string | null;

The package category.

property packageName

readonly packageName?: string | null;

The name of the package.

property vendor

readonly vendor?: string | null;

interface MacConfiguration

interface MacConfiguration extends PlatformSpecificBuildOptions {}

property additionalArguments

readonly additionalArguments?: Array<string> | null;

Array of strings specifying additional arguments to pass to the codesign command used to sign a specific file.
Some subresources that you may include in your Electron app may need to be signed with --deep, this is not typically safe to apply to the entire Electron app and therefore should be applied to just your file. Usage Example: ['--deep']

property binaries

readonly binaries?: Array<string> | null;

Paths of any extra binaries that need to be signed.

property bundleShortVersion

readonly bundleShortVersion?: string | null;

The CFBundleShortVersionString. Do not use it unless you need to.

property bundleVersion

readonly bundleVersion?: string | null;

The CFBundleVersion. Do not use it unless [you need to](https://github.com/electron-userland/electron-builder/issues/565#issuecomment-230678643).

property category

readonly category?: string | null;

The application category type, as shown in the Finder via *View -> Arrange by Application Category* when viewing the Applications directory.
For example, "category": "public.app-category.developer-tools" will set the application category to *Developer Tools*.
Valid values are listed in [Apple's documentation](https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/LaunchServicesKeys.html#//apple_ref/doc/uid/TP40009250-SW8).

property cscInstallerKeyPassword

readonly cscInstallerKeyPassword?: string | null;

property cscInstallerLink

readonly cscInstallerLink?: string | null;

property darkModeSupport

readonly darkModeSupport?: boolean;

Whether a dark mode is supported. If your app does have a dark mode, you can make your app follow the system-wide dark mode setting. false

property entitlements

readonly entitlements?: string | null;

The path to entitlements file for signing the app. build/entitlements.mac.plist will be used if exists (it is a recommended way to set). MAS entitlements is specified in the [mas](https://www.electron.build/mas). See [this folder in osx-sign's repository](https://github.com/electron/osx-sign/tree/main/entitlements) for examples. Be aware that your app may crash if the right entitlements are not set like com.apple.security.cs.allow-jit for example on arm64 builds with Electron 20+. See [Signing and Notarizing macOS Builds from the Electron documentation](https://www.electronjs.org/docs/latest/tutorial/code-signing#signing--notarizing-macos-builds) for more information.

property entitlementsInherit

readonly entitlementsInherit?: string | null;

The path to child entitlements which inherit the security settings for signing frameworks and bundles of a distribution. build/entitlements.mac.inherit.plist will be used if exists (it is a recommended way to set). See [this folder in osx-sign's repository](https://github.com/electron/osx-sign/tree/main/entitlements) for examples.
This option only applies when signing with entitlements provided.

property entitlementsLoginHelper

readonly entitlementsLoginHelper?: string | null;

Path to login helper entitlement file. When using App Sandbox, the the com.apple.security.inherit key that is normally in the inherited entitlements cannot be inherited since the login helper is a standalone executable. Defaults to the value provided for entitlements. This option only applies when signing with entitlements provided.

property extendInfo

readonly extendInfo?: any;

The extra entries for Info.plist.

property extraDistFiles

readonly extraDistFiles?: Array<string> | string | null;

Extra files to put in archive. Not applicable for tar.*.

property gatekeeperAssess

readonly gatekeeperAssess?: boolean;

Whether to let @electron/osx-sign validate the signing or not. false

property hardenedRuntime

readonly hardenedRuntime?: boolean;

Whether your app has to be signed with hardened runtime.
When using ad-hoc signing (identity: "-"), hardened runtime enforces library validation which will reject pre-signed Electron frameworks that carry a different Team ID. To resolve this either set hardenedRuntime: false or add the [com.apple.security.cs.disable-library-validation](https://developer.apple.com/documentation/BundleResources/Entitlements/com.apple.security.cs.disable-library-validation) entitlement to your entitlements file. true

property helperBundleId

readonly helperBundleId?: string | null;

The bundle identifier to use in the application helper's plist. ${appBundleIdentifier}.helper

property helperEHBundleId

readonly helperEHBundleId?: string | null;

The bundle identifier to use in the EH helper's plist. ${appBundleIdentifier}.helper.EH

property helperGPUBundleId

readonly helperGPUBundleId?: string | null;

The bundle identifier to use in the GPU helper's plist. ${appBundleIdentifier}.helper.GPU

property helperNPBundleId

readonly helperNPBundleId?: string | null;

The bundle identifier to use in the NP helper's plist. ${appBundleIdentifier}.helper.NP

property helperPluginBundleId

readonly helperPluginBundleId?: string | null;

The bundle identifier to use in the Plugin helper's plist. ${appBundleIdentifier}.helper.Plugin

property helperRendererBundleId

readonly helperRendererBundleId?: string | null;

The bundle identifier to use in the Renderer helper's plist. ${appBundleIdentifier}.helper.Renderer

property icon

readonly icon?: string | null;

The path to application icon. Accepts .icns (legacy) or .icon (Icon Composer asset). If a .icon asset is provided, it will be preferred and compiled to an asset catalog. build/icon.icns

property identity

readonly identity?: string | null;

The signing identity (certificate name) to use when signing. Consider using environment variables [CSC_LINK or CSC_NAME](https://www.electron.build/code-signing) instead of specifying this option. MAS installer identity is specified in the [mas](https://www.electron.build/mas).
- **Not set** (default): electron-builder searches the keychain for a valid signing certificate. If none is found, signing is skipped for all architectures — there is no automatic ad-hoc fallback. - **null**: skip signing entirely. - **"-"**: opt in to ad-hoc signing explicitly. Note that hardenedRuntime: true (the default) combined with ad-hoc signing requires the [com.apple.security.cs.disable-library-validation](https://developer.apple.com/documentation/BundleResources/Entitlements/com.apple.security.cs.disable-library-validation) entitlement to prevent app launch failures; otherwise set hardenedRuntime: false.

property mergeASARs

readonly mergeASARs?: boolean;

Whether to merge ASAR files for different architectures or not.
This option has no effect unless building for "universal" arch. true

property minimumSystemVersion

readonly minimumSystemVersion?: string | null;

The minimum version of macOS required for the app to run. Corresponds to LSMinimumSystemVersion.

property notarize

readonly notarize?: boolean;

Whether to disable electron-builder's [@electron/notarize](https://github.com/electron/notarize) integration.
Note: In order to activate the notarization step You MUST specify one of the following via environment variables:
1. APPLE_API_KEY, APPLE_API_KEY_ID and APPLE_API_ISSUER. 2. APPLE_ID, APPLE_APP_SPECIFIC_PASSWORD, and APPLE_TEAM_ID 3. APPLE_KEYCHAIN and APPLE_KEYCHAIN_PROFILE
For security reasons it is recommended to use the first option (see https://github.com/electron-userland/electron-builder/issues/7859)

property preAutoEntitlements

readonly preAutoEntitlements?: boolean;

Whether to enable entitlements automation from @electron/osx-sign. true

property provisioningProfile

readonly provisioningProfile?: string | null;

The path to the provisioning profile to use when signing, absolute or relative to the app root.

property requirements

readonly requirements?: string | null;

Path of [requirements file](https://developer.apple.com/library/mac/documentation/Security/Conceptual/CodeSigningGuide/RequirementLang/RequirementLang.html) used in signing. Not applicable for MAS.

property sign

readonly sign?: CustomMacSign | string | null;

The custom function (or path to file or module id) to sign an app bundle.

property signIgnore

readonly signIgnore?: Array<string> | string | null;

Regex or an array of regex's that signal skipping signing a file.

property singleArchFiles

readonly singleArchFiles?: string | null;

Minimatch pattern of paths that are allowed to be present in one of the ASAR files, but not in the other.
This option has no effect unless building for "universal" arch and applies only if mergeASARs is true.

property strictVerify

readonly strictVerify?: boolean;

Whether to let @electron/osx-sign verify the contents or not. true

property target

readonly target?:
    | Array<MacOsTargetName | TargetConfiguration>
    | MacOsTargetName
    | TargetConfiguration
    | null;

The target package type: list of default, dmg, mas, mas-dev, pkg, 7z, zip, tar.xz, tar.lz, tar.gz, tar.bz2, dir. Note: Squirrel.Mac auto update mechanism requires both dmg and zip to be enabled, even when only dmg is used. Disabling zip will break auto update in dmg packages. default (dmg and zip for Squirrel.Mac)

property timestamp

readonly timestamp?: string | null;

Specify the URL of the timestamp authority server

property type

readonly type?: 'distribution' | 'development' | null;

Whether to sign app for development or for distribution. distribution

property x64ArchFiles

readonly x64ArchFiles?: string | null;

Minimatch pattern of paths that are allowed to be x64 binaries in both ASAR files
This option has no effect unless building for "universal" arch and applies only if mergeASARs is true.

interface MasConfiguration

interface MasConfiguration extends MacConfiguration {}

property binaries

readonly binaries?: Array<string> | null;

Paths of any extra binaries that need to be signed.

property entitlements

readonly entitlements?: string | null;

The path to entitlements file for signing the app. build/entitlements.mas.plist will be used if exists (it is a recommended way to set). See [this folder in osx-sign's repository](https://github.com/electron/osx-sign/tree/main/entitlements) for examples. Be aware that your app may crash if the right entitlements are not set like com.apple.security.cs.allow-jit for example on arm64 builds with Electron 20+. See [Signing and Notarizing macOS Builds from the Electron documentation](https://www.electronjs.org/docs/latest/tutorial/code-signing#signing--notarizing-macos-builds) for more information.

property entitlementsInherit

readonly entitlementsInherit?: string | null;

The path to child entitlements which inherit the security settings for signing frameworks and bundles of a distribution. build/entitlements.mas.inherit.plist will be used if exists (it is a recommended way to set). See [this folder in osx-sign's repository](https://github.com/electron/osx-sign/tree/main/entitlements) for examples.

interface Metadata

interface Metadata {}

property author

readonly author?: AuthorMetadata | null;

property build

readonly build?: Configuration;

The electron-builder configuration.

property dependencies

readonly dependencies?: Record<string, string>;

property description

readonly description?: string;

The application description.

property desktopName

readonly desktopName?: string | null;

property homepage

readonly homepage?: string | null;

The url to the project [homepage](https://docs.npmjs.com/files/package.json#homepage) (NuGet Package projectUrl (optional) or Linux Package URL (required)).
If not specified and your project repository is public on GitHub, it will be https://github.com/${user}/${project} by default.

property license

readonly license?: string | null;

*linux-only.* The [license](https://docs.npmjs.com/files/package.json#license) name.

property main

readonly main?: string | null;

property name

readonly name?: string;

The application name. Required.

property productName

readonly productName?: string | null;

property repository

readonly repository?: string | RepositoryInfo | null;

The [repository](https://docs.npmjs.com/files/package.json#repository).

property shortVersion

readonly shortVersion?: string | null;

property shortVersionWindows

readonly shortVersionWindows?: string | null;

property type

readonly type?: string;

property version

readonly version?: string;

interface MetadataDirectories

interface MetadataDirectories {}

property app

readonly app?: string | null;

The application directory (containing the application package.json), defaults to app, www or working directory.

property buildResources

readonly buildResources?: string | null;

The path to build resources.
Please note — build resources are not packed into the app. If you need to use some files, e.g. as tray icon, please include required files explicitly: "files": ["**\/*", "build/icon.*"] build

property output

readonly output?: string | null;

The output directory. [File macros](https://www.electron.build/file-patterns#file-macros) are supported. dist

interface MsiOptions

interface MsiOptions
    extends CommonWindowsInstallerConfiguration,
        TargetSpecificOptions {}

property additionalLightArgs

readonly additionalLightArgs?: Array<string> | null;

Any additional arguments to be passed to the light.ext, such as ["-cultures:ja-jp"]

property additionalWixArgs

readonly additionalWixArgs?: Array<string> | null;

Any additional arguments to be passed to the WiX installer compiler, such as ["-ext", "WixUtilExtension"]

property oneClick

readonly oneClick?: boolean;

One-click installation. true

property upgradeCode

readonly upgradeCode?: string | null;

The [upgrade code](https://msdn.microsoft.com/en-us/library/windows/desktop/aa372375(v=vs.85).aspx). Optional, by default generated using app id.

property warningsAsErrors

readonly warningsAsErrors?: boolean;

If warningsAsErrors is true (default): treat warnings as errors. If warningsAsErrors is false: allow warnings. true

interface MsiWrappedOptions

interface MsiWrappedOptions
    extends CommonWindowsInstallerConfiguration,
        TargetSpecificOptions {}

property additionalWixArgs

readonly additionalWixArgs?: Array<string> | null;

Any additional arguments to be passed to the WiX installer compiler, such as ["-ext", "WixUtilExtension"]

property impersonate

readonly impersonate?: boolean;

Determines if the wrapped installer should be executed with impersonation false

property upgradeCode

readonly upgradeCode?: string | null;

The [upgrade code](https://msdn.microsoft.com/en-us/library/windows/desktop/aa372375(v=vs.85).aspx). Optional, by default generated using app id.

property warningsAsErrors

readonly warningsAsErrors?: boolean;

If warningsAsErrors is true (default): treat warnings as errors. If warningsAsErrors is false: allow warnings. true

property wrappedInstallerArgs

readonly wrappedInstallerArgs?: string | null;

Extra arguments to provide to the wrapped installer (ie: /S for silent install)

interface NsisOptions

interface NsisOptions
    extends CommonNsisOptions,
        CommonWindowsInstallerConfiguration,
        TargetSpecificOptions {}

property allowElevation

readonly allowElevation?: boolean;

*assisted installer only.* Allow requesting for elevation. If false, user will have to restart installer with elevated permissions. true

property allowToChangeInstallationDirectory

readonly allowToChangeInstallationDirectory?: boolean;

*assisted installer only.* Whether to allow user to change installation directory. false

property artifactName

readonly artifactName?: string | null;

The [artifact file name template](https://www.electron.build/docs/configuration#artifact-file-name-template). Defaults to ${productName} Setup ${version}.${ext}.

property buildUniversalInstaller

readonly buildUniversalInstaller?: boolean;

Disable building an universal installer of the archs specified in the target configuration *Not supported for nsis-web* true

property deleteAppDataOnUninstall

readonly deleteAppDataOnUninstall?: boolean;

*one-click installer only.* Whether to delete app data on uninstall. false

property differentialPackage

readonly differentialPackage?: boolean;

Marks the package as built with differential download support for the update server.

property displayLanguageSelector

readonly displayLanguageSelector?: boolean;

Whether to display a language selection dialog. Not recommended (by default will be detected using OS language). false

property include

readonly include?: string | null;

The path to NSIS include script to customize installer. Defaults to build/installer.nsh. See [Custom NSIS script](#custom-nsis-script).

property installerHeader

readonly installerHeader?: string | null;

*assisted installer only.* MUI_HEADERIMAGE, relative to the [build resources](https://www.electron.build/docs/contents#extraresources) or to the project directory. build/installerHeader.bmp

property installerHeaderIcon

readonly installerHeaderIcon?: string | null;

*one-click installer only.* The path to header icon (above the progress bar), relative to the [build resources](https://www.electron.build/docs/contents#extraresources) or to the project directory. Defaults to build/installerHeaderIcon.ico or application icon.

property installerIcon

readonly installerIcon?: string | null;

The path to installer icon, relative to the [build resources](https://www.electron.build/docs/contents#extraresources) or to the project directory. Defaults to build/installerIcon.ico or application icon.

property installerLanguages

readonly installerLanguages?: Array<string> | string | null;

The installer languages (e.g. en_US, de_DE). Change only if you understand what do you do and for what.

property installerSidebar

readonly installerSidebar?: string | null;

*assisted installer only.* MUI_WELCOMEFINISHPAGE_BITMAP, relative to the [build resources](https://www.electron.build/docs/contents#extraresources) or to the project directory. Defaults to build/installerSidebar.bmp or ${NSISDIR}\\Contrib\\Graphics\\Wizard\\nsis3-metro.bmp. Image size 164 × 314 pixels.

property language

readonly language?: string | null;

[LCID Dec](https://msdn.microsoft.com/en-au/goglobal/bb964664.aspx), defaults to 1033(English - United States).

property license

readonly license?: string | null;

The path to EULA license file. Defaults to license.txt or eula.txt (or uppercase variants). In addition to txt, rtf and html supported (don't forget to use target="_blank" for links).
Multiple license files in different languages are supported — use lang postfix (e.g. _de, _ru). For example, create files license_de.txt and license_en.txt in the build resources. If OS language is german, license_de.txt will be displayed. See map of [language code to name](https://github.com/meikidd/iso-639-1/blob/master/src/data.js).
Appropriate license file will be selected by user OS language.

property multiLanguageInstaller

readonly multiLanguageInstaller?: boolean;

Whether to create multi-language installer. Defaults to unicode option value.

property oneClick

readonly oneClick?: boolean;

Whether to create one-click installer or assisted. true

property packElevateHelper

readonly packElevateHelper?: boolean;

Whether to pack the elevate executable (required for electron-updater if per-machine installer used or can be used in the future). Ignored if perMachine is set to true. true

property perMachine

readonly perMachine?: boolean;

Whether to show install mode installer page (choice per-machine or per-user) for assisted installer. Or whether installation always per all users (per-machine).
If oneClick is true (default): Whether to install per all users (per-machine).
If oneClick is false and perMachine is true: no install mode installer page, always install per-machine.
If oneClick is false and perMachine is false (default): install mode installer page. false

property preCompressedFileExtensions

readonly preCompressedFileExtensions?: Array<string> | string | null;

The file extension of files that will be not compressed. Applicable only for extraResources and extraFiles files. [".avi", ".mov", ".m4v", ".mp4", ".m4p", ".qt", ".mkv", ".webm", ".vmdk"]

property removeDefaultUninstallWelcomePage

readonly removeDefaultUninstallWelcomePage?: boolean;

*assisted installer only.* remove the default uninstall welcome page. false

property script

readonly script?: string | null;

The path to NSIS script to customize installer. Defaults to build/installer.nsi. See [Custom NSIS script](#custom-nsis-script).

property selectPerMachineByDefault

readonly selectPerMachineByDefault?: boolean;

Whether to set per-machine or per-user installation as default selection on the install mode installer page.
false

property uninstallDisplayName

readonly uninstallDisplayName?: string | null;

The uninstaller display name in the control panel. ${productName} ${version}

property uninstallerIcon

readonly uninstallerIcon?: string | null;

The path to uninstaller icon, relative to the [build resources](https://www.electron.build/docs/contents#extraresources) or to the project directory. Defaults to build/uninstallerIcon.ico or application icon.

property uninstallerSidebar

readonly uninstallerSidebar?: string | null;

*assisted installer only.* MUI_UNWELCOMEFINISHPAGE_BITMAP, relative to the [build resources](https://www.electron.build/docs/contents#extraresources) or to the project directory. Defaults to installerSidebar option or build/uninstallerSidebar.bmp or build/installerSidebar.bmp or ${NSISDIR}\\Contrib\\Graphics\\Wizard\\nsis3-metro.bmp

property uninstallUrlHelp

readonly uninstallUrlHelp?: string | null;

The URL to the uninstaller help page in the control panel. Defaults to [homepage](https://www.electron.build/docs/configuration#homepage) from application package.json.

property uninstallUrlInfoAbout

readonly uninstallUrlInfoAbout?: string | null;

The URL to the uninstaller info about page in the control panel. Defaults to [homepage](https://www.electron.build/docs/configuration#homepage) from application package.json.

property uninstallUrlReadme

readonly uninstallUrlReadme?: string | null;

The URL to the uninstaller readme page in the control panel. Defaults to [homepage](https://www.electron.build/docs/configuration#homepage) from application package.json.

property uninstallUrlUpdateInfo

readonly uninstallUrlUpdateInfo?: string | null;

The URL to the uninstaller update info page in the control panel. Defaults to [homepage](https://www.electron.build/docs/configuration#homepage) from application package.json.

interface NsisWebOptions

interface NsisWebOptions extends NsisOptions {}

Web Installer options.

property appPackageUrl

readonly appPackageUrl?: string | null;

The application package download URL. Optional — by default computed using publish configuration.
URL like https://example.com/download/latest allows web installer to be version independent (installer will download latest application package). Please note — it is [full URL](https://github.com/electron-userland/electron-builder/issues/1810#issuecomment-317650878).
Custom X-Arch http header is set to 32 or 64.

property artifactName

readonly artifactName?: string | null;

The [artifact file name template](https://www.electron.build/docs/configuration#artifact-file-name-template). Defaults to ${productName} Web Setup ${version}.${ext}.

property buildUniversalInstaller

readonly buildUniversalInstaller?: true;

Override for NsisOptions.buildUniversalInstaller. nsis-web requires universal installer true

interface PackagerOptions

interface PackagerOptions {}

property config

readonly config?: Configuration | string | null;

property effectiveOptionComputed

readonly effectiveOptionComputed?: (options: any) => Promise<boolean>;

property linux

linux?: Array<string>;

property mac

mac?: Array<string>;

property platformPackagerFactory

platformPackagerFactory?:
    | ((info: Packager, platform: Platform) => PlatformPackager<any>)
    | null;

property prepackaged

readonly prepackaged?: string | null;

property projectDir

projectDir?: string | null;

property targets

targets?: Map<Platform, Map<Arch, Array<string>>>;

property win

win?: Array<string>;

interface PackContext

interface PackContext {}

property appOutDir

readonly appOutDir: string;

property arch

readonly arch: Arch;

property electronPlatformName

readonly electronPlatformName: string;

property outDir

readonly outDir: string;

property packager

readonly packager: PlatformPackager<any>;

property targets

readonly targets: Array<Target>;

interface PacmanOptions

interface PacmanOptions extends LinuxTargetSpecificOptions {}

property compression

readonly compression?: 'gz' | 'bzip2' | 'xz' | 'zstd' | null;

interface PkgBackgroundOptions

interface PkgBackgroundOptions {}

Options for the background image in a PKG installer

property alignment

alignment?: BackgroundAlignment | null;

Alignment of the background image. Options are: center, left, right, top, bottom, topleft, topright, bottomleft, bottomright center

property file

file?: string;

Path to the image to use as an installer background.

property scaling

scaling?: BackgroundScaling | null;

Scaling of the background image. Options are: tofit, none, proportional tofit

interface PkgOptions

interface PkgOptions extends TargetSpecificOptions {}

macOS product archive options.

property allowAnywhere

readonly allowAnywhere?: boolean | null;

Whether can be installed at the root of any volume, including non-system volumes. Otherwise, it cannot be installed at the root of a volume.
Corresponds to [enable_anywhere](https://developer.apple.com/library/content/documentation/DeveloperTools/Reference/DistributionDefinitionRef/Chapters/Distribution_XML_Ref.html#//apple_ref/doc/uid/TP40005370-CH100-SW70). true

property allowCurrentUserHome

readonly allowCurrentUserHome?: boolean | null;

Whether can be installed into the current user’s home directory. A home directory installation is done as the current user (not as root), and it cannot write outside of the home directory. If the product cannot be installed in the user’s home directory and be not completely functional from user’s home directory.
Corresponds to [enable_currentUserHome](https://developer.apple.com/library/content/documentation/DeveloperTools/Reference/DistributionDefinitionRef/Chapters/Distribution_XML_Ref.html#//apple_ref/doc/uid/TP40005370-CH100-SW70). true

property allowRootDirectory

readonly allowRootDirectory?: boolean | null;

Whether can be installed into the root directory. Should usually be true unless the product can be installed only to the user’s home directory.
Corresponds to [enable_localSystem](https://developer.apple.com/library/content/documentation/DeveloperTools/Reference/DistributionDefinitionRef/Chapters/Distribution_XML_Ref.html#//apple_ref/doc/uid/TP40005370-CH100-SW70). true

property background

readonly background?: PkgBackgroundOptions | null;

Options for the background image for the installer.

property conclusion

readonly conclusion?: string | null;

The path to the conclusion file. This may be used to customize the text on the final "Summary" page of the installer.

property extraPkgsDir

readonly extraPkgsDir?: string | null;

The extra component packages directory (relative to build resources directory) for MacOS product archive Autoscans directory for any .pkg files and adds to productbuild command as --package-path and --package accordingly

property hasStrictIdentifier

readonly hasStrictIdentifier?: boolean | null;

Require identical bundle identifiers at install path? true

property identity

readonly identity?: string | null;

The name of certificate to use when signing. Consider using environment variables [CSC_LINK or CSC_NAME](https://www.electron.build/code-signing) instead of specifying this option.

property installLocation

readonly installLocation?: string | null;

The install location. [Do not use it](https://stackoverflow.com/questions/12863944/how-do-you-specify-a-default-install-location-to-home-with-pkgbuild) to create per-user package. Mostly never you will need to change this option. /Applications would install it as expected into /Applications if the local system domain is chosen, or into $HOME/Applications if the home installation is chosen. /Applications

property isRelocatable

readonly isRelocatable?: boolean | null;

Install bundle over previous version if moved by user? true

property isVersionChecked

readonly isVersionChecked?: boolean | null;

Don't install bundle if newer version on disk? true

property license

readonly license?: string | null;

The path to EULA license file. Defaults to license.txt or eula.txt (or uppercase variants). In addition to txt, rtf and html supported (don't forget to use target="_blank" for links).

property mustClose

readonly mustClose?: Array<string> | null;

Identifies applications that must be closed before the package is installed.
Corresponds to [must-close](https://developer.apple.com/library/archive/documentation/DeveloperTools/Reference/DistributionDefinitionRef/Chapters/Distribution_XML_Ref.html#//apple_ref/doc/uid/TP40005370-CH100-SW77).

property overwriteAction

readonly overwriteAction?: 'upgrade' | 'update' | null;

Specifies how an existing version of the bundle on disk should be handled when the version in the package is installed.
If you specify upgrade, the bundle in the package atomi-cally replaces any version on disk; this has the effect of deleting old paths that no longer exist in the new version of the bundle.
If you specify update, the bundle in the package overwrites the version on disk, and any files not contained in the package will be left intact; this is appropriate when you are delivering an update-only package.
Another effect of update is that the package bundle will not be installed at all if there is not already a version on disk; this allows a package to deliver an update for an app that the user might have deleted.
upgrade

property productbuild

readonly productbuild?: Array<string> | null;

should be not documented, only to experiment

property scripts

readonly scripts?: string | null;

The scripts directory, relative to build (build resources directory). The scripts can be in any language so long as the files are marked executable and have the appropriate shebang indicating the path to the interpreter. Scripts are required to be executable (chmod +x file). build/pkg-scripts
See Also
- [Scripting in installer packages](http://macinstallers.blogspot.de/2012/07/scripting-in-installer-packages.html).

property welcome

readonly welcome?: string | null;

The path to the welcome file. This may be used to customize the text on the Introduction page of the installer.

interface PlatformSpecificBuildOptions

interface PlatformSpecificBuildOptions
    extends TargetSpecificOptions,
        FilesBuildOptions {}

property appId

readonly appId?: string | null;

The application id. Used as [CFBundleIdentifier](https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/20001431-102070) for MacOS and as [Application User Model ID](https://msdn.microsoft.com/en-us/library/windows/desktop/dd378459(v=vs.85).aspx) for Windows (NSIS target only, Squirrel.Windows not supported). It is strongly recommended that an explicit ID is set. com.electron.${name}

property artifactName

readonly artifactName?: string | null;

The [artifact file name template](https://www.electron.build/configuration#artifact-file-name-template). Defaults to ${productName}-${version}.${ext} (some target can have other defaults, see corresponding options).

property asar

readonly asar?: AsarOptions | boolean | null;

Whether to package the application's source code into an archive, using [Electron's archive format](http://electron.atom.io/docs/tutorial/application-packaging/).
Node modules, that must be unpacked, will be detected automatically, you don't need to explicitly set [asarUnpack](#asarUnpack) - please file an issue if this doesn't work. true

property asarUnpack

readonly asarUnpack?: Array<string> | string | null;

A [glob patterns](https://www.electron.build/file-patterns) relative to the [app directory](#directories), which specifies which files to unpack when creating the [asar](http://electron.atom.io/docs/tutorial/application-packaging/) archive.

property compression

readonly compression?: CompressionLevel | null;

The compression level. If you want to rapidly test build, store can reduce build time significantly. maximum doesn't lead to noticeable size difference, but increase build time. normal

property cscKeyPassword

cscKeyPassword?: string | null;

property cscLink

cscLink?: string | null;

property defaultArch

readonly defaultArch?: string;

The default architecture to build for when no --arch flag is specified. Defaults to the current machine's architecture.

property detectUpdateChannel

readonly detectUpdateChannel?: boolean;

Whether to infer update channel from application version pre-release components. e.g. if version 0.12.1-alpha.1, channel will be set to alpha. Otherwise to latest. This does *not* apply to github publishing, which will [never auto-detect the update channel](https://github.com/electron-userland/electron-builder/issues/8589). true

property disableDefaultIgnoredFiles

disableDefaultIgnoredFiles?: boolean | null;

Whether to exclude all default ignored files(https://www.electron.build/contents#files) and options. Defaults to false.
false

property electronLanguages

readonly electronLanguages?: Array<string> | string;

The electron locales to keep. By default, all Electron locales used as-is.

property electronUpdaterCompatibility

readonly electronUpdaterCompatibility?: string | null;

The [electron-updater compatibility](https://www.electron.build/auto-update#compatibility) semver range.

property executableName

readonly executableName?: string | null;

The executable name. Defaults to productName Note: Except for Linux, where this would constitute a breaking change in previous behavior and lead to both invalid executable names and Desktop files. Ref comments in: https://github.com/electron-userland/electron-builder/pull/9068

property fileAssociations

readonly fileAssociations?: Array<FileAssociation> | FileAssociation;

The file associations.

property forceCodeSigning

readonly forceCodeSigning?: boolean;

Whether to fail if app will be not code signed. false

property generateUpdatesFilesForAllChannels

readonly generateUpdatesFilesForAllChannels?: boolean;

Please see [Building and Releasing using Channels](https://github.com/electron-userland/electron-builder/issues/1182#issuecomment-324947139). false

property icon

readonly icon?: string | null;

property protocols

readonly protocols?: Array<Protocol> | Protocol;

The URL protocol schemes.

property publish

publish?: Publish;

Publisher configuration. See [Auto Update](https://www.electron.build/publish) for more information.

property releaseInfo

readonly releaseInfo?: ReleaseInfo;

The release info. Intended for command line usage:
-c.releaseInfo.releaseNotes="new features"

property target

readonly target?:
    | Array<string | TargetConfiguration>
    | string
    | TargetConfiguration
    | null;

The build target(s) for this platform. Can be a target name string, a TargetConfiguration object, or an array of either. Available targets depend on the platform — see platform-specific options (e.g. MacConfiguration.target, WindowsConfiguration.target, LinuxConfiguration.target).

interface PlugDescriptor

interface PlugDescriptor {}

Maps a named plug to its attribute object. null uses snapd defaults for that interface.
Example 1
{ "browser-sandbox": { "interface": "browser-support", "allow-sandbox": true } }

index signature

[key: string]: {
    [key: string]: any;
} | null;

interface PortableOptions

interface PortableOptions extends TargetSpecificOptions, CommonNsisOptions {}

Portable options.

property buildUniversalInstaller

readonly buildUniversalInstaller?: boolean;

Disable building an universal installer of the archs specified in the target configuration true

property requestExecutionLevel

readonly requestExecutionLevel?: 'user' | 'highest' | 'admin';

The [requested execution level](http://nsis.sourceforge.net/Reference/RequestExecutionLevel) for Windows. user

property splashImage

readonly splashImage?: string | null;

The image to show while the portable executable is extracting. This image must be a bitmap (.bmp) image.

property unpackDirName

readonly unpackDirName?: string | boolean;

The unpack directory for the portable app resources.
If set to a string, it will be the name in [TEMP](https://www.askvg.com/where-does-windows-store-temporary-files-and-how-to-change-temp-folder-location/) directory If set explicitly to false, it will use the Windows temp directory ($PLUGINSDIR) that is unique to each launch of the portable application.
Defaults to [uuid](https://github.com/segmentio/ksuid) of build (changed on each build of portable executable).

interface PrepareApplicationStageDirectoryOptions

interface PrepareApplicationStageDirectoryOptions {}

property appOutDir

readonly appOutDir: string;

Platform doesn't process application output directory in any way. Unpack implementation must create or empty dir if need.

property arch

readonly arch: string;

property packager

readonly packager: PlatformPackager<any>;

property platformName

readonly platformName: ElectronPlatformName;

property version

readonly version: string;

interface Protocol

interface Protocol {}

URL Protocol Schemes. Protocols to associate the app with. macOS only.
Please note — on macOS [you need to register an open-url event handler](http://electron.atom.io/docs/api/app/#event-open-url-macos).

property name

readonly name: string;

The name. e.g. IRC server URL.

property role

readonly role?: 'Editor' | 'Viewer' | 'Shell' | 'None';

*macOS-only* The app’s role with respect to the type. Editor

property schemes

readonly schemes: Array<string>;

The schemes. e.g. ["irc", "ircs"].

interface ReleaseInfo

interface ReleaseInfo {}

property releaseDate

releaseDate?: string;

The release date.

property releaseName

releaseName?: string | null;

The release name.

property releaseNotes

releaseNotes?: string | null;

The release notes.

property releaseNotesFile

releaseNotesFile?: string | null;

The path to release notes file. Defaults to release-notes-${platform}.md (where platform it is current platform — mac, linux or windows) or release-notes.md in the [build resources](https://www.electron.build/contents#extraresources).

property vendor

vendor?: {
    [key: string]: any;
} | null;

Vendor specific information.

interface RepositoryInfo

interface RepositoryInfo {}

property url

readonly url: string;

interface RpmOptions

interface RpmOptions extends LinuxTargetSpecificOptions {}

property compression

readonly compression?: 'xz' | 'xzmt' | 'gzip' | 'bzip2' | null;

Passed to fpm via --rpm-compression. "xzmt" uses multi-threaded xz (fpm's RPM default). "xz" is automatically promoted to "xzmt". "gzip" and "bzip2" pass through as-is. xzmt

interface SlotDescriptor

interface SlotDescriptor {}

Maps a named slot to its attribute object. null uses snapd defaults for that interface.
Example 1
{ "mpris": { "name": "chromium" } }

index signature

[key: string]: {
    [key: string]: any;
} | null;

interface SnapcraftOptions

interface SnapcraftOptions extends TargetSpecificOptions {}

New-style snap configuration. Use this via the snapcraft key in your build config. Selects the snapcraft core version and its per-core options.

property base

readonly base: 'core18' | 'core20' | 'core22' | 'core24' | 'custom';

The snap base to use as the execution environment. Determines which set of per-core options (core18, core20, core22, core24, custom) is active.
Only one core may be selected per build target.

property core18

readonly core18?: SnapOptionsLegacy | null;

Configuration for a core18 build. Only active when base is "core18".

property core20

readonly core20?: SnapOptionsLegacy | null;

Configuration for a core20 build. Only active when base is "core20".

property core22

readonly core22?: SnapOptionsLegacy | null;

Configuration for a core22 build. Only active when base is "core22".

property core24

readonly core24?: SnapOptions24 | null;

**[Beta]** Options for building a core24 snap. Uses the snapcraft CLI directly. Inherits desktop-entry fields from CommonLinuxOptions and publish config from TargetSpecificOptions.
Modifiers
- @beta

property cscLink

readonly cscLink?: string;

Snapcraft Store credentials — base64-encoded credentials string or file path. Accepts the same formats as WIN_CSC_LINK / CSC_LINK: base64 data, absolute/relative/~/ file paths, and file:// URIs. Relative paths are resolved against the build resources directory.
Injected as SNAPCRAFT_STORE_CREDENTIALS into every snapcraft subprocess (core18/core20/core22/core24 builds and snapcraft upload). Not applied for base: "custom" — inject credentials manually via environment variables.
The SNAP_CSC_LINK environment variable is the CI-friendly alternative. Generate with: snapcraft export-login - | base64 -w0

property custom

readonly custom?: SnapOptionsCustom | null;

**[Beta]** Pass-through custom snap configuration. electron-builder will read the snapcraft.yaml at yamlPath and use it verbatim — no plugs, extensions, organize mappings, or desktop files are injected.
Modifiers
- @beta

interface SnapOptions

interface SnapOptions extends CommonLinuxOptions, TargetSpecificOptions {}

Flat snap options. Used via the snap key in your build config.
Deprecated
Prefer the snapcraft key with an explicit base field (e.g. { "snapcraft": { "base": "core24", "core24": { ... } } }). The flat snap interface is maintained for backward compatibility and targets core22 and older snap bases only.
Fields inherited from CommonLinuxOptions (e.g. description, category, mimeTypes, executableArgs) are automatically populated from linux.* configuration and do not need to be repeated here. Per-core values take precedence when both are set.

property after

readonly after?: Array<string> | null;

Names of snapcraft parts that must be built before the app part. Defaults to ["desktop-gtk2"].
Use "default" to keep the default and add extras: ["default", "my-helper-part"].

property allowNativeWayland

readonly allowNativeWayland?: boolean | null;

Allow the snap to run with native Wayland support (--ozone-platform=wayland). Defaults to false for Electron < 38 (legacy behaviour); true for Electron ≥ 38. Set explicitly to override the version-based default.

property appPartStage

readonly appPartStage?: Array<string> | null;

Filesets controlling which files from the app part are staged into the snap. Supports individual files, directories, globs, globstars, and exclusions (prefix !). See [Snapcraft filesets](https://snapcraft.io/docs/snapcraft-filesets). When not set, the snap template's default stage list is used for legacy bases (core18/core20/core22).

property assumes

readonly assumes?: Array<string> | string | null;

[Snapd features](https://snapcraft.io/docs/snapcraft-yaml-reference#assumes) that must be present on the host before the snap can be installed.

property autoStart

readonly autoStart?: boolean;

Whether the snap should automatically start on login. false

property base

readonly base?: string | null;

The snap base to use as the execution environment. Examples: core18, core20, core22.
For new projects, use the snapcraft key with base: "core24" instead of this legacy interface.

property buildPackages

readonly buildPackages?: Array<string> | null;

Debian packages required at **build** time (installed inside the build environment).

property compression

readonly compression?: 'xz' | 'lzo' | null;

Compression algorithm for the snap SquashFS image. - xz — smaller file, slower decompression (good for distribution). - lzo — larger file, faster decompression (good for development iteration). Omit to use snapcraft's default (xz).
When not set, linux.compression is mapped automatically: "store" → "lzo", "maximum" → "xz", "normal" → snapcraft default. Explicitly setting this field always overrides the mapped value.

property confinement

readonly confinement?: 'devmode' | 'strict' | 'classic' | null;

The type of [snap confinement](https://snapcraft.io/docs/reference/confinement). - strict — recommended; the snap runs in a fully isolated sandbox. - devmode — sandbox violations are logged but not enforced; for development only. - classic — no confinement; equivalent to a traditionally packaged application. Requires Snap Store approval before publishing. strict

property environment

readonly environment?: {
    [key: string]: string;
} | null;

Environment variables injected into the snap's runtime environment. Merged with the electron-builder default { TMPDIR: "$XDG_RUNTIME_DIR" }. User-supplied values take precedence.

property grade

readonly grade?: 'devel' | 'stable' | null;

The quality grade of the snap. - stable — suitable for all channels, including stable and candidate. - devel — development snapshot; cannot be promoted to stable or candidate. stable

property hooks

readonly hooks?: string | null;

Directory containing [snap hooks](https://snapcraft.io/docs/snap-hooks), relative to the build resources directory (build/). build/snap-hooks

property layout

readonly layout?: {
    [key: string]: {
        [key: string]: string;
    };
} | null;

[Snap layouts](https://snapcraft.io/docs/snap-layouts) — bind-mount or symlink host paths into the snap's namespace, making libraries or config at /usr, /var, /etc, etc. accessible inside the confined environment.

property plugs

readonly plugs?: Array<string | PlugDescriptor> | PlugDescriptor | null;

[Plugs](https://snapcraft.io/docs/reference/interfaces) (consumed interfaces) to declare for the app entry point. Defaults to `["desktop", "desktop-legacy", "home", "x11", "wayland", "unity7", "browser-support", "network", "gsettings", "audio-playback", "pulseaudio", "opengl"]`.
Use "default" in the list to keep the defaults and append extras: ["default", "camera"] adds camera to the standard set.
To configure plug attributes (e.g. allow-sandbox for Chromium's internal sandbox), use a descriptor object:
[ { "browser-sandbox": { "interface": "browser-support", "allow-sandbox": true } }, "another-simple-plug-name" ]

property slots

readonly slots?: Array<string | SlotDescriptor> | SlotDescriptor | null;

[Slots](https://snapcraft.io/docs/reference/interfaces) (provided interfaces) to declare for the app.
To expose an MPRIS player under the Chromium bus name (required for strict confinement):
[{ "mpris": { "name": "chromium" } }]
Chromium [hard-codes](https://source.chromium.org/chromium/chromium/src/+/master:components/system_media_controls/linux/system_media_controls_linux.cc;l=51;bpv=0;bpt=1) the bus name chromium, so the slot name must match for snapd to [allow it](https://forum.snapcraft.io/t/unable-to-use-mpris-interface/15360/7).

property stagePackages

readonly stagePackages?: Array<string> | null;

Ubuntu packages to **stage** alongside the app (equivalent to depends for deb). Defaults to ["libnspr4", "libnss3", "libxss1", "libappindicator3-1", "libsecret-1-0"].
Use the "default" keyword to extend the default list: ["default", "my-extra-lib"] appends my-extra-lib to the defaults.

property summary

readonly summary?: string | null;

A short summary of the snap (max 78 characters). Defaults to [productName](./configuration.md#productName).

property title

readonly title?: string | null;

Display title for the snap (may contain uppercase letters and spaces). Defaults to productName. See [snap format](https://snapcraft.io/docs/snap-format).

property useTemplateApp

readonly useTemplateApp?: boolean;

Whether to use the pre-built Electron snap template for faster builds. When true, electron-builder delegates snap assembly to the upstream Electron snap template rather than running a full snapcraft build, significantly reducing build time. Defaults to true when stagePackages is not customised. Only applicable to x64 and armv7l builds.

interface SourceRepositoryInfo

interface SourceRepositoryInfo {}

property domain

domain?: string;

property project

project: string;

property type

type?: string;

property user

user: string;

interface SquirrelWindowsOptions

interface SquirrelWindowsOptions extends TargetSpecificOptions {}

property customSquirrelVendorDir

readonly customSquirrelVendorDir?: string;

The custom squirrel vendor dir. If not specified will use the Squirrel.Windows that is shipped with electron-installer(https://github.com/electron/windows-installer/tree/main/vendor). After https://github.com/electron-userland/electron-builder-binaries/pull/56 merged, will add electron-builder-binaries to get the latest version of squirrel.

property iconUrl

readonly iconUrl?: string | null;

A URL to an ICO file to use as the application icon (displayed in Control Panel > Programs and Features). Defaults to the Electron icon.
Please note — [local icon file url is not accepted](https://github.com/atom/grunt-electron-installer/issues/73), must be https/http.
If you don't plan to build windows installer, you can omit it. If your project repository is public on GitHub, it will be https://github.com/${u}/${p}/blob/master/build/icon.ico?raw=true by default.

property loadingGif

readonly loadingGif?: string | null;

The path to a .gif file to display during install. build/install-spinner.gif will be used if exists (it is a recommended way to set) (otherwise [default](https://github.com/electron/windows-installer/blob/master/resources/install-spinner.gif)).

property msi

readonly msi?: boolean;

Whether to create an MSI installer. Defaults to false (MSI is not created).

property name

readonly name?: string;

https://github.com/electron-userland/electron-builder/issues/1743

property remoteReleases

readonly remoteReleases?: string | boolean | null;

A URL to your existing updates. Or true to automatically set to your GitHub repository. If given, these will be downloaded to create delta updates.

property remoteToken

readonly remoteToken?: string | null;

Authentication token for remote updates

property useAppIdAsId

readonly useAppIdAsId?: boolean;

Use appId to identify package instead of name.

interface TargetConfiguration

interface TargetConfiguration {}

property arch

readonly arch?: Array<ArchType> | ArchType;

The arch or list of archs.

property target

readonly target: string;

The target name. e.g. snap.

interface TargetSpecificOptions

interface TargetSpecificOptions {}

property artifactName

readonly artifactName?: string | null;

The [artifact file name template](https://www.electron.build/configuration#artifact-file-name-template).

property publish

publish?: Publish;

interface ToolInfo

interface ToolInfo {}

property env

env?: any;

property path

path: string;

interface ToolsetConfig

interface ToolsetConfig {}

Configuration of toolsets utilized by electron-builder

property appimage

readonly appimage?: '0.0.0' | '1.0.2' | '1.0.3' | null;

appimage bundle version to use for Appimage packaging and runtime. Located at https://github.com/electron-userland/electron-builder-binaries/releases?q=appimage&expanded=true 0.0.0 - legacy toolset (appimage)
Betas: 1.0.2 - Runtime 20251108 1.0.3 - Runtime 20251108 (Resolves GH issue #9598)
"0.0.0"

property nsis

readonly nsis?: '0.0.0' | '1.2.1' | null;

nsis bundle version to use for NSIS installer compilation. Located at https://github.com/electron-userland/electron-builder-binaries/releases?q=nsis&expanded=true 0.0.0 - legacy toolset (nsis-3.0.4.1 + nsis-resources-3.4.1)
Betas: 1.2.1 - unified bundle (makensis 3.12 + plugins in one archive, entrypoint scripts auto-set NSISDIR)
"0.0.0"

property winCodeSign

readonly winCodeSign?: '0.0.0' | '1.0.0' | '1.1.0' | null;

win-codesign version to use for signing Windows artifacts. Located at https://github.com/electron-userland/electron-builder-binaries/releases?q=win-codesign&expanded=true
Stable: v0.0.0 (winCodeSign)
Beta: Windows Kits 10.0.26100.0 v1.0.0, v1.1.0
"0.0.0"

property wine

readonly wine?: '0.0.0' | '1.0.1' | null;

wine bundle version to use for running Windows tools on non-Windows platforms. Located at https://github.com/electron-userland/electron-builder-binaries/releases?q=wine&expanded=true 0.0.0 - legacy toolset (wine 4.0.1 portable; mac-only support)
Beta: 1.0.1 - Wine 11 bundle (unified wine binary, ia32 via WoW64)
"0.0.0"

interface WindowsAzureSigningConfiguration

interface WindowsAzureSigningConfiguration {}

property certificateProfileName

readonly certificateProfileName: string;

The Certificate Profile name. Translates to field: CertificateProfileName

property codeSigningAccountName

readonly codeSigningAccountName: string;

The Code Signing Signing Account name. Translates to field: CodeSigningAccountName

property endpoint

readonly endpoint: string;

The Trusted Signing Account endpoint. The URI value must have a URI that aligns to the region your Trusted Signing Account and Certificate Profile you are specifying were created in during the setup of these resources.
Translates to field: Endpoint
Requires one of environment variable configurations for authenticating to Microsoft Entra ID per [Microsoft's documentation](https://learn.microsoft.com/en-us/dotnet/api/azure.identity.environmentcredential?view=azure-dotnet#definition)

property fileDigest

readonly fileDigest?: string;

The File Digest for signing each file. Translates to field: FileDigest SHA256

property publisherName

readonly publisherName: string;

[The publisher name](https://github.com/electron-userland/electron-builder/issues/1187#issuecomment-278972073), exactly as in your code signed certificate. Several names can be provided.

property timestampDigest

readonly timestampDigest?: string;

The Timestamp Digest. Translates to field: TimestampDigest SHA256

property timestampRfc3161

readonly timestampRfc3161?: string;

The Timestamp rfc3161 server. Translates to field: TimestampRfc3161 http://timestamp.acs.microsoft.com

index signature

[k: string]: string | Nullish;

Allow other CLI parameters (verbatim case-sensitive) to Invoke-TrustedSigning Note: Key-Value pairs with undefined/null value are filtered out of the command.

interface WindowsConfiguration

interface WindowsConfiguration extends PlatformSpecificBuildOptions {}

property azureSignOptions

readonly azureSignOptions?: WindowsAzureSigningConfiguration | null;

Options for usage of Azure Trusted Signing service Cannot be used in conjunction with signtoolOptions, signing will default to Azure Trusted Signing

property icon

readonly icon?: string | null;

The path to application icon. build/icon.ico

property legalTrademarks

readonly legalTrademarks?: string | null;

The trademarks and registered trademarks.

property requestedExecutionLevel

readonly requestedExecutionLevel?: RequestedExecutionLevel | null;

The [security level](https://msdn.microsoft.com/en-us/library/6ad1fshk.aspx#Anchor_9) at which the application requests to be executed. Cannot be specified per target, allowed only in the win. asInvoker

property signAndEditExecutable

readonly signAndEditExecutable?: boolean;

Whether to sign and add metadata to executable via [resedit](https://www.npmjs.com/package/resedit). Metadata includes information about the app name/description/version, publisher, copyright, etc. This property also is responsible for adding the app icon and setting execution level. Set to false only if you need to fully disable resedit-based resource editing. To skip only code signing while keeping resource editing, use signExecutable: false instead. true

property signExecutable

readonly signExecutable?: boolean;

Whether to sign Windows executables and any additional files matched by signExts. Set to false to skip Windows code signing while still editing executable resources (icon, metadata, etc. via [resedit](https://www.npmjs.com/package/resedit)). This option is not limited to the main executable edit/sign flow and can also affect signing of Windows installers or other artifacts that use the standard signing path. true

property signExts

readonly signExts?: string[] | null;

Explicit file name/extensions (str.endsWith) to also sign. Advanced option. Supports negative patterns, e.g. example that excludes .appx files: ["somefilename", ".dll", "!.appx"].
See Also
- https://github.com/electron-userland/electron-builder/issues/7329 null

property signtoolOptions

readonly signtoolOptions?: WindowsSigntoolConfiguration | null;

Options for usage with signtool.exe Cannot be used in conjunction with azureSignOptions, signing will default to Azure Trusted Signing

property target

readonly target?: TargetConfigType;

The target package type: list of nsis, nsis-web (Web installer), portable ([portable]https://www.electron.build/nsis#portable) app without installation), appx, msi, msi-wrapped, squirrel, 7z, zip, tar.xz, tar.lz, tar.gz, tar.bz2, dir. AppX package can be built only on Windows 10.
To use Squirrel.Windows please install electron-builder-squirrel-windows dependency.
nsis

property verifyUpdateCodeSignature

readonly verifyUpdateCodeSignature?: boolean;

Whether to verify the signature of an available update before installation. The [publisher name](#publisherName) will be used for the signature verification.
true

interface WindowsSignOptions

interface WindowsSignOptions {}

property options

readonly options: WindowsConfiguration;

property path

readonly path: string;

interface WindowsSignTaskConfiguration

interface WindowsSignTaskConfiguration extends WindowsSignToolOptions {}

property cscInfo

readonly cscInfo: FileCodeSigningInfo | CertificateFromStoreInfo | null;

property hash

hash: string;

property isNest

isNest: boolean;

property resultOutputPath

resultOutputPath?: string;

interface WindowsSigntoolConfiguration

interface WindowsSigntoolConfiguration {}

property additionalCertificateFile

readonly additionalCertificateFile?: string | null;

The path to an additional certificate file you want to add to the signature block.

property certificateFile

readonly certificateFile?: string | null;

The path to the *.pfx certificate you want to sign with. Please use it only if you cannot use env variable CSC_LINK (WIN_CSC_LINK) for some reason. Please see [Code Signing](https://www.electron.build/code-signing).

property certificatePassword

readonly certificatePassword?: string | null;

The password to the certificate provided in certificateFile. Please use it only if you cannot use env variable CSC_KEY_PASSWORD (WIN_CSC_KEY_PASSWORD) for some reason. Please see [Code Signing](https://www.electron.build/code-signing).

property certificateSha1

readonly certificateSha1?: string | null;

The SHA1 hash of the signing certificate. The SHA1 hash is commonly specified when multiple certificates satisfy the criteria specified by the remaining switches. Works only on Windows (or on macOS if [Parallels Desktop](https://www.parallels.com/products/desktop/) Windows 10 virtual machines exits).

property certificateSubjectName

readonly certificateSubjectName?: string | null;

The name of the subject of the signing certificate, which is often labeled with the field name issued to. Required only for EV Code Signing and works only on Windows (or on macOS if [Parallels Desktop](https://www.parallels.com/products/desktop/) Windows 10 virtual machines exits).

property publisherName

readonly publisherName?: string | Array<string> | null;

[The publisher name](https://github.com/electron-userland/electron-builder/issues/1187#issuecomment-278972073), exactly as in your code signed certificate. Several names can be provided. Defaults to common name from your code signing certificate.

property rfc3161TimeStampServer

readonly rfc3161TimeStampServer?: string | null;

The URL of the RFC 3161 time stamp server. http://timestamp.digicert.com

property sign

readonly sign?: CustomWindowsSign | string | null;

The custom function (or path to file or module id) to sign Windows executables

property signingHashAlgorithms

readonly signingHashAlgorithms?: Array<'sha1' | 'sha256'> | null;

Array of signing algorithms used. For AppX sha256 is always used. ['sha1', 'sha256']

property timeStampServer

readonly timeStampServer?: string | null;

The URL of the time stamp server. http://timestamp.digicert.com

Type Aliases

type AfterExtractContext

type AfterExtractContext = PackContext;

type AfterPackContext

type AfterPackContext = PackContext;

type BackgroundAlignment

type BackgroundAlignment =
    | 'center'
    | 'left'
    | 'right'
    | 'top'
    | 'bottom'
    | 'topleft'
    | 'topright'
    | 'bottomleft'
    | 'bottomright';

type BackgroundScaling

type BackgroundScaling = 'tofit' | 'none' | 'proportional';

type BeforePackContext

type BeforePackContext = PackContext;

type CompressionLevel

type CompressionLevel = 'store' | 'normal' | 'maximum';

type CustomMacSign

type CustomMacSign = (
    configuration: CustomMacSignOptions,
    packager: MacPackager
) => Promise<void>;

type CustomMacSignOptions

type CustomMacSignOptions = SignOptions;

type CustomWindowsSign

type CustomWindowsSign = (
    configuration: CustomWindowsSignTaskConfiguration,
    packager?: WinPackager
) => Promise<any>;

type ElectronPlatformName

type ElectronPlatformName = 'darwin' | 'linux' | 'win32' | 'mas';

type Hook

type Hook<T, V> = (contextOrPath: T) => Promise<V> | V;

type MacOsTargetName

type MacOsTargetName =
    | 'default'
    | 'dmg'
    | 'mas'
    | 'mas-dev'
    | 'pkg'
    | '7z'
    | 'zip'
    | 'tar.xz'
    | 'tar.lz'
    | 'tar.gz'
    | 'tar.bz2'
    | 'dir';

type TargetConfigType

type TargetConfigType =
    | Array<string | TargetConfiguration>
    | string
    | TargetConfiguration
    | null;

Package Files (32)

Dev Dependencies (32)

Peer Dependencies (2)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/app-builder-lib.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/app-builder-lib)

HTML

<a href="https://www.jsdocs.io/package/app-builder-lib"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 second ago.
Package analyzed in 10586 ms.
Missing or incorrect documentation? Open an issue for this package.