1648 lines
58 KiB
TypeScript
1648 lines
58 KiB
TypeScript
/// <reference path="./gio-2.0.d.ts" />
|
|
/// <reference path="./gobject-2.0.d.ts" />
|
|
/// <reference path="./glib-2.0.d.ts" />
|
|
/// <reference path="./gmodule-2.0.d.ts" />
|
|
|
|
/**
|
|
* Type Definitions for Gjs (https://gjs.guide/)
|
|
*
|
|
* These type definitions are automatically generated, do not edit them by hand.
|
|
* If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
|
|
*
|
|
* The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
|
|
*/
|
|
|
|
declare module 'gi://AstalWp?version=0.1' {
|
|
// Module dependencies
|
|
import type Gio from 'gi://Gio?version=2.0';
|
|
import type GObject from 'gi://GObject?version=2.0';
|
|
import type GLib from 'gi://GLib?version=2.0';
|
|
import type GModule from 'gi://GModule?version=2.0';
|
|
|
|
export namespace AstalWp {
|
|
/**
|
|
* AstalWp-0.1
|
|
*/
|
|
|
|
export namespace Available {
|
|
export const $gtype: GObject.GType<Available>;
|
|
}
|
|
|
|
enum Available {
|
|
UNKNOWN,
|
|
NO,
|
|
YES,
|
|
}
|
|
|
|
export namespace DeviceType {
|
|
export const $gtype: GObject.GType<DeviceType>;
|
|
}
|
|
|
|
enum DeviceType {
|
|
UNKNOWN,
|
|
AUDIO_DEVICE,
|
|
VIDEO_DEVICE,
|
|
}
|
|
|
|
export namespace Direction {
|
|
export const $gtype: GObject.GType<Direction>;
|
|
}
|
|
|
|
enum Direction {
|
|
INPUT,
|
|
OUTPUT,
|
|
}
|
|
|
|
export namespace MediaCategory {
|
|
export const $gtype: GObject.GType<MediaCategory>;
|
|
}
|
|
|
|
enum MediaCategory {
|
|
UNKNOWN,
|
|
PLAYBACK,
|
|
CAPTURE,
|
|
DUPLEX,
|
|
MONITOR,
|
|
MANAGER,
|
|
}
|
|
|
|
export namespace MediaClass {
|
|
export const $gtype: GObject.GType<MediaClass>;
|
|
}
|
|
|
|
enum MediaClass {
|
|
UNKNOWN,
|
|
AUDIO_SOURCE,
|
|
AUDIO_SINK,
|
|
STREAM_INPUT_AUDIO,
|
|
STREAM_OUTPUT_AUDIO,
|
|
VIDEO_SOURCE,
|
|
VIDEO_SINK,
|
|
STREAM_INPUT_VIDEO,
|
|
STREAM_OUTPUT_VIDEO,
|
|
}
|
|
|
|
export namespace MediaRole {
|
|
export const $gtype: GObject.GType<MediaRole>;
|
|
}
|
|
|
|
enum MediaRole {
|
|
UNKNOWN,
|
|
MOVIE,
|
|
MUSIC,
|
|
CAMERA,
|
|
SCREEN,
|
|
COMMUNICATION,
|
|
GAME,
|
|
NOTIFICATION,
|
|
DSP,
|
|
PRODUCTION,
|
|
ACCESSIBILITY,
|
|
TEST,
|
|
}
|
|
|
|
export namespace NodeState {
|
|
export const $gtype: GObject.GType<NodeState>;
|
|
}
|
|
|
|
enum NodeState {
|
|
ERROR,
|
|
CREATING,
|
|
SUSPENDED,
|
|
IDLE,
|
|
RUNNING,
|
|
}
|
|
|
|
export namespace Scale {
|
|
export const $gtype: GObject.GType<Scale>;
|
|
}
|
|
|
|
enum Scale {
|
|
LINEAR,
|
|
CUBIC,
|
|
}
|
|
const MAJOR_VERSION: number;
|
|
const MICRO_VERSION: number;
|
|
const MINOR_VERSION: number;
|
|
const VERSION: string;
|
|
function device_type_from_string(string: string): DeviceType;
|
|
function device_type_to_string(device_type: DeviceType | null): string;
|
|
/**
|
|
* gets the default wireplumber object.
|
|
* @returns gets the default wireplumber object.
|
|
*/
|
|
function get_default(): Wp | null;
|
|
function media_category_from_string(string: string): MediaCategory;
|
|
function media_category_to_string(category: MediaCategory | null): string;
|
|
function media_class_from_string(string: string): MediaClass;
|
|
function media_class_to_string(media_class: MediaClass | null): string;
|
|
function media_role_from_string(string: string): MediaRole;
|
|
function media_role_to_string(role: MediaRole | null): string;
|
|
namespace Audio {
|
|
// Signal signatures
|
|
interface SignalSignatures extends GObject.Object.SignalSignatures {
|
|
'device-added': (arg0: Device) => void;
|
|
'device-removed': (arg0: Device) => void;
|
|
'microphone-added': (arg0: Endpoint) => void;
|
|
'microphone-removed': (arg0: Endpoint) => void;
|
|
'recorder-added': (arg0: Stream) => void;
|
|
'recorder-removed': (arg0: Stream) => void;
|
|
'speaker-added': (arg0: Endpoint) => void;
|
|
'speaker-removed': (arg0: Endpoint) => void;
|
|
'stream-added': (arg0: Stream) => void;
|
|
'stream-removed': (arg0: Stream) => void;
|
|
'notify::default-microphone': (pspec: GObject.ParamSpec) => void;
|
|
'notify::default-speaker': (pspec: GObject.ParamSpec) => void;
|
|
'notify::devices': (pspec: GObject.ParamSpec) => void;
|
|
'notify::microphones': (pspec: GObject.ParamSpec) => void;
|
|
'notify::recorders': (pspec: GObject.ParamSpec) => void;
|
|
'notify::speakers': (pspec: GObject.ParamSpec) => void;
|
|
'notify::streams': (pspec: GObject.ParamSpec) => void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
default_microphone: Endpoint;
|
|
defaultMicrophone: Endpoint;
|
|
default_speaker: Endpoint;
|
|
defaultSpeaker: Endpoint;
|
|
devices: Device[];
|
|
microphones: Endpoint[];
|
|
recorders: Stream[];
|
|
speakers: Endpoint[];
|
|
streams: Stream[];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* is instanciated by [class`AstalWp`.Wp]. An instance of class can only be received there.
|
|
*
|
|
* This is a convinience class and acts as a filter for [class`AstalWp`.Wp] to filter for audio
|
|
* endpoints and devices.
|
|
*/
|
|
class Audio extends GObject.Object {
|
|
static $gtype: GObject.GType<Audio>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The AstalWndpoint object representing the default speaker
|
|
*/
|
|
get default_microphone(): Endpoint;
|
|
/**
|
|
* The AstalWndpoint object representing the default speaker
|
|
*/
|
|
get defaultMicrophone(): Endpoint;
|
|
/**
|
|
* The AstalWndpoint object representing the default speaker
|
|
*/
|
|
get default_speaker(): Endpoint;
|
|
/**
|
|
* The AstalWndpoint object representing the default speaker
|
|
*/
|
|
get defaultSpeaker(): Endpoint;
|
|
/**
|
|
* A list of AstalWpEndpoint objects
|
|
*/
|
|
get devices(): Device[];
|
|
/**
|
|
* A list of AstalWpEndpoint objects
|
|
*/
|
|
get microphones(): Endpoint[];
|
|
/**
|
|
* A list of AstalWpStream objects
|
|
*/
|
|
get recorders(): Stream[];
|
|
/**
|
|
* A list of AstalWpEndpoint objects
|
|
*/
|
|
get speakers(): Endpoint[];
|
|
/**
|
|
* A list of AstalWpStream objects
|
|
*/
|
|
get streams(): Stream[];
|
|
|
|
/**
|
|
* Compile-time signal type information.
|
|
*
|
|
* This instance property is generated only for TypeScript type checking.
|
|
* It is not defined at runtime and should not be accessed in JS code.
|
|
* @internal
|
|
*/
|
|
$signals: Audio.SignalSignatures;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Audio.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](wp: Wp): Audio;
|
|
|
|
// Signals
|
|
|
|
connect<K extends keyof Audio.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Audio.SignalSignatures[K]>,
|
|
): number;
|
|
connect(signal: string, callback: (...args: any[]) => any): number;
|
|
connect_after<K extends keyof Audio.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Audio.SignalSignatures[K]>,
|
|
): number;
|
|
connect_after(signal: string, callback: (...args: any[]) => any): number;
|
|
emit<K extends keyof Audio.SignalSignatures>(
|
|
signal: K,
|
|
...args: GObject.GjsParameters<Audio.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
|
|
): void;
|
|
emit(signal: string, ...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* gets the default microphone object
|
|
*/
|
|
get_default_microphone(): Endpoint | null;
|
|
/**
|
|
* gets the default speaker object
|
|
*/
|
|
get_default_speaker(): Endpoint | null;
|
|
/**
|
|
* gets the device with the given id
|
|
* @param id the id of the device
|
|
*/
|
|
get_device(id: number): Device | null;
|
|
/**
|
|
* a GList containing the devices
|
|
*/
|
|
get_devices(): Device[] | null;
|
|
/**
|
|
* gets the microphone with the given id
|
|
* @param id the id of the endpoint
|
|
*/
|
|
get_microphone(id: number): Endpoint | null;
|
|
/**
|
|
* a GList containing the microphones
|
|
*/
|
|
get_microphones(): Endpoint[] | null;
|
|
/**
|
|
* the node with the given id
|
|
* @param id the id of the endpoint
|
|
*/
|
|
get_node(id: number): Node | null;
|
|
/**
|
|
* gets the recorder with the given id
|
|
* @param id the id of the endpoint
|
|
*/
|
|
get_recorder(id: number): Stream | null;
|
|
/**
|
|
* a GList containing the recorders
|
|
*/
|
|
get_recorders(): Stream[] | null;
|
|
/**
|
|
* gets the speaker with the given id
|
|
* @param id the id of the endpoint
|
|
*/
|
|
get_speaker(id: number): Endpoint | null;
|
|
/**
|
|
* a GList containing the speakers
|
|
*/
|
|
get_speakers(): Endpoint[] | null;
|
|
/**
|
|
* gets the stream with the given id
|
|
* @param id the id of the endpoint
|
|
*/
|
|
get_stream(id: number): Stream | null;
|
|
/**
|
|
* a GList containing the streams
|
|
*/
|
|
get_streams(): Stream[] | null;
|
|
}
|
|
|
|
namespace Channel {
|
|
// Signal signatures
|
|
interface SignalSignatures extends GObject.Object.SignalSignatures {
|
|
'notify::name': (pspec: GObject.ParamSpec) => void;
|
|
'notify::volume': (pspec: GObject.ParamSpec) => void;
|
|
'notify::volume-icon': (pspec: GObject.ParamSpec) => void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
name: string;
|
|
volume: number;
|
|
volume_icon: string;
|
|
volumeIcon: string;
|
|
}
|
|
}
|
|
|
|
class Channel extends GObject.Object {
|
|
static $gtype: GObject.GType<Channel>;
|
|
|
|
// Properties
|
|
|
|
get name(): string;
|
|
get volume(): number;
|
|
set volume(val: number);
|
|
get volume_icon(): string;
|
|
get volumeIcon(): string;
|
|
|
|
/**
|
|
* Compile-time signal type information.
|
|
*
|
|
* This instance property is generated only for TypeScript type checking.
|
|
* It is not defined at runtime and should not be accessed in JS code.
|
|
* @internal
|
|
*/
|
|
$signals: Channel.SignalSignatures;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Channel.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Signals
|
|
|
|
connect<K extends keyof Channel.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Channel.SignalSignatures[K]>,
|
|
): number;
|
|
connect(signal: string, callback: (...args: any[]) => any): number;
|
|
connect_after<K extends keyof Channel.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Channel.SignalSignatures[K]>,
|
|
): number;
|
|
connect_after(signal: string, callback: (...args: any[]) => any): number;
|
|
emit<K extends keyof Channel.SignalSignatures>(
|
|
signal: K,
|
|
...args: GObject.GjsParameters<Channel.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
|
|
): void;
|
|
emit(signal: string, ...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* the name of the channel
|
|
*/
|
|
get_name(): string | null;
|
|
/**
|
|
* the volume of the channel
|
|
*/
|
|
get_volume(): number;
|
|
get_volume_icon(): string;
|
|
/**
|
|
* sets the volume for this channel. Note that if [property`AstalWp`.Node:lock-channels] is true for
|
|
* the node this channel is associated with, this method will set the volume for all channels.
|
|
* @param volume
|
|
*/
|
|
set_volume(volume: number): void;
|
|
}
|
|
|
|
namespace Device {
|
|
// Signal signatures
|
|
interface SignalSignatures extends GObject.Object.SignalSignatures {
|
|
'notify::active-profile-id': (pspec: GObject.ParamSpec) => void;
|
|
'notify::description': (pspec: GObject.ParamSpec) => void;
|
|
'notify::device-type': (pspec: GObject.ParamSpec) => void;
|
|
'notify::form-factor': (pspec: GObject.ParamSpec) => void;
|
|
'notify::icon': (pspec: GObject.ParamSpec) => void;
|
|
'notify::id': (pspec: GObject.ParamSpec) => void;
|
|
'notify::input-route-id': (pspec: GObject.ParamSpec) => void;
|
|
'notify::input-routes': (pspec: GObject.ParamSpec) => void;
|
|
'notify::output-route-id': (pspec: GObject.ParamSpec) => void;
|
|
'notify::output-routes': (pspec: GObject.ParamSpec) => void;
|
|
'notify::profiles': (pspec: GObject.ParamSpec) => void;
|
|
'notify::routes': (pspec: GObject.ParamSpec) => void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
active_profile_id: number;
|
|
activeProfileId: number;
|
|
description: string;
|
|
device_type: DeviceType;
|
|
deviceType: DeviceType;
|
|
form_factor: string;
|
|
formFactor: string;
|
|
icon: string;
|
|
id: number;
|
|
input_route_id: number;
|
|
inputRouteId: number;
|
|
input_routes: Route[];
|
|
inputRoutes: Route[];
|
|
output_route_id: number;
|
|
outputRouteId: number;
|
|
output_routes: Route[];
|
|
outputRoutes: Route[];
|
|
profiles: Profile[];
|
|
routes: Route[];
|
|
}
|
|
}
|
|
|
|
class Device extends GObject.Object {
|
|
static $gtype: GObject.GType<Device>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The id of the currently active profile.
|
|
*/
|
|
get active_profile_id(): number;
|
|
set active_profile_id(val: number);
|
|
/**
|
|
* The id of the currently active profile.
|
|
*/
|
|
get activeProfileId(): number;
|
|
set activeProfileId(val: number);
|
|
get description(): string;
|
|
/**
|
|
* The type of this device
|
|
*/
|
|
get device_type(): DeviceType;
|
|
/**
|
|
* The type of this device
|
|
*/
|
|
get deviceType(): DeviceType;
|
|
/**
|
|
* The from factor of this device.
|
|
*/
|
|
get form_factor(): string;
|
|
/**
|
|
* The from factor of this device.
|
|
*/
|
|
get formFactor(): string;
|
|
/**
|
|
* The icon name for this device.
|
|
*/
|
|
get icon(): string;
|
|
/**
|
|
* The id of this device.
|
|
*/
|
|
get id(): number;
|
|
/**
|
|
* The id of the currently active input route.
|
|
*/
|
|
get input_route_id(): number;
|
|
set input_route_id(val: number);
|
|
/**
|
|
* The id of the currently active input route.
|
|
*/
|
|
get inputRouteId(): number;
|
|
set inputRouteId(val: number);
|
|
/**
|
|
* A list of available input routes
|
|
*/
|
|
get input_routes(): Route[];
|
|
/**
|
|
* A list of available input routes
|
|
*/
|
|
get inputRoutes(): Route[];
|
|
/**
|
|
* The id of the currently active output route.
|
|
*/
|
|
get output_route_id(): number;
|
|
set output_route_id(val: number);
|
|
/**
|
|
* The id of the currently active output route.
|
|
*/
|
|
get outputRouteId(): number;
|
|
set outputRouteId(val: number);
|
|
/**
|
|
* A list of available output routes
|
|
*/
|
|
get output_routes(): Route[];
|
|
/**
|
|
* A list of available output routes
|
|
*/
|
|
get outputRoutes(): Route[];
|
|
/**
|
|
* A list of available profiles
|
|
*/
|
|
get profiles(): Profile[];
|
|
/**
|
|
* A list of available routes
|
|
*/
|
|
get routes(): Route[];
|
|
|
|
/**
|
|
* Compile-time signal type information.
|
|
*
|
|
* This instance property is generated only for TypeScript type checking.
|
|
* It is not defined at runtime and should not be accessed in JS code.
|
|
* @internal
|
|
*/
|
|
$signals: Device.SignalSignatures;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Device.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Signals
|
|
|
|
connect<K extends keyof Device.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Device.SignalSignatures[K]>,
|
|
): number;
|
|
connect(signal: string, callback: (...args: any[]) => any): number;
|
|
connect_after<K extends keyof Device.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Device.SignalSignatures[K]>,
|
|
): number;
|
|
connect_after(signal: string, callback: (...args: any[]) => any): number;
|
|
emit<K extends keyof Device.SignalSignatures>(
|
|
signal: K,
|
|
...args: GObject.GjsParameters<Device.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
|
|
): void;
|
|
emit(signal: string, ...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* gets the currently active profile of this device
|
|
*/
|
|
get_active_profile_id(): number;
|
|
/**
|
|
* gets the description of this device
|
|
*/
|
|
get_description(): string;
|
|
/**
|
|
* gets the type of this device
|
|
*/
|
|
get_device_type(): DeviceType;
|
|
/**
|
|
* gets the form factor of this device.
|
|
*/
|
|
get_form_factor(): string;
|
|
/**
|
|
* gets the icon of this device
|
|
*/
|
|
get_icon(): string;
|
|
/**
|
|
* gets the id of this device
|
|
*/
|
|
get_id(): number;
|
|
/**
|
|
* gets the currently active input route of this device
|
|
*/
|
|
get_input_route_id(): number;
|
|
/**
|
|
* gets a GList containing the input routes
|
|
*/
|
|
get_input_routes(): Route[] | null;
|
|
/**
|
|
* gets the currently active output route of this device
|
|
*/
|
|
get_output_route_id(): number;
|
|
/**
|
|
* gets a GList containing the output routes
|
|
*/
|
|
get_output_routes(): Route[] | null;
|
|
/**
|
|
* gets the profile with the given id
|
|
* @param id the id of the profile
|
|
*/
|
|
get_profile(id: number): Profile | null;
|
|
/**
|
|
* gets a GList containing the profiles
|
|
*/
|
|
get_profiles(): Profile[] | null;
|
|
/**
|
|
* gets the route with the given id
|
|
* @param id the id of the route
|
|
*/
|
|
get_route(id: number): Route | null;
|
|
/**
|
|
* gets a GList containing the routes
|
|
*/
|
|
get_routes(): Route[] | null;
|
|
/**
|
|
* sets the profile for this device
|
|
* @param profile_id the id of the profile
|
|
*/
|
|
set_active_profile_id(profile_id: number): void;
|
|
/**
|
|
* sets the route for this device. You should use the [method`AstalWp`.Endpoint.set_route] instead.
|
|
* @param route
|
|
* @param card_device card device index
|
|
*/
|
|
set_route(route: Route, card_device: number): void;
|
|
}
|
|
|
|
namespace Endpoint {
|
|
// Signal signatures
|
|
interface SignalSignatures extends Node.SignalSignatures {
|
|
'notify::device': (pspec: GObject.ParamSpec) => void;
|
|
'notify::device-id': (pspec: GObject.ParamSpec) => void;
|
|
'notify::is-default': (pspec: GObject.ParamSpec) => void;
|
|
'notify::route': (pspec: GObject.ParamSpec) => void;
|
|
'notify::route-id': (pspec: GObject.ParamSpec) => void;
|
|
'notify::routes': (pspec: GObject.ParamSpec) => void;
|
|
'notify::channels': (pspec: GObject.ParamSpec) => void;
|
|
'notify::description': (pspec: GObject.ParamSpec) => void;
|
|
'notify::icon': (pspec: GObject.ParamSpec) => void;
|
|
'notify::id': (pspec: GObject.ParamSpec) => void;
|
|
'notify::lock-channels': (pspec: GObject.ParamSpec) => void;
|
|
'notify::media-class': (pspec: GObject.ParamSpec) => void;
|
|
'notify::mute': (pspec: GObject.ParamSpec) => void;
|
|
'notify::name': (pspec: GObject.ParamSpec) => void;
|
|
'notify::path': (pspec: GObject.ParamSpec) => void;
|
|
'notify::serial': (pspec: GObject.ParamSpec) => void;
|
|
'notify::state': (pspec: GObject.ParamSpec) => void;
|
|
'notify::volume': (pspec: GObject.ParamSpec) => void;
|
|
'notify::volume-icon': (pspec: GObject.ParamSpec) => void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Node.ConstructorProps {
|
|
device: Device;
|
|
device_id: number;
|
|
deviceId: number;
|
|
is_default: boolean;
|
|
isDefault: boolean;
|
|
route: Route;
|
|
route_id: number;
|
|
routeId: number;
|
|
routes: Route[];
|
|
}
|
|
}
|
|
|
|
class Endpoint extends Node {
|
|
static $gtype: GObject.GType<Endpoint>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The the device associated with this endpoint.
|
|
*/
|
|
get device(): Device;
|
|
/**
|
|
* The id of the device associated with this endpoint.
|
|
*/
|
|
get device_id(): number;
|
|
/**
|
|
* The id of the device associated with this endpoint.
|
|
*/
|
|
get deviceId(): number;
|
|
/**
|
|
* Whether this node is the default one used for this media-class. Note that setting this
|
|
* property to false has no effect.
|
|
*/
|
|
get is_default(): boolean;
|
|
set is_default(val: boolean);
|
|
/**
|
|
* Whether this node is the default one used for this media-class. Note that setting this
|
|
* property to false has no effect.
|
|
*/
|
|
get isDefault(): boolean;
|
|
set isDefault(val: boolean);
|
|
get route(): Route;
|
|
set route(val: Route);
|
|
get route_id(): number;
|
|
set route_id(val: number);
|
|
get routeId(): number;
|
|
set routeId(val: number);
|
|
/**
|
|
* A list of available routes
|
|
*/
|
|
get routes(): Route[];
|
|
|
|
/**
|
|
* Compile-time signal type information.
|
|
*
|
|
* This instance property is generated only for TypeScript type checking.
|
|
* It is not defined at runtime and should not be accessed in JS code.
|
|
* @internal
|
|
*/
|
|
$signals: Endpoint.SignalSignatures;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Endpoint.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Signals
|
|
|
|
connect<K extends keyof Endpoint.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Endpoint.SignalSignatures[K]>,
|
|
): number;
|
|
connect(signal: string, callback: (...args: any[]) => any): number;
|
|
connect_after<K extends keyof Endpoint.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Endpoint.SignalSignatures[K]>,
|
|
): number;
|
|
connect_after(signal: string, callback: (...args: any[]) => any): number;
|
|
emit<K extends keyof Endpoint.SignalSignatures>(
|
|
signal: K,
|
|
...args: GObject.GjsParameters<Endpoint.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
|
|
): void;
|
|
emit(signal: string, ...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* gets the device associated with this endpoint
|
|
*/
|
|
get_device(): Device | null;
|
|
/**
|
|
* gets the id of the device associated with this endpoint
|
|
*/
|
|
get_device_id(): number;
|
|
/**
|
|
* is this endpoint configured as the default.
|
|
*/
|
|
get_is_default(): boolean;
|
|
/**
|
|
* Gets the currently active [class`AstalWp`.Route]
|
|
*/
|
|
get_route(): Route | null;
|
|
/**
|
|
* gets the id of the currently active route
|
|
*/
|
|
get_route_id(): number;
|
|
/**
|
|
* Gets a list of available routes.
|
|
* This list is filtered and contains only routes, that are actually available. You can get a full
|
|
* list of routes from [property`AstalWp`.Device:routes]
|
|
*/
|
|
get_routes(): Route[] | null;
|
|
/**
|
|
* Sets this endpoint as the default
|
|
* @param is_default
|
|
*/
|
|
set_is_default(is_default: boolean): void;
|
|
/**
|
|
* Sets the currently active [class`AstalWp`.Route]
|
|
* @param route
|
|
*/
|
|
set_route(route: Route): void;
|
|
/**
|
|
* Sets the currently active route id
|
|
* @param route_id
|
|
*/
|
|
set_route_id(route_id: number): void;
|
|
}
|
|
|
|
namespace Node {
|
|
// Signal signatures
|
|
interface SignalSignatures extends GObject.Object.SignalSignatures {
|
|
'notify::channels': (pspec: GObject.ParamSpec) => void;
|
|
'notify::description': (pspec: GObject.ParamSpec) => void;
|
|
'notify::icon': (pspec: GObject.ParamSpec) => void;
|
|
'notify::id': (pspec: GObject.ParamSpec) => void;
|
|
'notify::lock-channels': (pspec: GObject.ParamSpec) => void;
|
|
'notify::media-class': (pspec: GObject.ParamSpec) => void;
|
|
'notify::mute': (pspec: GObject.ParamSpec) => void;
|
|
'notify::name': (pspec: GObject.ParamSpec) => void;
|
|
'notify::path': (pspec: GObject.ParamSpec) => void;
|
|
'notify::serial': (pspec: GObject.ParamSpec) => void;
|
|
'notify::state': (pspec: GObject.ParamSpec) => void;
|
|
'notify::volume': (pspec: GObject.ParamSpec) => void;
|
|
'notify::volume-icon': (pspec: GObject.ParamSpec) => void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
channels: Channel[];
|
|
description: string;
|
|
icon: string;
|
|
id: number;
|
|
lock_channels: boolean;
|
|
lockChannels: boolean;
|
|
media_class: MediaClass;
|
|
mediaClass: MediaClass;
|
|
mute: boolean;
|
|
name: string;
|
|
path: string;
|
|
serial: number;
|
|
state: NodeState;
|
|
volume: number;
|
|
volume_icon: string;
|
|
volumeIcon: string;
|
|
}
|
|
}
|
|
|
|
class Node extends GObject.Object {
|
|
static $gtype: GObject.GType<Node>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* A list of per channel volumes
|
|
*/
|
|
get channels(): Channel[];
|
|
/**
|
|
* The description of this node
|
|
*/
|
|
get description(): string;
|
|
/**
|
|
* The icon of this node. Note that nodes do not have icons associated with them in
|
|
* pipewire, so the icon of the associated device is used instead.
|
|
*/
|
|
get icon(): string;
|
|
/**
|
|
* The pipewire id of this node.
|
|
*/
|
|
get id(): number;
|
|
/**
|
|
* Whether to lock the channels together or not.
|
|
*/
|
|
get lock_channels(): boolean;
|
|
set lock_channels(val: boolean);
|
|
/**
|
|
* Whether to lock the channels together or not.
|
|
*/
|
|
get lockChannels(): boolean;
|
|
set lockChannels(val: boolean);
|
|
/**
|
|
* The media class of this node
|
|
*/
|
|
get media_class(): MediaClass;
|
|
/**
|
|
* The media class of this node
|
|
*/
|
|
get mediaClass(): MediaClass;
|
|
/**
|
|
* The mute state of this node
|
|
*/
|
|
get mute(): boolean;
|
|
set mute(val: boolean);
|
|
/**
|
|
* The name of this node
|
|
*/
|
|
get name(): string;
|
|
/**
|
|
* The object path of this node
|
|
*/
|
|
get path(): string;
|
|
/**
|
|
* The object serial of this node.
|
|
*/
|
|
get serial(): number;
|
|
/**
|
|
* the current state of this node.
|
|
*/
|
|
get state(): NodeState;
|
|
/**
|
|
* The volume of this node
|
|
*/
|
|
get volume(): number;
|
|
set volume(val: number);
|
|
/**
|
|
* The volume icon of this node
|
|
*/
|
|
get volume_icon(): string;
|
|
/**
|
|
* The volume icon of this node
|
|
*/
|
|
get volumeIcon(): string;
|
|
|
|
/**
|
|
* Compile-time signal type information.
|
|
*
|
|
* This instance property is generated only for TypeScript type checking.
|
|
* It is not defined at runtime and should not be accessed in JS code.
|
|
* @internal
|
|
*/
|
|
$signals: Node.SignalSignatures;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Node.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Signals
|
|
|
|
connect<K extends keyof Node.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Node.SignalSignatures[K]>,
|
|
): number;
|
|
connect(signal: string, callback: (...args: any[]) => any): number;
|
|
connect_after<K extends keyof Node.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Node.SignalSignatures[K]>,
|
|
): number;
|
|
connect_after(signal: string, callback: (...args: any[]) => any): number;
|
|
emit<K extends keyof Node.SignalSignatures>(
|
|
signal: K,
|
|
...args: GObject.GjsParameters<Node.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
|
|
): void;
|
|
emit(signal: string, ...args: any[]): void;
|
|
|
|
// Virtual methods
|
|
|
|
vfunc_metadata_changed(key: string, type: string, value: string): void;
|
|
vfunc_params_changed(id: string): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* gets the list representing the per channel volumes
|
|
*/
|
|
get_channels(): Channel[] | null;
|
|
/**
|
|
* gets the description of this node
|
|
*/
|
|
get_description(): string;
|
|
/**
|
|
* gets the icon for this node
|
|
*/
|
|
get_icon(): string;
|
|
/**
|
|
* gets the id of the node.
|
|
*/
|
|
get_id(): number;
|
|
get_lock_channels(): boolean;
|
|
/**
|
|
* gets the media class of the node.
|
|
*/
|
|
get_media_class(): MediaClass;
|
|
/**
|
|
* gets the mute status of the node.
|
|
*/
|
|
get_mute(): boolean;
|
|
/**
|
|
* gets the name of this node
|
|
*/
|
|
get_name(): string;
|
|
/**
|
|
* gets the object path of this node
|
|
*/
|
|
get_path(): string;
|
|
/**
|
|
* Gets the pipewire property with the give key. You should use the GObject properties of this node
|
|
* whereever possible, as you can get notified on changes, which is not the case here.
|
|
* @param key
|
|
*/
|
|
get_pw_property(key: string): string;
|
|
/**
|
|
* gets the serial number of this node
|
|
*/
|
|
get_serial(): number;
|
|
/**
|
|
* gets the current state of this node
|
|
*/
|
|
get_state(): NodeState;
|
|
/**
|
|
* gets the volume
|
|
*/
|
|
get_volume(): number;
|
|
get_volume_icon(): string;
|
|
metadata_changed(key: string, type: string, value: string): void;
|
|
params_changed(id: string): void;
|
|
/**
|
|
* Lock the channel volumes together. If set, all channels will always have the same volume.
|
|
* @param lock_channels
|
|
*/
|
|
set_lock_channels(lock_channels: boolean): void;
|
|
/**
|
|
* Sets the mute status for the node.
|
|
* @param mute A boolean indicating whether to mute the node.
|
|
*/
|
|
set_mute(mute: boolean): void;
|
|
/**
|
|
* Sets the volume level for this node. The volume is clamped to be between
|
|
* 0 and 1.5.
|
|
* @param volume The new volume level to set.
|
|
*/
|
|
set_volume(volume: number): void;
|
|
}
|
|
|
|
namespace Profile {
|
|
// Signal signatures
|
|
interface SignalSignatures extends GObject.Object.SignalSignatures {
|
|
'notify::available': (pspec: GObject.ParamSpec) => void;
|
|
'notify::description': (pspec: GObject.ParamSpec) => void;
|
|
'notify::index': (pspec: GObject.ParamSpec) => void;
|
|
'notify::name': (pspec: GObject.ParamSpec) => void;
|
|
'notify::priority': (pspec: GObject.ParamSpec) => void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
available: Available;
|
|
description: string;
|
|
index: number;
|
|
name: string;
|
|
priority: number;
|
|
}
|
|
}
|
|
|
|
class Profile extends GObject.Object {
|
|
static $gtype: GObject.GType<Profile>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* the available state of this profile
|
|
*/
|
|
get available(): Available;
|
|
get description(): string;
|
|
get index(): number;
|
|
get name(): string;
|
|
get priority(): number;
|
|
|
|
/**
|
|
* Compile-time signal type information.
|
|
*
|
|
* This instance property is generated only for TypeScript type checking.
|
|
* It is not defined at runtime and should not be accessed in JS code.
|
|
* @internal
|
|
*/
|
|
$signals: Profile.SignalSignatures;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Profile.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Signals
|
|
|
|
connect<K extends keyof Profile.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Profile.SignalSignatures[K]>,
|
|
): number;
|
|
connect(signal: string, callback: (...args: any[]) => any): number;
|
|
connect_after<K extends keyof Profile.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Profile.SignalSignatures[K]>,
|
|
): number;
|
|
connect_after(signal: string, callback: (...args: any[]) => any): number;
|
|
emit<K extends keyof Profile.SignalSignatures>(
|
|
signal: K,
|
|
...args: GObject.GjsParameters<Profile.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
|
|
): void;
|
|
emit(signal: string, ...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
get_available(): Available;
|
|
get_description(): string;
|
|
get_index(): number;
|
|
get_name(): string;
|
|
get_priority(): number;
|
|
}
|
|
|
|
namespace Route {
|
|
// Signal signatures
|
|
interface SignalSignatures extends GObject.Object.SignalSignatures {
|
|
'notify::available': (pspec: GObject.ParamSpec) => void;
|
|
'notify::description': (pspec: GObject.ParamSpec) => void;
|
|
'notify::direction': (pspec: GObject.ParamSpec) => void;
|
|
'notify::index': (pspec: GObject.ParamSpec) => void;
|
|
'notify::name': (pspec: GObject.ParamSpec) => void;
|
|
'notify::priority': (pspec: GObject.ParamSpec) => void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
available: Available;
|
|
description: string;
|
|
direction: Direction;
|
|
index: number;
|
|
name: string;
|
|
priority: number;
|
|
}
|
|
}
|
|
|
|
class Route extends GObject.Object {
|
|
static $gtype: GObject.GType<Route>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* the available state of this route
|
|
*/
|
|
get available(): Available;
|
|
get description(): string;
|
|
/**
|
|
* The direction for this route
|
|
*/
|
|
get direction(): Direction;
|
|
get index(): number;
|
|
get name(): string;
|
|
get priority(): number;
|
|
|
|
/**
|
|
* Compile-time signal type information.
|
|
*
|
|
* This instance property is generated only for TypeScript type checking.
|
|
* It is not defined at runtime and should not be accessed in JS code.
|
|
* @internal
|
|
*/
|
|
$signals: Route.SignalSignatures;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Route.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Signals
|
|
|
|
connect<K extends keyof Route.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Route.SignalSignatures[K]>,
|
|
): number;
|
|
connect(signal: string, callback: (...args: any[]) => any): number;
|
|
connect_after<K extends keyof Route.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Route.SignalSignatures[K]>,
|
|
): number;
|
|
connect_after(signal: string, callback: (...args: any[]) => any): number;
|
|
emit<K extends keyof Route.SignalSignatures>(
|
|
signal: K,
|
|
...args: GObject.GjsParameters<Route.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
|
|
): void;
|
|
emit(signal: string, ...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
get_available(): Available;
|
|
get_description(): string;
|
|
get_device(): number;
|
|
get_direction(): Direction;
|
|
get_index(): number;
|
|
get_name(): string;
|
|
get_priority(): number;
|
|
}
|
|
|
|
namespace Stream {
|
|
// Signal signatures
|
|
interface SignalSignatures extends Node.SignalSignatures {
|
|
'notify::media-category': (pspec: GObject.ParamSpec) => void;
|
|
'notify::media-role': (pspec: GObject.ParamSpec) => void;
|
|
'notify::target-endpoint': (pspec: GObject.ParamSpec) => void;
|
|
'notify::target-serial': (pspec: GObject.ParamSpec) => void;
|
|
'notify::channels': (pspec: GObject.ParamSpec) => void;
|
|
'notify::description': (pspec: GObject.ParamSpec) => void;
|
|
'notify::icon': (pspec: GObject.ParamSpec) => void;
|
|
'notify::id': (pspec: GObject.ParamSpec) => void;
|
|
'notify::lock-channels': (pspec: GObject.ParamSpec) => void;
|
|
'notify::media-class': (pspec: GObject.ParamSpec) => void;
|
|
'notify::mute': (pspec: GObject.ParamSpec) => void;
|
|
'notify::name': (pspec: GObject.ParamSpec) => void;
|
|
'notify::path': (pspec: GObject.ParamSpec) => void;
|
|
'notify::serial': (pspec: GObject.ParamSpec) => void;
|
|
'notify::state': (pspec: GObject.ParamSpec) => void;
|
|
'notify::volume': (pspec: GObject.ParamSpec) => void;
|
|
'notify::volume-icon': (pspec: GObject.ParamSpec) => void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Node.ConstructorProps {
|
|
media_category: MediaCategory;
|
|
mediaCategory: MediaCategory;
|
|
media_role: MediaRole;
|
|
mediaRole: MediaRole;
|
|
target_endpoint: Endpoint;
|
|
targetEndpoint: Endpoint;
|
|
target_serial: number;
|
|
targetSerial: number;
|
|
}
|
|
}
|
|
|
|
class Stream extends Node {
|
|
static $gtype: GObject.GType<Stream>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* the media category of this stream.
|
|
*/
|
|
get media_category(): MediaCategory;
|
|
/**
|
|
* the media category of this stream.
|
|
*/
|
|
get mediaCategory(): MediaCategory;
|
|
/**
|
|
* the media role of this stream.
|
|
*/
|
|
get media_role(): MediaRole;
|
|
/**
|
|
* the media role of this stream.
|
|
*/
|
|
get mediaRole(): MediaRole;
|
|
get target_endpoint(): Endpoint;
|
|
set target_endpoint(val: Endpoint);
|
|
get targetEndpoint(): Endpoint;
|
|
set targetEndpoint(val: Endpoint);
|
|
get target_serial(): number;
|
|
set target_serial(val: number);
|
|
get targetSerial(): number;
|
|
set targetSerial(val: number);
|
|
|
|
/**
|
|
* Compile-time signal type information.
|
|
*
|
|
* This instance property is generated only for TypeScript type checking.
|
|
* It is not defined at runtime and should not be accessed in JS code.
|
|
* @internal
|
|
*/
|
|
$signals: Stream.SignalSignatures;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Stream.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Signals
|
|
|
|
connect<K extends keyof Stream.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Stream.SignalSignatures[K]>,
|
|
): number;
|
|
connect(signal: string, callback: (...args: any[]) => any): number;
|
|
connect_after<K extends keyof Stream.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Stream.SignalSignatures[K]>,
|
|
): number;
|
|
connect_after(signal: string, callback: (...args: any[]) => any): number;
|
|
emit<K extends keyof Stream.SignalSignatures>(
|
|
signal: K,
|
|
...args: GObject.GjsParameters<Stream.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
|
|
): void;
|
|
emit(signal: string, ...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
get_media_category(): MediaCategory;
|
|
get_media_role(): MediaRole;
|
|
/**
|
|
* get the target [class`AstalWp`.Endpoint]
|
|
*/
|
|
get_target_endpoint(): Endpoint;
|
|
get_target_serial(): number;
|
|
set_target_endpoint(target: Endpoint): void;
|
|
set_target_serial(serial: number): void;
|
|
}
|
|
|
|
namespace Video {
|
|
// Signal signatures
|
|
interface SignalSignatures extends GObject.Object.SignalSignatures {
|
|
'device-added': (arg0: Device) => void;
|
|
'device-removed': (arg0: Device) => void;
|
|
'recorder-added': (arg0: Stream) => void;
|
|
'recorder-removed': (arg0: Stream) => void;
|
|
'sink-added': (arg0: Endpoint) => void;
|
|
'sink-removed': (arg0: Endpoint) => void;
|
|
'source-added': (arg0: Endpoint) => void;
|
|
'source-removed': (arg0: Endpoint) => void;
|
|
'stream-added': (arg0: Stream) => void;
|
|
'stream-removed': (arg0: Stream) => void;
|
|
'notify::devices': (pspec: GObject.ParamSpec) => void;
|
|
'notify::recorders': (pspec: GObject.ParamSpec) => void;
|
|
'notify::sinks': (pspec: GObject.ParamSpec) => void;
|
|
'notify::sources': (pspec: GObject.ParamSpec) => void;
|
|
'notify::streams': (pspec: GObject.ParamSpec) => void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
devices: Endpoint[];
|
|
recorders: Endpoint[];
|
|
sinks: Endpoint[];
|
|
sources: Endpoint[];
|
|
streams: Endpoint[];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* is instanciated by [class`AstalWp`.Wp]. An instance of class can only be received there.
|
|
*
|
|
* This is a convinience class and acts as a filter for [class`AstalWp`.Wp] to filter for video
|
|
* endpoints and devices.
|
|
*/
|
|
class Video extends GObject.Object {
|
|
static $gtype: GObject.GType<Video>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* A list of AstalWpEndpoint objects
|
|
*/
|
|
get devices(): Endpoint[];
|
|
/**
|
|
* A list of AstalWpEndpoint objects
|
|
*/
|
|
get recorders(): Endpoint[];
|
|
/**
|
|
* A list of AstalWpEndpoint objects
|
|
*/
|
|
get sinks(): Endpoint[];
|
|
/**
|
|
* A list of AstalWpEndpoint objects
|
|
*/
|
|
get sources(): Endpoint[];
|
|
/**
|
|
* A list of AstalWpEndpoint objects
|
|
*/
|
|
get streams(): Endpoint[];
|
|
|
|
/**
|
|
* Compile-time signal type information.
|
|
*
|
|
* This instance property is generated only for TypeScript type checking.
|
|
* It is not defined at runtime and should not be accessed in JS code.
|
|
* @internal
|
|
*/
|
|
$signals: Video.SignalSignatures;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Video.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](wp: Wp): Video;
|
|
|
|
// Signals
|
|
|
|
connect<K extends keyof Video.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Video.SignalSignatures[K]>,
|
|
): number;
|
|
connect(signal: string, callback: (...args: any[]) => any): number;
|
|
connect_after<K extends keyof Video.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Video.SignalSignatures[K]>,
|
|
): number;
|
|
connect_after(signal: string, callback: (...args: any[]) => any): number;
|
|
emit<K extends keyof Video.SignalSignatures>(
|
|
signal: K,
|
|
...args: GObject.GjsParameters<Video.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
|
|
): void;
|
|
emit(signal: string, ...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* the device with the given id
|
|
* @param id the id of the device
|
|
* @returns the device with the given id
|
|
*/
|
|
get_device(id: number): Device | null;
|
|
/**
|
|
* a list containing the devices
|
|
* @returns a GList containing the devices
|
|
*/
|
|
get_devices(): Device[] | null;
|
|
/**
|
|
* the recorder with the given id
|
|
* @param id the id of the endpoint
|
|
* @returns the recorder with the given id
|
|
*/
|
|
get_recorder(id: number): Stream | null;
|
|
/**
|
|
* a list containing the video recorders
|
|
* @returns a GList containing the video recorders
|
|
*/
|
|
get_recorders(): Stream[] | null;
|
|
/**
|
|
* the sink with the given id
|
|
* @param id the id of the endpoint
|
|
* @returns the sink with the given id
|
|
*/
|
|
get_sink(id: number): Endpoint | null;
|
|
/**
|
|
* a list containing the video sinks
|
|
* @returns a GList containing the video sinks
|
|
*/
|
|
get_sinks(): Endpoint[] | null;
|
|
/**
|
|
* the source with the given id
|
|
* @param id the id of the endpoint
|
|
* @returns the source with the given id
|
|
*/
|
|
get_source(id: number): Endpoint | null;
|
|
/**
|
|
* a list containing the video sources
|
|
* @returns a GList containing the video sources
|
|
*/
|
|
get_sources(): Endpoint[] | null;
|
|
/**
|
|
* the stream with the given id
|
|
* @param id the id of the endpoint
|
|
* @returns the stream with the given id
|
|
*/
|
|
get_stream(id: number): Stream | null;
|
|
/**
|
|
* a list containing the video streams
|
|
* @returns a GList containing the video streams
|
|
*/
|
|
get_streams(): Stream[] | null;
|
|
}
|
|
|
|
namespace Wp {
|
|
// Signal signatures
|
|
interface SignalSignatures extends GObject.Object.SignalSignatures {
|
|
'device-added': (arg0: Device) => void;
|
|
'device-removed': (arg0: Device) => void;
|
|
'node-added': (arg0: Node) => void;
|
|
'node-removed': (arg0: Node) => void;
|
|
ready: () => void;
|
|
'notify::audio': (pspec: GObject.ParamSpec) => void;
|
|
'notify::default-microphone': (pspec: GObject.ParamSpec) => void;
|
|
'notify::default-speaker': (pspec: GObject.ParamSpec) => void;
|
|
'notify::devices': (pspec: GObject.ParamSpec) => void;
|
|
'notify::nodes': (pspec: GObject.ParamSpec) => void;
|
|
'notify::scale': (pspec: GObject.ParamSpec) => void;
|
|
'notify::video': (pspec: GObject.ParamSpec) => void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
audio: Audio;
|
|
default_microphone: Endpoint;
|
|
defaultMicrophone: Endpoint;
|
|
default_speaker: Endpoint;
|
|
defaultSpeaker: Endpoint;
|
|
devices: Device[];
|
|
nodes: Node[];
|
|
scale: Scale;
|
|
video: Video;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* manages the connection to wireplumber. Usually you don't want to use this class directly, but use
|
|
* the [class`AstalWp`.Audio] or [class`AstalWp`.Video] instead.
|
|
*/
|
|
class Wp extends GObject.Object {
|
|
static $gtype: GObject.GType<Wp>;
|
|
|
|
// Properties
|
|
|
|
get audio(): Audio;
|
|
/**
|
|
* The [class`AstalWp`.Endpoint] representing the default speaker
|
|
*/
|
|
get default_microphone(): Endpoint;
|
|
/**
|
|
* The [class`AstalWp`.Endpoint] representing the default speaker
|
|
*/
|
|
get defaultMicrophone(): Endpoint;
|
|
/**
|
|
* The [class`AstalWp`.Endpoint] representing the default speaker
|
|
*/
|
|
get default_speaker(): Endpoint;
|
|
/**
|
|
* The [class`AstalWp`.Endpoint] representing the default speaker
|
|
*/
|
|
get defaultSpeaker(): Endpoint;
|
|
/**
|
|
* A list of [class`AstalWp`.Device] objects
|
|
*/
|
|
get devices(): Device[];
|
|
/**
|
|
* A list of [class`AstalWp`.Node] objects
|
|
*/
|
|
get nodes(): Node[];
|
|
/**
|
|
* The scale used for the volume
|
|
*/
|
|
get scale(): Scale;
|
|
set scale(val: Scale);
|
|
get video(): Video;
|
|
|
|
/**
|
|
* Compile-time signal type information.
|
|
*
|
|
* This instance property is generated only for TypeScript type checking.
|
|
* It is not defined at runtime and should not be accessed in JS code.
|
|
* @internal
|
|
*/
|
|
$signals: Wp.SignalSignatures;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Wp.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Signals
|
|
|
|
connect<K extends keyof Wp.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Wp.SignalSignatures[K]>,
|
|
): number;
|
|
connect(signal: string, callback: (...args: any[]) => any): number;
|
|
connect_after<K extends keyof Wp.SignalSignatures>(
|
|
signal: K,
|
|
callback: GObject.SignalCallback<this, Wp.SignalSignatures[K]>,
|
|
): number;
|
|
connect_after(signal: string, callback: (...args: any[]) => any): number;
|
|
emit<K extends keyof Wp.SignalSignatures>(
|
|
signal: K,
|
|
...args: GObject.GjsParameters<Wp.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
|
|
): void;
|
|
emit(signal: string, ...args: any[]): void;
|
|
|
|
// Static methods
|
|
|
|
/**
|
|
* gets the default wireplumber object.
|
|
*/
|
|
static get_default(): Wp | null;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* gets the [class`AstalWp`.Audio] object
|
|
* @returns gets the audio object
|
|
*/
|
|
get_audio(): Audio | null;
|
|
/**
|
|
* gets the default microphone object
|
|
* @returns gets the default microphone object
|
|
*/
|
|
get_default_microphone(): Endpoint | null;
|
|
/**
|
|
* gets the default speaker object
|
|
* @returns gets the default speaker object
|
|
*/
|
|
get_default_speaker(): Endpoint | null;
|
|
/**
|
|
* the device with the given id
|
|
* @param id the id of the device
|
|
* @returns the device with the given id
|
|
*/
|
|
get_device(id: number): Device | null;
|
|
/**
|
|
* the GList containing the devices
|
|
* @returns a GList containing the devices
|
|
*/
|
|
get_devices(): Device[] | null;
|
|
/**
|
|
* the node with the given id
|
|
* @param id the id of the node
|
|
* @returns the node with the given id
|
|
*/
|
|
get_node(id: number): Node | null;
|
|
/**
|
|
* finds the AstalWpNode with the give serial.
|
|
* @param serial
|
|
*/
|
|
get_node_by_serial(serial: number): Node | null;
|
|
/**
|
|
* a GList containing all nodes
|
|
* @returns a GList containing the nodes
|
|
*/
|
|
get_nodes(): Node[] | null;
|
|
get_scale(): Scale;
|
|
/**
|
|
* gets the video object
|
|
* @returns gets the video object
|
|
*/
|
|
get_video(): Video | null;
|
|
set_scale(scale: Scale | null): void;
|
|
}
|
|
|
|
type AudioClass = typeof Audio;
|
|
type ChannelClass = typeof Channel;
|
|
type DeviceClass = typeof Device;
|
|
type EndpointClass = typeof Endpoint;
|
|
type NodeClass = typeof Node;
|
|
type ProfileClass = typeof Profile;
|
|
type RouteClass = typeof Route;
|
|
type StreamClass = typeof Stream;
|
|
type VideoClass = typeof Video;
|
|
type WpClass = typeof Wp;
|
|
/**
|
|
* Name of the imported GIR library
|
|
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
|
|
*/
|
|
const __name__: string;
|
|
/**
|
|
* Version of the imported GIR library
|
|
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
|
|
*/
|
|
const __version__: string;
|
|
}
|
|
|
|
export default AstalWp;
|
|
}
|
|
|
|
declare module 'gi://AstalWp' {
|
|
import AstalWp01 from 'gi://AstalWp?version=0.1';
|
|
export default AstalWp01;
|
|
}
|
|
// END
|