* Copyright (C) 2024 Red Hat, Inc.
* SPDX-License-Identifier: GPL-3.0-or-later
*/
import '_internal/common';
import type { Info } from './cockpit/_internal/info';
declare module 'cockpit' {
export type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
export type JsonObject = Record<string, JsonValue>;
export class BasicError {
problem: string;
message: string;
toString(): string;
}
export type SuperuserMode = "require" | "try" | null | undefined;
export function init(): Promise<void>;
export function assert(predicate: unknown, message?: string): asserts predicate;
export const manifests: { [package in string]?: JsonObject };
export const info: Info;
export let language: string;
export let language_direction: string;
export interface Transport {
csrf_token: string;
origin: string;
host: string;
options: JsonObject;
uri(suffix?: string): string;
wait(callback: (transport: Transport) => void): void;
close(problem?: string): void;
application(): string;
control(command: string, options: JsonObject): void;
}
export const transport: Transport;
export const hint: (name: string, options?: JsonObject | string) => void;
export interface DeferredPromise<T> extends Promise<T> {
done(callback: (data: T) => void): DeferredPromise<T>
fail(callback: (exc: Error) => void): DeferredPromise<T>
always(callback: () => void): DeferredPromise<T>
progress(callback: (message: T, cancel: () => void) => void): DeferredPromise<T>
}
export interface Deferred<T> {
resolve(): Deferred<T>;
reject(): Deferred<T>;
notify(): Deferred<T>;
promise: DeferredPromise<T>
}
export function defer<T>(): Deferred<T>;
export interface EventMap {
[_: string]: (...args: any[]) => void;
}
export type EventListener<E extends (...args: unknown[]) => void> =
(event: CustomEvent<Parameters<E>>, ...args: Parameters<E>) => void;
export interface EventSource<EM extends EventMap> {
addEventListener<E extends keyof EM>(event: E, listener: EventListener<EM[E]>): void;
removeEventListener<E extends keyof EM>(event: E, listener: EventListener<EM[E]>): void;
dispatchEvent<E extends keyof EM>(event: E, ...args: Parameters<EM[E]>): void;
}
export interface CockpitEvents extends EventMap {
locationchanged(): void;
visibilitychange(): void;
}
export function addEventListener<E extends keyof CockpitEvents>(
event: E, listener: EventListener<CockpitEvents[E]>
): void;
export function removeEventListener<E extends keyof CockpitEvents>(
event: E, listener: EventListener<CockpitEvents[E]>
): void;
export interface ChangedEvents {
changed(): void;
}
export function event_target<T, EM extends EventMap>(obj: T): T & EventSource<EM>;
export interface ControlMessage extends JsonObject {
command: string;
}
export interface ChannelEvents<T> extends EventMap {
control(options: JsonObject): void;
ready(options: JsonObject): void;
close(options: JsonObject): void;
message(data: T): void;
}
export interface Channel<T> extends EventSource<ChannelEvents<T>> {
id: string | null;
binary: boolean;
options: JsonObject;
ready: boolean;
valid: boolean;
send(data: T): void;
control(options: ControlMessage): void;
wait(callback?: (data: T) => void): Promise<T>;
close(options?: string | JsonObject): void;
}
export interface ChannelOptions {
superuser?: SuperuserMode;
[_: string]: JsonValue | undefined;
binary?: boolean,
host?: string;
user?: string;
password?: string;
session?: "shared" | "private";
}
export interface ChannelOpenOptions extends ChannelOptions {
payload: string;
}
export function channel(options: ChannelOpenOptions & { binary?: false; }): Channel<string>;
export function channel(options: ChannelOpenOptions & { binary: true; }): Channel<Uint8Array>;
export class ProcessError {
problem: string | null;
exit_status: number | null;
exit_signal: number | null;
message: string;
}
export interface Spawn<T> extends DeferredPromise<T> {
input(message?: T | null, stream?: boolean): Spawn<T>;
stream(callback: (data: T) => number | null | void): Spawn<T>;
done(callback: (data: T, message?: string) => void): Spawn<T>;
fail(callback: (exc: Error, data?: string) => void): Spawn<T>;
state(): "pending" | "resolved" | "rejected";
close(options?: string | JsonObject): void;
}
export interface SpawnOptions extends ChannelOptions {
directory?: string;
err?: "out" | "ignore" | "message";
environ?: string[];
pty?: boolean;
window?: { rows: number; cols: number };
}
export function spawn(
args: string[],
options?: SpawnOptions & { binary?: false }
): Spawn<string>;
export function spawn(
args: string[],
options: SpawnOptions & { binary: true }
): Spawn<Uint8Array>;
export function script(
script: string,
options?: SpawnOptions & { binary?: false }
): Spawn<string>;
export function script(
script: string,
options: SpawnOptions & { binary: true }
): Spawn<Uint8Array>;
export function script(
script: string,
args: string[],
options?: SpawnOptions & { binary?: false }
): Spawn<string>;
export function script(
script: string,
args: string[],
options: SpawnOptions & { binary: true }
): Spawn<Uint8Array>;
export interface Location {
url_root: string;
options: { [name: string]: string | Array<string> };
path: Array<string>;
href: string;
go(path: Location | string[] | string, options?: { [key: string]: string }): void;
replace(path: Location | string[] | string, options?: { [key: string]: string }): void;
encode(path: string[], options?: { [key: string]: string }, with_root?: boolean): string;
decode(string: string, options?: { [key: string]: string }): string[];
}
export let location: Location;
export function jump(path: string | string[], host?: string): void;
export let hidden: boolean;
export interface DBusProxyEvents extends EventMap {
changed(changes: { [property: string]: unknown }): void;
}
export interface DBusProxiesEvents extends EventMap {
added(proxy: DBusProxy): void;
changed(proxy: DBusProxy): void;
removed(proxy: DBusProxy): void;
}
export interface DBusProxy extends EventSource<DBusProxyEvents> {
valid: boolean;
[property: string]: unknown;
}
export interface DBusClientEvents extends EventMap {
notify(data: unknown): void;
meta(data: unknown): void;
owner(owner: string): void;
}
export interface DBusOptions {
bus?: string;
address?: string;
host?: string;
superuser?: SuperuserMode;
track?: boolean;
}
export type DBusCallOptions = {
flags?: "" | "i",
type?: string,
timeout?: number,
};
export interface DBusProxies extends EventSource<DBusProxiesEvents> {
client: DBusClient;
iface: string;
path_namespace: string;
wait(callback?: () => void): Promise<void>;
}
export interface DBusClient extends EventSource<DBusClientEvents> {
readonly unique_name: string;
readonly options: DBusOptions;
proxy(interface?: string, path?: string, options?: { watch?: boolean }): DBusProxy;
proxies(interface?: string, path_namespace?: string, options?: { watch?: boolean }): DBusProxies;
call(path: string, iface: string, method: string, args?: unknown[] | null, options?: DBusCallOptions): Promise<unknown[]>;
watch(path: string): DeferredPromise<void>,
subscribe: (
match: {
path?: string,
path_namespace?: string,
interface?: string,
member?: string,
arg0?: string
},
callback: (path: string, iface: string, signal: string, args: unknown[]) => void,
rule?: boolean,
) => {
remove: () => void;
},
close(): void;
}
export type VariantType = string | Uint8Array | number | boolean | VariantType[];
export interface Variant {
t: string;
v: VariantType;
}
export function dbus(name: string | null, options?: DBusOptions): DBusClient;
export function variant(type: string, value: VariantType): Variant;
export function byte_array(string: string): string;
export interface FileSyntaxObject<T, B> {
parse(content: B): T;
stringify?(content: T): B;
}
export type FileTag = string;
export type FileWatchCallback<T> = (data: T | null, tag: FileTag | null, error: BasicError | null) => void;
export interface FileWatchHandle {
remove(): void;
}
export interface FileHandle<T> {
read(): Promise<T>;
replace(new_content: T | null, expected_tag?: FileTag): Promise<FileTag>;
watch(callback: FileWatchCallback<T>, options?: { read?: boolean }): FileWatchHandle;
modify(callback: (data: T | null) => T | null, initial_content?: string, initial_tag?: FileTag): Promise<T>;
close(): void;
path: string;
}
export type FileOpenOptions = {
max_read_size?: number;
superuser?: SuperuserMode;
};
export function file(
path: string,
options?: FileOpenOptions & { binary?: false; syntax?: never; }
): FileHandle<string>;
export function file(
path: string,
options: FileOpenOptions & { binary: true; syntax?: never; }
): FileHandle<Uint8Array>;
export function file<T>(
path: string,
options: FileOpenOptions & { binary?: false; syntax: FileSyntaxObject<T, string>; }
): FileHandle<T>;
export function file<T>(
path: string,
options: FileOpenOptions & { binary: true; syntax: FileSyntaxObject<T, Uint8Array>; }
): FileHandle<T>;
export type UserInfo = {
id: number;
gid: number;
name: string;
full_name: string;
groups: Array<string>;
home: string;
shell: string;
};
export function user(): Promise<Readonly<UserInfo>>;
export interface TlsCert {
file?: string;
data?: string;
}
export interface HttpOptions {
address?: string;
port?: number;
tls?: {
authority?: TlsCert;
certificate?: TlsCert;
key?: TlsCert;
validate?: boolean;
};
superuser?: SuperuserMode;
binary?: boolean;
headers?: HttpHeaders;
params?: { [key: string]: string | number };
}
export type HttpHeaders = { [key: string]: string };
export interface HttpRequestOptions {
path?: string;
method?: string;
headers?: HttpHeaders;
params?: { [key: string]: string | number };
body?: string | Uint8Array | null;
}
export interface HttpInstance<TResponse = string> {
request(options: HttpRequestOptions): Promise<TResponse>;
get(path: string, options?: Omit<HttpRequestOptions, "method" | "path" | "body">): Promise<TResponse>;
post(path: string,
body?: string | Uint8Array | JsonObject | null,
options?: Omit<HttpRequestOptions, "method" | "path" | "body">
): Promise<TResponse>;
close(): void;
}
export function http(endpoint: string): HttpInstance<string>;
export function http(endpoint: string, options: HttpOptions & { binary?: false | undefined }): HttpInstance<string>;
export function http(endpoint: string, options: HttpOptions & { binary: true }): HttpInstance<Uint8Array>;
export function message(problem: string | JsonObject): string;
export function format(format_string: string, ...args: unknown[]): string;
export function gettext(message: string): string;
export function gettext(context: string, message?: string): string;
export function ngettext(message1: string, messageN: string, n: number): string;
export function ngettext(context: string, message1: string, messageN: string, n: number): string;
export function translate(): void;
export type FormatOptions = {
precision?: number;
base2?: boolean;
};
export type MaybeNumber = number | null | undefined;
export function format_number(n: MaybeNumber, precision?: number): string
export function format_bytes(n: MaybeNumber, options?: FormatOptions): string;
export function format_bytes_per_sec(n: MaybeNumber, options?: FormatOptions): string;
export function format_bits_per_sec(n: MaybeNumber, options?: FormatOptions & { base2?: false }): string;
export function format_bytes(n: MaybeNumber, factor: unknown, options?: object | boolean): string | string[];
export function format_bytes_per_sec(n: MaybeNumber, factor: unknown, options?: object | boolean): string | string[];
export function format_bits_per_sec(n: MaybeNumber, factor: unknown, options?: object | boolean): string | string[];
export function logout(reload: boolean, reason?: string): void;
export let localStorage: Storage;
export let sessionStorage: Storage;
export function base64_encode(data: string | Array<number> | Uint8Array | ArrayBuffer): string;
export function base64_decode(str: string, constructor: StringConstructor): string;
export function base64_decode(str: string, constructor?: ArrayConstructor): Array<number>;
export function base64_decode(str: string, constructor?: Uint8ArrayConstructor): Uint8Array;
}
