app-builder-lib

  • Version 26.0.12
  • Published
  • 3.26 MB
  • 33 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

Functions

Classes

Interfaces

Type Aliases

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> {}

                                                                      constructor

                                                                      constructor(info: Packager);

                                                                        property codeSigningInfo

                                                                        readonly codeSigningInfo: MemoLazy<CreateKeychainOptions, CodeSigningInfo>;

                                                                          property defaultTarget

                                                                          readonly defaultTarget: string[];

                                                                            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

                                                                                protected 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,
                                                                                    identity: Identity | null
                                                                                    ) => Promise<void>;

                                                                                      method getElectronDestinationDir

                                                                                      getElectronDestinationDir: (appOutDir: string) => string;

                                                                                        method getElectronSrcDir

                                                                                        getElectronSrcDir: (dist: string) => string;

                                                                                          method getIconPath

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

                                                                                            method notarizeIfProvided

                                                                                            notarizeIfProvided: (appPath: string) => Promise<void>;

                                                                                              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 options

                                                                                                                                readonly options: PackagerOptions;

                                                                                                                                  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 addPackagerEventHandlers

                                                                                                                                            addPackagerEventHandlers: () => Promise<void>;

                                                                                                                                              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 getNodeDependencyInfo

                                                                                                                                                                      getNodeDependencyInfo: (
                                                                                                                                                                      platform: Platform | null,
                                                                                                                                                                      flatten?: boolean
                                                                                                                                                                      ) => Lazy<(NodeModuleInfo | NodeModuleDirInfo)[]>;

                                                                                                                                                                        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 dispatchArtifactCreated

                                                                                                                                                                                                                                                    dispatchArtifactCreated: (
                                                                                                                                                                                                                                                    file: string,
                                                                                                                                                                                                                                                    target: Target | null,
                                                                                                                                                                                                                                                    arch: Arch | null,
                                                                                                                                                                                                                                                    safeArtifactName?: string | null
                                                                                                                                                                                                                                                    ) => Promise<void>;

                                                                                                                                                                                                                                                      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 generateName2

                                                                                                                                                                                                                                                                    generateName2: (
                                                                                                                                                                                                                                                                    ext: string | null,
                                                                                                                                                                                                                                                                    classifier: string | Nullish,
                                                                                                                                                                                                                                                                    deployment: boolean
                                                                                                                                                                                                                                                                    ) => string;
                                                                                                                                                                                                                                                                      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 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

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

                                                                                                                                                                                                                                                                                                                            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 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 sign

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

                                                                                                                                                                                                                                                                                                                                                                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>;

                                                                                                                                                                                                                                                                                                                                                                    Interfaces

                                                                                                                                                                                                                                                                                                                                                                    interface AppImageOptions

                                                                                                                                                                                                                                                                                                                                                                    interface AppImageOptions extends CommonLinuxOptions, TargetSpecificOptions {}

                                                                                                                                                                                                                                                                                                                                                                      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 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} - ${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](./configuration.md#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;

                                                                                                                                                                                                                                                                                                                                                                                                  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;

                                                                                                                                                                                                                                                                                                                                                                                                                                        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.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property appx

                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly appx?: AppXOptions | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                          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 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                          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.

                                                                                                                                                                                                                                                                                                                                                                                                                                          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;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property includePdb

                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly includePdb?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Whether to include PDB files. false

                                                                                                                                                                                                                                                                                                                                                                                                                                            property linux

                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly linux?: LinuxConfiguration | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Options related to how build Linux targets.

                                                                                                                                                                                                                                                                                                                                                                                                                                            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;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property msiWrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly msiWrapped?: MsiWrappedOptions | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                            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;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property nsisWeb

                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly nsisWeb?: NsisWebOptions | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property p5p

                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly p5p?: LinuxTargetSpecificOptions | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property pacman

                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly pacman?: LinuxTargetSpecificOptions | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property pkg

                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly pkg?: PkgOptions | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • macOS PKG options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property portable

                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly portable?: PortableOptions | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      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?: LinuxTargetSpecificOptions | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property snap

                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly snap?: SnapOptions | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Snap options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property squirrelWindows

                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly squirrelWindows?: SquirrelWindowsOptions | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property win

                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly win?: WindowsConfiguration | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Options related to how build Windows targets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CommonLinuxOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CommonLinuxOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            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](./configuration.md#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 guid

                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly guid?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • See [GUID vs Application Name](./nsis.md#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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property electronDownload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly electronDownload?: ElectronDownloadOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The [electron-download](https://github.com/electron-userland/electron-download#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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 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). Defaults to #ffffff (white) if no background image.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 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](./contents.md#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 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 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](./file-patterns.md) 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](./file-patterns.md) relative to the [app directory](configuration.md#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](mac.md)).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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](./file-patterns.md#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](./file-patterns.md). Defaults to "**/*"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              from?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The source path relative to and defaults to:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - the [app directory](configuration.md#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).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ```typescript (buildResult: BuildResult): Promise<Array> | Array ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Configuration in the same way as afterPack (see above).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !!! example "myAfterAllArtifactBuild.js" ```js exports.default = function () { // you can 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](#afterextract) Same setup as beforePack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property afterPack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly afterPack?: Hook<AfterPackContext, void> | string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The function (or path to file or module id) to be [run after pack](#afterpack) (but before pack into distributable format and sign). Same setup as 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](#aftersign) (but before pack into distributable format). Same setup as 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 on artifact build completed. Same setup as beforePack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property artifactBuildStarted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly artifactBuildStarted?: Hook<ArtifactBuildStarted, void> | string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The function (or path to file or module id) to be run on artifact build start. Same setup as 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ```typescript (context: BeforePackContext): Promise | any ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !!! example "As function"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ```js beforePack: async (context) => { // your code } ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Because in a configuration file you cannot use JavaScript, can be specified as a path to file or module id. Function must be exported as default export.

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      File myBeforePackHook.js in the project root directory:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !!! example "myBeforePackHook.js" ```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](./contents.md#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](./configuration.md#author).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property packageCategory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly packageCategory?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • backward compatibility + to allow specify fpm-only category for all possible fpm targets in one place

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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](./multi-platform-build.md#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](./configuration.md#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' | 'lzo' | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The compression type. 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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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](./mas.md). 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. 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. build/icon.icns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property identity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly identity?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The name of certificate to use when signing. Consider using environment variables [CSC_LINK or CSC_NAME](./code-signing.md) instead of specifying this option. MAS installer identity is specified in the [mas](./mas.md).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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. Defaults to default (dmg and zip for Squirrel.Mac). 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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](./file-patterns.md#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](./configuration.md#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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              differentialPackage?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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](./contents.md#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](./contents.md#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](./contents.md#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](./contents.md#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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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](./contents.md#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](./contents.md#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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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](./configuration.md#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 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](./code-signing.md) 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](./configuration.md#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](./file-patterns.md) 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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cscLink?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultArch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly defaultArch?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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](./auto-update.md#compatibility) semver range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property executableName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly executableName?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The executable name. Defaults to productName.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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](./publish.md) 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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PlugDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PlugDescriptor {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PortableOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PortableOptions extends TargetSpecificOptions, CommonNsisOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Portable options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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](./contents.md#extraresources).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property vendor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            vendor?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Vendor specific information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RepositoryInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RepositoryInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SlotDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SlotDescriptor {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SnapOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SnapOptions extends CommonLinuxOptions, TargetSpecificOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property after

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly after?: Array<string> | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies any [parts](https://snapcraft.io/docs/reference/parts) that should be built before this part. Defaults to ["desktop-gtk2""].

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If list contains default, it will be replaced to default list, so, ["default", "foo"] can be used to add custom parts foo in addition to defaults.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property allowNativeWayland

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly allowNativeWayland?: boolean | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Allow running the program with native wayland support with --ozone-platform=wayland. Disabled by default because of this issue in older Electron/Snap versions: https://github.com/electron-userland/electron-builder/issues/4007

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property appPartStage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly appPartStage?: Array<string> | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies which files from the app part to stage and which to exclude. Individual files, directories, wildcards, globstars, and exclusions are accepted. See [Snapcraft filesets](https://snapcraft.io/docs/snapcraft-filesets) to learn more about the format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The defaults can be found in [snap.ts](https://github.com/electron-userland/electron-builder/blob/master/packages/app-builder-lib/templates/snap/snapcraft.yaml#L29).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property assumes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly assumes?: Array<string> | string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The list of features that must be supported by the core in order for this snap to install.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property autoStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly autoStart?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the snap should automatically start on login. false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property base

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly base?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • A snap of type base to be used as the execution environment for this snap. Examples: core, core18, core20, core22. Defaults to core20

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property buildPackages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly buildPackages?: Array<string> | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The list of debian packages needs to be installed for building this snap.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property compression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly compression?: 'xz' | 'lzo' | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Sets the compression type for the snap. Can be xz, lzo, or null.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property confinement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly confinement?: 'devmode' | 'strict' | 'classic' | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The type of [confinement](https://snapcraft.io/docs/reference/confinement) supported by the snap. strict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property environment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly environment?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The custom environment. Defaults to {"TMPDIR: "$XDG_RUNTIME_DIR"}. If you set custom, it will be merged with default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property grade

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly grade?: 'devel' | 'stable' | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The quality grade of the snap. It can be either devel (i.e. a development version of the snap, so not to be published to the “stable” or “candidate” channels) or “stable” (i.e. a stable release or release candidate, which can be released to all channels). stable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property hooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly hooks?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The [hooks](https://docs.snapcraft.io/build-snaps/hooks) directory, relative to build (build resources directory). build/snap-hooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly layout?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies any files to make accessible from locations such as /usr, /var, and /etc. See [snap layouts](https://snapcraft.io/docs/snap-layouts) to learn more.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property plugs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly plugs?: Array<string | PlugDescriptor> | PlugDescriptor | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The list of [plugs](https://snapcraft.io/docs/reference/interfaces). Defaults to ["desktop", "desktop-legacy", "home", "x11", "wayland", "unity7", "browser-support", "network", "gsettings", "audio-playback", "pulseaudio", "opengl"].

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If list contains default, it will be replaced to default list, so, ["default", "foo"] can be used to add custom plug foo in addition to defaults.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Additional attributes can be specified using object instead of just name of plug:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "browser-sandbox": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "interface": "browser-support",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "allow-sandbox": true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "another-simple-plug-name"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property slots

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly slots?: Array<string | SlotDescriptor> | PlugDescriptor | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The list of [slots](https://snapcraft.io/docs/reference/interfaces).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Additional attributes can be specified using object instead of just name of slot: ``` [ { "mpris": { "name": "chromium" }, } ]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        In case you want your application to be a compliant MPris player, you will need to definie The mpris slot with "chromium" name. This electron has it [hardcoded](https://source.chromium.org/chromium/chromium/src/+/master:components/system_media_controls/linux/system_media_controls_linux.cc;l=51;bpv=0;bpt=1), and we need to pass this name so snap [will allow it](https://forum.snapcraft.io/t/unable-to-use-mpris-interface/15360/7) in strict confinement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property stagePackages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly stagePackages?: Array<string> | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The list of Ubuntu packages to use that are needed to support the app part creation. Like depends for deb. Defaults to ["libnspr4", "libnss3", "libxss1", "libappindicator3-1", "libsecret-1-0"].

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If list contains default, it will be replaced to default list, so, ["default", "foo"] can be used to add custom package foo in addition to defaults.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property summary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly summary?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The 78 character long summary. Defaults to [productName](./configuration.md#productName).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly title?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • An optional title for the snap, may contain uppercase letters and spaces. Defaults to productName. See [snap format documentation](https://snapcraft.io/docs/snap-format).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property useTemplateApp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly useTemplateApp?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether to use template snap. Defaults to true if stagePackages not specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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](./configuration.md#artifact-file-name-template).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property publish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      publish?: Publish;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 (beta) 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. Advanced option. true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property signExts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly signExts?: string[] | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Explicit file extensions to also sign. Advanced option.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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]./nsis.md#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](./code-signing.md).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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](./code-signing.md).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 (30)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (33)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (31)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto 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>