Variable default

Type Declaration

• authenticate: (password: string) => Promise<unknown>

• authenticateUser: (username: string, password: string) => Promise<unknown>

• bulkConnect: (
      service: Object,
      list: [event: string, callback: (...args: any[]) => void][],
  ) => number[]

• bulkDisconnect: (service: Object, ids: number[]) => void

• CACHE_DIR: string

  The AGS cache directory path (e.g., ~/.cache/ags).

• cpuUsage: () => number

• derive: <
      V,
      const Deps extends Variable<any>[],
      Args extends
          {
              [K in string | number | symbol]: Deps[K] extends Variable<T>
                  ? T
                  : never
          },
  >(
      deps: Deps,
      fn: (...args: Args) => V,
  ) => Variable<V>

• diskUsage: (mount?: string) => number

• ensureDirectory: (path: string) => void

• exec: {
      <Out = string, Err = string>(args: Args<Out, Err>): Out | Err;
      <Out = string, Err = string>(
          cmd: string | string[],
          out?: (stdout: string) => Out,
          err?: (stderr: string) => Err,
      ): Out | Err;
  }

• execAsync: (cmd: string | string[]) => Promise<string>

• fetch: (url: string, options?: FetchOptions) => Promise<Response>

• HOME: string

  The current user's home directory path.

• idle: (callback: () => void, prio?: number) => number

• interval: (interval: number, callback: () => void, bind?: Widget) => number

• kebabify: (str: string) => string

• loadInterfaceXML: (iface: string) => string | null

• lookUpIcon: (name?: string, size?: number) => IconInfo | null

• memUsage: () => number

• merge: <
      V,
      const Deps extends Dep<unknown>[],
      Args extends
          { [K in string | number | symbol]: Deps[K] extends Dep<T> ? T : never },
  >(
      deps: Deps,
      fn: (...args: Args) => V,
  ) => Binding<
      Variable<V>,
  
          | "$signals"
          | "is_listening"
          | "is_polling"
          | "is_disposed"
          | Exclude<
              V extends (...args: any[]) => any ? never : "value",
              "g_type_instance",
          >,
      V,
  >

• monitorFile: (
      path: string,
      callback?: (file: File, event: FileMonitorEvent) => void,
      options?: { flags: FileMonitorFlags; recursive: boolean },
  ) => FileMonitor | null

• networkRates: () => { down: number; up: number }

• notify: {
      (args: NotificationArgs): Promise<number>;
      (summary: string, body?: string, iconName?: string): Promise<number>;
  }

• onFrame: (widget: Widget, callback: () => boolean) => CancelHandle

• pspec: (name: string, type?: PspecType, handle?: PspecFlag) => ParamSpec<unknown>

• readFile: (file: string | File) => string

• readFileAsync: (file: string | File) => Promise<string>

• registerGObject: <
      Obj extends new (...args: any[]) => Object,
      Config extends
          {
              cssName?: string;
              properties?: { [prop: string]: [type?: PspecType, handle?: PspecFlag] };
              signals?: { [signal: string]: PspecType[] };
              typename?: string;
          },
  >(
      object: Obj,
      config?: Config,
  ) => Obj

• subprocess: {
      (args: Args<void, void> & { bind?: Widget }): Subprocess;
      (
          cmd: string | string[],
          out?: (stdout: string) => void,
          err?: (stderr: string) => void,
          bind?: Widget,
      ): Subprocess;
  }

• temperature: (sensor?: string) => number

• timeout: (ms: number, callback: () => void) => number

• uptime: () => number

• USER: string

  The current system user's login name.

• watch: {
      <T>(
          init: T,
          objs: (Connectable | [obj: Connectable, signal?: string])[],
          callback: () => T,
      ): B<T>;
      <T>(init: T, obj: Connectable, signal: string, callback: () => T): B<T>;
      <T>(init: T, obj: Connectable, callback: () => T): B<T>;
  }

• writeFile: (string: string, path: string) => Promise<File>

• writeFileSync: (string: string, path: string) => File