Initial Commit

This commit is contained in:
Reece Wilson 2023-03-04 13:40:44 +00:00
commit 48e7b813f6
17 changed files with 45851 additions and 0 deletions

2777
GLib.d.ts vendored Normal file

File diff suppressed because it is too large Load Diff

992
GObject.d.ts vendored Normal file
View File

@ -0,0 +1,992 @@
declare namespace GObject {
class BindingFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kDefault": BindingFlags
static readonly "kBidirectional": BindingFlags
static readonly "kSyncCreate": BindingFlags
static readonly "kInvertBoolean": BindingFlags
}
class ConnectFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kAfter": ConnectFlags
static readonly "kSwapped": ConnectFlags
}
class ParamFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kReadable": ParamFlags
static readonly "kWritable": ParamFlags
static readonly "kReadwrite": ParamFlags
static readonly "kConstruct": ParamFlags
static readonly "kConstructOnly": ParamFlags
static readonly "kLaxValidation": ParamFlags
static readonly "kStaticName": ParamFlags
static readonly "kPrivate": ParamFlags
static readonly "kStaticNick": ParamFlags
static readonly "kStaticBlurb": ParamFlags
static readonly "kExplicitNotify": ParamFlags
static readonly "kDeprecated": ParamFlags
}
class SignalFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kRunFirst": SignalFlags
static readonly "kRunLast": SignalFlags
static readonly "kRunCleanup": SignalFlags
static readonly "kNoRecurse": SignalFlags
static readonly "kDetailed": SignalFlags
static readonly "kAction": SignalFlags
static readonly "kNoHooks": SignalFlags
static readonly "kMustCollect": SignalFlags
static readonly "kDeprecated": SignalFlags
static readonly "kAccumulatorFirstRun": SignalFlags
}
class SignalMatchType {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kId": SignalMatchType
static readonly "kDetail": SignalMatchType
static readonly "kClosure": SignalMatchType
static readonly "kFunc": SignalMatchType
static readonly "kData": SignalMatchType
static readonly "kUnblocked": SignalMatchType
}
class TypeDebugFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kNone": TypeDebugFlags
static readonly "kObjects": TypeDebugFlags
static readonly "kSignals": TypeDebugFlags
static readonly "kInstanceCount": TypeDebugFlags
static readonly "kMask": TypeDebugFlags
}
class TypeFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kAbstract": TypeFlags
static readonly "kValueAbstract": TypeFlags
static readonly "kFinal": TypeFlags
}
class TypeFundamentalFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kClassed": TypeFundamentalFlags
static readonly "kInstantiatable": TypeFundamentalFlags
static readonly "kDerivable": TypeFundamentalFlags
static readonly "kDeepDerivable": TypeFundamentalFlags
}
class TypePlugin {
completeInterfaceInfo(instanceType: number, interfaceType: number, info: GObject.InterfaceInfo): void;
completeTypeInfo(gType: number, info: GObject.TypeInfo, valueTable: GObject.TypeValueTable): void;
unuse(): void;
use(): void;
}
class CClosure {
closure : GObject.Closure;
callback : void;
static MarshalBOOLEANBOXEDBOXED(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalBOOLEANFLAGS(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalSTRINGOBJECTPOINTER(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDBOOLEAN(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDBOXED(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDCHAR(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDDOUBLE(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDENUM(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDFLAGS(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDFLOAT(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDINT(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDLONG(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDOBJECT(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDPARAM(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDPOINTER(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDSTRING(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDUCHAR(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDUINT(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDUINTPOINTER(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDULONG(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDVARIANT(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalVOIDVOID(closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
static MarshalGeneric(closure: GObject.Closure, returnGvalue: GObject.Value, nParamValues: number, paramValues: GObject.Value): void;
}
class Closure {
refCount : number;
metaMarshalNouse : number;
nGuards : number;
nFnotifiers : number;
nInotifiers : number;
inInotify : number;
floating : number;
derivativeFlag : number;
inMarshal : number;
isInvalid : number;
marshal : (closure: GObject.Closure, returnValue: GObject.Value, nParamValues: number, paramValues: GObject.Value) => void;
data : void;
notifiers : GObject.ClosureNotifyData;
static NewObject(sizeofClosure: number, object: GObject.Object): GObject.Closure;
static NewSimple(sizeofClosure: number): GObject.Closure;
invalidate(): void;
invoke(returnValue ?: GObject.Value, nParamValues ?: number, paramValues ?: GObject.Value[]): void;
ref(): GObject.Closure;
sink(): void;
unref(): void;
}
class ClosureNotifyData {
data : void;
notify : (closure: GObject.Closure) => void;
}
class EnumClass {
gTypeClass : GObject.TypeClass;
minimum : number;
maximum : number;
nValues : number;
values : GObject.EnumValue;
}
class EnumValue {
value : number;
valueName : string;
valueNick : string;
}
class FlagsClass {
gTypeClass : GObject.TypeClass;
mask : number;
nValues : number;
values : GObject.FlagsValue;
}
class FlagsValue {
value : number;
valueName : string;
valueNick : string;
}
class InitiallyUnownedClass { /*unsupported*/ }
class InterfaceInfo {
interfaceInit : (gIface: GObject.TypeInterface) => void;
interfaceFinalize : (gIface: GObject.TypeInterface) => void;
interfaceData : void;
}
class ObjectClass {
gTypeClass : GObject.TypeClass;
_constructor : void;
setProperty : (object: GObject.Object, propertyId: number, value: GObject.Value, pspec: GObject.ParamSpec) => void;
getProperty : (object: GObject.Object, propertyId: number, value: GObject.Value, pspec: GObject.ParamSpec) => void;
dispose : (object: GObject.Object) => void;
finalize : (object: GObject.Object) => void;
dispatchPropertiesChanged : (object: GObject.Object, nPspecs: number, pspecs: GObject.ParamSpec) => void;
notify : (object: GObject.Object, pspec: GObject.ParamSpec) => void;
constructed : (object: GObject.Object) => void;
flags : number | bigint;
findProperty(propertyName: string): GObject.ParamSpec;
installProperties(nPspecs: number, pspecs: GObject.ParamSpec[]): void;
installProperty(propertyId: number, pspec: GObject.ParamSpec): void;
listProperties(nProperties: number): GObject.ParamSpec[];
overrideProperty(propertyId: number, name: string): void;
}
class ObjectConstructParam {
pspec : GObject.ParamSpec;
value : GObject.Value;
}
class ParamSpecClass {
gTypeClass : GObject.TypeClass;
valueType : number;
finalize : (pspec: GObject.ParamSpec) => void;
valueSetDefault : (pspec: GObject.ParamSpec, value: GObject.Value) => void;
valueValidate : (pspec: GObject.ParamSpec, value: GObject.Value) => boolean;
valuesCmp : (pspec: GObject.ParamSpec, value1: GObject.Value, value2: GObject.Value) => number;
}
class ParamSpecPool {
insert(pspec: GObject.ParamSpec, ownerType: number): void;
list(ownerType: number, nPspecsP: number): GObject.ParamSpec[];
listOwned(ownerType: number): GObject.ParamSpec[];
lookup(paramName: string, ownerType: number, walkAncestors: boolean): GObject.ParamSpec;
remove(pspec: GObject.ParamSpec): void;
}
class ParamSpecTypeInfo {
instanceSize : number;
nPreallocs : number;
instanceInit : (pspec: GObject.ParamSpec) => void;
valueType : number;
finalize : (pspec: GObject.ParamSpec) => void;
valueSetDefault : (pspec: GObject.ParamSpec, value: GObject.Value) => void;
valueValidate : (pspec: GObject.ParamSpec, value: GObject.Value) => boolean;
valuesCmp : (pspec: GObject.ParamSpec, value1: GObject.Value, value2: GObject.Value) => number;
}
class Parameter {
name : string;
value : GObject.Value;
}
class SignalInvocationHint {
signalId : number;
detail : number;
runType : GObject.SignalFlags;
}
class SignalQuery {
signalId : number;
signalName : string;
itype : number;
signalFlags : GObject.SignalFlags;
returnType : number;
nParams : number;
paramTypes : number[];
}
class TypeClass {
gType : number;
addPrivate(privateSize: number | bigint): void;
getPrivate(privateType: number): void;
peekParent(): GObject.TypeClass;
unref(): void;
static AdjustPrivateOffset(privateSizeOrOffset: number): void;
static Peek(type: number): GObject.TypeClass;
static PeekStatic(type: number): GObject.TypeClass;
static Ref(type: number): GObject.TypeClass;
}
class TypeFundamentalInfo {
typeFlags : GObject.TypeFundamentalFlags;
}
class TypeInfo {
classSize : number;
baseInit : (gClass: GObject.TypeClass) => void;
baseFinalize : (gClass: GObject.TypeClass) => void;
classInit : (gClass: GObject.TypeClass) => void;
classFinalize : (gClass: GObject.TypeClass) => void;
classData : void;
instanceSize : number;
nPreallocs : number;
instanceInit : (instance: GObject.TypeInstance, gClass: GObject.TypeClass) => void;
valueTable : GObject.TypeValueTable;
}
class TypeInstance {
gClass : GObject.TypeClass;
getPrivate(privateType: number): void;
}
class TypeInterface {
gType : number;
gInstanceType : number;
peekParent(): GObject.TypeInterface;
static AddPrerequisite(interfaceType: number, prerequisiteType: number): void;
static GetPlugin(instanceType: number, interfaceType: number): GObject.TypePlugin;
static InstantiatablePrerequisite(interfaceType: number): number;
static Peek(instanceClass: GObject.TypeClass, ifaceType: number): GObject.TypeInterface;
static Prerequisites(interfaceType: number, nPrerequisites ?: number): number[];
}
class TypeModuleClass {
parentClass : GObject.ObjectClass;
load : (module: GObject.TypeModule) => boolean;
unload : (module: GObject.TypeModule) => void;
reserved1 : () => void;
reserved2 : () => void;
reserved3 : () => void;
reserved4 : () => void;
}
class TypePluginClass {
baseIface : GObject.TypeInterface;
usePlugin : (plugin: GObject.TypePlugin) => void;
unusePlugin : (plugin: GObject.TypePlugin) => void;
completeTypeInfo : (plugin: GObject.TypePlugin, gType: number, info: GObject.TypeInfo, valueTable: GObject.TypeValueTable) => void;
completeInterfaceInfo : (plugin: GObject.TypePlugin, instanceType: number, interfaceType: number, info: GObject.InterfaceInfo) => void;
}
class TypeQuery {
type : number;
typeName : string;
classSize : number;
instanceSize : number;
}
class TypeValueTable { /*unsupported*/ }
class Value {
gType : number;
copy(destValue: GObject.Value): void;
dupObject(): GObject.Object;
dupString(): string;
dupVariant(): AuGlibEx.Variant;
fitsPointer(): boolean;
getBoolean(): boolean;
getBoxed(): void;
getChar(): number;
getDouble(): number;
getEnum(): number;
getFlags(): number;
getFloat(): number;
getGtype(): number;
getInt(): number;
getInt64(): number | bigint;
getLong(): number;
getObject(): GObject.Object;
getParam(): GObject.ParamSpec;
getPointer(): void;
getSchar(): number;
getString(): string;
getUchar(): number;
getUint(): number;
getUint64(): number | bigint;
getUlong(): number;
getVariant(): AuGlibEx.Variant;
init(gType: number): GObject.Value;
initFromInstance(instance: GObject.TypeInstance): void;
peekPointer(): void;
reset(): GObject.Value;
setBoolean(vBoolean: boolean): void;
setBoxed(): void;
setBoxedTakeOwnership(): void;
setChar(vChar: number): void;
setDouble(vDouble: number): void;
setEnum(vEnum: number): void;
setFlags(vFlags: number): void;
setFloat(vFloat: number): void;
setGtype(vGtype: number): void;
setInstance(): void;
setInt(vInt: number): void;
setInt64(vInt64: number | bigint): void;
setInternedString(vString: string | undefined | null): void;
setLong(vLong: number): void;
setObject(vObject: GObject.Object | undefined | null): void;
setParam(param: GObject.ParamSpec | undefined | null): void;
setPointer(): void;
setSchar(vChar: number): void;
setStaticBoxed(): void;
setStaticString(vString: string | undefined | null): void;
setString(vString: string | undefined | null): void;
setStringTakeOwnership(vString: string | undefined | null): void;
setUchar(vUchar: number): void;
setUint(vUint: number): void;
setUint64(vUint64: number | bigint): void;
setUlong(vUlong: number): void;
setVariant(variant: AuGlibEx.Variant | undefined | null): void;
takeBoxed(): void;
takeString(vString: string | undefined | null): void;
takeVariant(variant: AuGlibEx.Variant | undefined | null): void;
transform(destValue: GObject.Value): boolean;
unset(): void;
static TypeCompatible(srcType: number, destType: number): boolean;
static TypeTransformable(srcType: number, destType: number): boolean;
}
class ValueArray {
nValues : number;
values : GObject.Value;
nPrealloced : number;
static New(nPrealloced: number): GObject.ValueArray;
append(value: GObject.Value | undefined | null): GObject.ValueArray;
copy(): GObject.ValueArray;
getNth(index: number): GObject.Value;
insert(index: number, value: GObject.Value | undefined | null): GObject.ValueArray;
prepend(value: GObject.Value | undefined | null): GObject.ValueArray;
remove(index: number): GObject.ValueArray;
sort(compareFunc: () => number): GObject.ValueArray;
}
class WeakRef {
}
class Binding extends GObject.Object {
constructor(initializerList ?: BindingCtor);
flags : GObject.BindingFlags;
source : GObject.Object;
sourceProperty : string;
target : GObject.Object;
targetProperty : string;
dupSource(): GObject.Object;
dupTarget(): GObject.Object;
getFlags(): GObject.BindingFlags;
getSource(): GObject.Object;
getSourceProperty(): string;
getTarget(): GObject.Object;
getTargetProperty(): string;
unbind(): void;
//TypeScript is complete garbage:
}
class BindingCtor {
source ?: GObject.Object;
target ?: GObject.Object;
sourceProperty ?: string;
targetProperty ?: string;
flags ?: GObject.BindingFlags;
}
class BindingGroup extends GObject.Object {
constructor(initializerList ?: BindingGroupCtor);
source : GObject.Object;
static New(): GObject.BindingGroup;
bind(sourceProperty: string, target: GObject.Object, targetProperty: string, flags: GObject.BindingFlags): void;
bindFull(sourceProperty: string, target: GObject.Object, targetProperty: string, flags: GObject.BindingFlags, transformTo: GObject.Closure | undefined | null, transformFrom: GObject.Closure | undefined | null): void;
dupSource(): GObject.Object;
setSource(source: GObject.Object | undefined | null): void;
//TypeScript is complete garbage:
}
class BindingGroupCtor {
source ?: GObject.Object;
}
class InitiallyUnowned extends GObject.Object {
constructor(initializerList ?: InitiallyUnownedCtor);
gTypeInstance : GObject.TypeInstance;
refCount : number;
qdata : AuGlibEx.Data;
//TypeScript is complete garbage:
}
class InitiallyUnownedCtor {
}
class Object {
constructor(initializerList ?: ObjectCtor);
gTypeInstance : GObject.TypeInstance;
refCount : number;
qdata : AuGlibEx.Data;
static Newv(objectType: number, nParameters: number, parameters: GObject.Parameter[]): GObject.Object;
static CompatControl(what: number | bigint): number | bigint;
static InterfaceFindProperty(gIface: GObject.TypeInterface, propertyName: string): GObject.ParamSpec;
static InterfaceInstallProperty(gIface: GObject.TypeInterface, pspec: GObject.ParamSpec): void;
static InterfaceListProperties(gIface: GObject.TypeInterface, nPropertiesP: number): GObject.ParamSpec[];
bindProperty(sourceProperty: string, target: GObject.Object, targetProperty: string, flags: GObject.BindingFlags): GObject.Binding;
bindPropertyFull(sourceProperty: string, target: GObject.Object, targetProperty: string, flags: GObject.BindingFlags, transformTo: GObject.Closure, transformFrom: GObject.Closure): GObject.Binding;
forceFloating(): void;
freezeNotify(): void;
getData(key: string): void;
getProperty(propertyName: string, value: GObject.Value): void;
getQdata(quark: number): void;
getv(nProperties: number, names: string[], values: GObject.Value[]): void;
isFloating(): boolean;
notify(propertyName: string): void;
notifyByPspec(pspec: GObject.ParamSpec): void;
ref(): GObject.Object;
refSink(): GObject.Object;
runDispose(): void;
setData(key: string): void;
setProperty(propertyName: string, value: GObject.Value): void;
stealData(key: string): void;
stealQdata(quark: number): void;
thawNotify(): void;
unref(): void;
watchClosure(closure: GObject.Closure): void;
attachEventListener(listener: AuGlibEx.IEventListener): AuGlibEx.EventListener;
//TypeScript is complete garbage:
}
class ObjectCtor {
}
class ObjectEventListener extends AuGlibEx.IEventListener {
notify(pspec: GObject.ParamSpec): void;
}
class ParamSpec {
constructor(initializerList ?: ParamSpecCtor);
gTypeInstance : GObject.TypeInstance;
name : string;
flags : GObject.ParamFlags;
valueType : number;
ownerType : number;
nick : string;
blurb : string;
qdata : AuGlibEx.Data;
refCount : number;
paramId : number;
static IsValidName(name: string): boolean;
getBlurb(): string;
getDefaultValue(): GObject.Value;
getName(): string;
getNameQuark(): number;
getNick(): string;
getQdata(quark: number): void;
getRedirectTarget(): GObject.ParamSpec;
setQdata(quark: number): void;
sink(): void;
stealQdata(quark: number): void;
//TypeScript is complete garbage:
}
class ParamSpecCtor {
}
class ParamSpecBoolean extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecBooleanCtor);
parentInstance : GObject.ParamSpec;
defaultValue : boolean;
//TypeScript is complete garbage:
}
class ParamSpecBooleanCtor {
}
class ParamSpecBoxed extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecBoxedCtor);
parentInstance : GObject.ParamSpec;
//TypeScript is complete garbage:
}
class ParamSpecBoxedCtor {
}
class ParamSpecChar extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecCharCtor);
parentInstance : GObject.ParamSpec;
minimum : number;
maximum : number;
defaultValue : number;
//TypeScript is complete garbage:
}
class ParamSpecCharCtor {
}
class ParamSpecDouble extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecDoubleCtor);
parentInstance : GObject.ParamSpec;
minimum : number;
maximum : number;
defaultValue : number;
epsilon : number;
//TypeScript is complete garbage:
}
class ParamSpecDoubleCtor {
}
class ParamSpecEnum extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecEnumCtor);
parentInstance : GObject.ParamSpec;
enumClass : GObject.EnumClass;
defaultValue : number;
//TypeScript is complete garbage:
}
class ParamSpecEnumCtor {
}
class ParamSpecFlags extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecFlagsCtor);
parentInstance : GObject.ParamSpec;
flagsClass : GObject.FlagsClass;
defaultValue : number;
//TypeScript is complete garbage:
}
class ParamSpecFlagsCtor {
}
class ParamSpecFloat extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecFloatCtor);
parentInstance : GObject.ParamSpec;
minimum : number;
maximum : number;
defaultValue : number;
epsilon : number;
//TypeScript is complete garbage:
}
class ParamSpecFloatCtor {
}
class ParamSpecGType extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecGTypeCtor);
parentInstance : GObject.ParamSpec;
isAType : number;
//TypeScript is complete garbage:
}
class ParamSpecGTypeCtor {
}
class ParamSpecInt extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecIntCtor);
parentInstance : GObject.ParamSpec;
minimum : number;
maximum : number;
defaultValue : number;
//TypeScript is complete garbage:
}
class ParamSpecIntCtor {
}
class ParamSpecInt64 extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecInt64Ctor);
parentInstance : GObject.ParamSpec;
minimum : number | bigint;
maximum : number | bigint;
defaultValue : number | bigint;
//TypeScript is complete garbage:
}
class ParamSpecInt64Ctor {
}
class ParamSpecLong extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecLongCtor);
parentInstance : GObject.ParamSpec;
minimum : number;
maximum : number;
defaultValue : number;
//TypeScript is complete garbage:
}
class ParamSpecLongCtor {
}
class ParamSpecObject extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecObjectCtor);
parentInstance : GObject.ParamSpec;
//TypeScript is complete garbage:
}
class ParamSpecObjectCtor {
}
class ParamSpecOverride extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecOverrideCtor);
parentInstance : GObject.ParamSpec;
overridden : GObject.ParamSpec;
//TypeScript is complete garbage:
}
class ParamSpecOverrideCtor {
}
class ParamSpecParam extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecParamCtor);
parentInstance : GObject.ParamSpec;
//TypeScript is complete garbage:
}
class ParamSpecParamCtor {
}
class ParamSpecPointer extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecPointerCtor);
parentInstance : GObject.ParamSpec;
//TypeScript is complete garbage:
}
class ParamSpecPointerCtor {
}
class ParamSpecString extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecStringCtor);
parentInstance : GObject.ParamSpec;
defaultValue : string;
csetFirst : string;
csetNth : string;
substitutor : number;
nullFoldIfEmpty : number;
ensureNonNull : number;
//TypeScript is complete garbage:
}
class ParamSpecStringCtor {
}
class ParamSpecUChar extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecUCharCtor);
parentInstance : GObject.ParamSpec;
minimum : number;
maximum : number;
defaultValue : number;
//TypeScript is complete garbage:
}
class ParamSpecUCharCtor {
}
class ParamSpecUInt extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecUIntCtor);
parentInstance : GObject.ParamSpec;
minimum : number;
maximum : number;
defaultValue : number;
//TypeScript is complete garbage:
}
class ParamSpecUIntCtor {
}
class ParamSpecUInt64 extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecUInt64Ctor);
parentInstance : GObject.ParamSpec;
minimum : number | bigint;
maximum : number | bigint;
defaultValue : number | bigint;
//TypeScript is complete garbage:
}
class ParamSpecUInt64Ctor {
}
class ParamSpecULong extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecULongCtor);
parentInstance : GObject.ParamSpec;
minimum : number;
maximum : number;
defaultValue : number;
//TypeScript is complete garbage:
}
class ParamSpecULongCtor {
}
class ParamSpecUnichar extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecUnicharCtor);
parentInstance : GObject.ParamSpec;
defaultValue : string;
//TypeScript is complete garbage:
}
class ParamSpecUnicharCtor {
}
class ParamSpecValueArray extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecValueArrayCtor);
parentInstance : GObject.ParamSpec;
elementSpec : GObject.ParamSpec;
fixedNElements : number;
//TypeScript is complete garbage:
}
class ParamSpecValueArrayCtor {
}
class ParamSpecVariant extends GObject.ParamSpec {
constructor(initializerList ?: ParamSpecVariantCtor);
parentInstance : GObject.ParamSpec;
type : AuGlibEx.VariantType;
defaultValue : AuGlibEx.Variant;
//TypeScript is complete garbage:
}
class ParamSpecVariantCtor {
}
class SignalGroup extends GObject.Object {
constructor(initializerList ?: SignalGroupCtor);
target : GObject.Object;
targetType : number;
static New(targetType: number): GObject.SignalGroup;
block(): void;
connectData(detailedSignal: string, cHandler: () => void, notify: (closure: GObject.Closure) => void, flags: GObject.ConnectFlags): void;
connectSwapped(detailedSignal: string, cHandler: () => void): void;
dupTarget(): GObject.Object;
setTarget(target: GObject.Object | undefined | null): void;
unblock(): void;
//TypeScript is complete garbage:
}
class SignalGroupCtor {
target ?: GObject.Object;
targetType ?: any;
}
class SignalGroupEventListener extends AuGlibEx.IEventListener {
bind(instance: GObject.Object): void;
unbind(): void;
}
class TypeModule extends GObject.Object implements GObject.TypePlugin {
constructor(initializerList ?: TypeModuleCtor);
parentInstance : GObject.Object;
useCount : number;
name : string;
addInterface(instanceType: number, interfaceType: number, interfaceInfo: GObject.InterfaceInfo): void;
registerEnum(name: string, constStaticValues: GObject.EnumValue): number;
registerFlags(name: string, constStaticValues: GObject.FlagsValue): number;
registerType(parentType: number, typeName: string, typeInfo: GObject.TypeInfo, flags: GObject.TypeFlags): number;
setName(name: string): void;
unuse(): void;
use(): boolean;
//TypeScript is complete garbage:
completeInterfaceInfo(instanceType: number, interfaceType: number, info: GObject.InterfaceInfo): void;
completeTypeInfo(gType: number, info: GObject.TypeInfo, valueTable: GObject.TypeValueTable): void;
}
class TypeModuleCtor {
}
}

1774
Gdk.d.ts vendored Normal file

File diff suppressed because it is too large Load Diff

383
GdkPixbuf.d.ts vendored Normal file
View File

@ -0,0 +1,383 @@
declare namespace AuGDKPixBuf {
class Colorspace {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kRgb": Colorspace
}
class InterpType {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kNearest": InterpType
static readonly "kTiles": InterpType
static readonly "kBilinear": InterpType
static readonly "kHyper": InterpType
}
class PixbufAlphaMode {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kBilevel": PixbufAlphaMode
static readonly "kFull": PixbufAlphaMode
}
class PixbufError {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kCorruptImage": PixbufError
static readonly "kInsufficientMemory": PixbufError
static readonly "kBadOption": PixbufError
static readonly "kUnknownType": PixbufError
static readonly "kUnsupportedOperation": PixbufError
static readonly "kFailed": PixbufError
static readonly "kIncompleteAnimation": PixbufError
}
class PixbufFormatFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kWritable": PixbufFormatFlags
static readonly "kScalable": PixbufFormatFlags
static readonly "kThreadsafe": PixbufFormatFlags
}
class PixbufRotation {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kNone": PixbufRotation
static readonly "kCounterclockwise": PixbufRotation
static readonly "kUpsidedown": PixbufRotation
static readonly "kClockwise": PixbufRotation
}
class PixbufAnimationClass {
parentClass : GObject.ObjectClass;
isStaticImage : (animation: AuGDKPixBuf.PixbufAnimation) => boolean;
getStaticImage : (animation: AuGDKPixBuf.PixbufAnimation) => AuGDKPixBuf.Pixbuf;
getSize : (animation: AuGDKPixBuf.PixbufAnimation, width: number, height: number) => void;
getIter : (animation: AuGDKPixBuf.PixbufAnimation, startTime: AuGlibEx.TimeVal | undefined | null) => AuGDKPixBuf.PixbufAnimationIter;
}
class PixbufAnimationIterClass {
parentClass : GObject.ObjectClass;
getDelayTime : (iter: AuGDKPixBuf.PixbufAnimationIter) => number;
getPixbuf : (iter: AuGDKPixBuf.PixbufAnimationIter) => AuGDKPixBuf.Pixbuf;
onCurrentlyLoadingFrame : (iter: AuGDKPixBuf.PixbufAnimationIter) => boolean;
advance : (iter: AuGDKPixBuf.PixbufAnimationIter, currentTime: AuGlibEx.TimeVal | undefined | null) => boolean;
}
class PixbufFormat {
name : string;
signature : AuGDKPixBuf.PixbufModulePattern;
domain : string;
description : string;
mimeTypes : string[];
extensions : string[];
flags : number;
disabled : boolean;
license : string;
copy(): AuGDKPixBuf.PixbufFormat;
free(): void;
getDescription(): string;
getExtensions(): string[];
getLicense(): string;
getMimeTypes(): string[];
getName(): string;
isDisabled(): boolean;
isSaveOptionSupported(optionKey: string): boolean;
isScalable(): boolean;
isWritable(): boolean;
setDisabled(disabled: boolean): void;
}
class PixbufLoaderClass {
parentClass : GObject.ObjectClass;
sizePrepared : (loader: AuGDKPixBuf.PixbufLoader, width: number, height: number) => void;
areaPrepared : (loader: AuGDKPixBuf.PixbufLoader) => void;
areaUpdated : (loader: AuGDKPixBuf.PixbufLoader, x: number, y: number, width: number, height: number) => void;
closed : (loader: AuGDKPixBuf.PixbufLoader) => void;
}
class PixbufModule {
moduleName : string;
modulePath : string;
info : AuGDKPixBuf.PixbufFormat;
load : () => AuGDKPixBuf.Pixbuf;
loadXPmData : (data: string[]) => AuGDKPixBuf.Pixbuf;
beginLoad : void;
stopLoad : () => boolean;
loadIncrement : (buf: number[], size: number) => boolean;
loadAnimation : () => AuGDKPixBuf.PixbufAnimation;
save : (pixbuf: AuGDKPixBuf.Pixbuf, paramKeys: string[] | undefined | null, paramValues: string[] | undefined | null) => boolean;
saveToCallback : void;
isSaveOptionSupported : (optionKey: string) => boolean;
reserved1 : void;
reserved2 : void;
reserved3 : void;
reserved4 : void;
}
class PixbufModulePattern {
prefix : string;
mask : string;
relevance : number;
}
class PixbufSimpleAnimClass {
}
class Pixbuf extends GObject.Object implements AuGIO.Icon, AuGIO.LoadableIcon {
constructor(initializerList ?: PixbufCtor);
bitsPerSample : number;
colorspace : AuGDKPixBuf.Colorspace;
hasAlpha : boolean;
height : number;
nChannels : number;
pixelBytes : AuGlibEx.Bytes;
pixels : void;
rowstride : number;
width : number;
static New(colorspace: AuGDKPixBuf.Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number): AuGDKPixBuf.Pixbuf;
static NewFromBytes(data: AuGlibEx.Bytes, colorspace: AuGDKPixBuf.Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number, rowstride: number): AuGDKPixBuf.Pixbuf;
static NewFromData(data: number[], colorspace: AuGDKPixBuf.Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number, rowstride: number, destroyFn: (pixels: number[]) => void | undefined | null): AuGDKPixBuf.Pixbuf;
static NewFromFile(filename: string): AuGDKPixBuf.Pixbuf;
static NewFromFileAtScale(filename: string, width: number, height: number, preserveAspectRatio: boolean): AuGDKPixBuf.Pixbuf;
static NewFromFileAtScaleUtf8(filename: string, width: number, height: number, preserveAspectRatio: boolean): AuGDKPixBuf.Pixbuf;
static NewFromFileAtSize(filename: string, width: number, height: number): AuGDKPixBuf.Pixbuf;
static NewFromFileAtSizeUtf8(filename: string, width: number, height: number): AuGDKPixBuf.Pixbuf;
static NewFromFileUtf8(filename: string): AuGDKPixBuf.Pixbuf;
static NewFromInline(dataLength: number, data: number[], copyPixels: boolean): AuGDKPixBuf.Pixbuf;
static NewFromResource(resourcePath: string): AuGDKPixBuf.Pixbuf;
static NewFromResourceAtScale(resourcePath: string, width: number, height: number, preserveAspectRatio: boolean): AuGDKPixBuf.Pixbuf;
static NewFromStream(stream: AuGIO.InputStream, cancellable: AuGIO.Cancellable | undefined | null): AuGDKPixBuf.Pixbuf;
static NewFromStreamAtScale(stream: AuGIO.InputStream, width: number, height: number, preserveAspectRatio: boolean, cancellable: AuGIO.Cancellable | undefined | null): AuGDKPixBuf.Pixbuf;
static NewFromStreamFinish(asyncResult: AuGIO.AsyncResult): AuGDKPixBuf.Pixbuf;
static NewFromXPmData(data: string[]): AuGDKPixBuf.Pixbuf;
static CalculateRowstride(colorspace: AuGDKPixBuf.Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number): number;
static GetFileInfo(filename: string, width ?: number, height ?: number): AuGDKPixBuf.PixbufFormat;
static GetFileInfoAsync(filename: string, cancellable: AuGIO.Cancellable | undefined | null, callback: (sourceObject: GObject.Object | undefined | null, res: AuGIO.AsyncResult) => void | undefined | null): void;
static GetFileInfoFinish(asyncResult: AuGIO.AsyncResult, width: number, height: number): AuGDKPixBuf.PixbufFormat;
static GetFormats(): AuGDKPixBuf.PixbufFormat[];
static InitModules(path: string): boolean;
static NewFromStreamAsync(stream: AuGIO.InputStream, cancellable: AuGIO.Cancellable | undefined | null, callback: (sourceObject: GObject.Object | undefined | null, res: AuGIO.AsyncResult) => void | undefined | null): void;
static NewFromStreamAtScaleAsync(stream: AuGIO.InputStream, width: number, height: number, preserveAspectRatio: boolean, cancellable: AuGIO.Cancellable | undefined | null, callback: (sourceObject: GObject.Object | undefined | null, res: AuGIO.AsyncResult) => void | undefined | null): void;
static SaveToStreamFinish(asyncResult: AuGIO.AsyncResult): boolean;
addAlpha(substituteColor: boolean, r: number, g: number, b: number): AuGDKPixBuf.Pixbuf;
applyEmbeddedOrientation(): AuGDKPixBuf.Pixbuf;
composite(dest: AuGDKPixBuf.Pixbuf, destX: number, destY: number, destWidth: number, destHeight: number, offsetX: number, offsetY: number, scaleX: number, scaleY: number, interpType: AuGDKPixBuf.InterpType, overallAlpha: number): void;
compositeColor(dest: AuGDKPixBuf.Pixbuf, destX: number, destY: number, destWidth: number, destHeight: number, offsetX: number, offsetY: number, scaleX: number, scaleY: number, interpType: AuGDKPixBuf.InterpType, overallAlpha: number, checkX: number, checkY: number, checkSize: number, color1: number, color2: number): void;
compositeColorSimple(destWidth: number, destHeight: number, interpType: AuGDKPixBuf.InterpType, overallAlpha: number, checkSize: number, color1: number, color2: number): AuGDKPixBuf.Pixbuf;
copy(): AuGDKPixBuf.Pixbuf;
copyArea(srcX: number, srcY: number, width: number, height: number, destPixbuf: AuGDKPixBuf.Pixbuf, destX: number, destY: number): void;
copyOptions(destPixbuf: AuGDKPixBuf.Pixbuf): boolean;
fill(pixel: number): void;
flip(horizontal: boolean): AuGDKPixBuf.Pixbuf;
getBitsPerSample(): number;
getByteLength(): number | bigint;
getColorspace(): AuGDKPixBuf.Colorspace;
getHasAlpha(): boolean;
getHeight(): number;
getNChannels(): number;
getOption(key: string): string;
getOptions(): number;
getPixels(length: number): number[];
getRowstride(): number;
getWidth(): number;
newSubpixbuf(srcX: number, srcY: number, width: number, height: number): AuGDKPixBuf.Pixbuf;
readPixelBytes(): AuGlibEx.Bytes;
readPixels(): number;
removeOption(key: string): boolean;
rotateSimple(angle: AuGDKPixBuf.PixbufRotation): AuGDKPixBuf.Pixbuf;
saturateAndPixelate(dest: AuGDKPixBuf.Pixbuf, saturation: number, pixelate: boolean): void;
saveToBufferv(buffer: number[], bufferSize: number | bigint, type: string, optionKeys: string[] | undefined | null, optionValues: string[] | undefined | null): boolean;
saveToCallbackv(saveFunc: (buf: number[], count: number | bigint, error: AuGlibEx.Error) => boolean, type: string, optionKeys: string[] | undefined | null, optionValues: string[] | undefined | null): boolean;
saveToStreamv(stream: AuGIO.OutputStream, type: string, optionKeys: string[] | undefined | null, optionValues: string[] | undefined | null, cancellable: AuGIO.Cancellable | undefined | null): boolean;
saveToStreamvAsync(stream: AuGIO.OutputStream, type: string, optionKeys: string[] | undefined | null, optionValues: string[] | undefined | null, cancellable: AuGIO.Cancellable | undefined | null, callback: (sourceObject: GObject.Object | undefined | null, res: AuGIO.AsyncResult) => void | undefined | null): void;
savev(filename: string, type: string, optionKeys: string[] | undefined | null, optionValues: string[] | undefined | null): boolean;
savevUtf8(filename: string, type: string, optionKeys: string[] | undefined | null, optionValues: string[] | undefined | null): boolean;
scale(dest: AuGDKPixBuf.Pixbuf, destX: number, destY: number, destWidth: number, destHeight: number, offsetX: number, offsetY: number, scaleX: number, scaleY: number, interpType: AuGDKPixBuf.InterpType): void;
scaleSimple(destWidth: number, destHeight: number, interpType: AuGDKPixBuf.InterpType): AuGDKPixBuf.Pixbuf;
setOption(key: string, value: string): boolean;
//TypeScript is complete garbage:
static Deserialize(value: AuGlibEx.Variant): AuGIO.Icon;
static Hash(): number;
static NewForString(str: string): AuGIO.Icon;
equal(icon2: AuGIO.Icon | undefined | null): boolean;
serialize(): AuGlibEx.Variant;
load(size: number, type ?: string, cancellable ?: AuGIO.Cancellable | undefined | null): AuGIO.InputStream;
loadAsync(size: number, cancellable: AuGIO.Cancellable | undefined | null, callback: (sourceObject: GObject.Object | undefined | null, res: AuGIO.AsyncResult) => void | undefined | null): void;
loadFinish(res: AuGIO.AsyncResult, type ?: string): AuGIO.InputStream;
}
class PixbufCtor {
colorspace ?: AuGDKPixBuf.Colorspace;
nChannels ?: number;
hasAlpha ?: boolean;
bitsPerSample ?: number;
width ?: number;
height ?: number;
rowstride ?: number;
pixels ?: number | bigint;
pixelBytes ?: AuGlibEx.Bytes;
}
class PixbufAnimation extends GObject.Object {
constructor(initializerList ?: PixbufAnimationCtor);
parentInstance : GObject.Object;
static NewFromFile(filename: string): AuGDKPixBuf.PixbufAnimation;
static NewFromFileUtf8(filename: string): AuGDKPixBuf.PixbufAnimation;
static NewFromResource(resourcePath: string): AuGDKPixBuf.PixbufAnimation;
static NewFromStream(stream: AuGIO.InputStream, cancellable: AuGIO.Cancellable | undefined | null): AuGDKPixBuf.PixbufAnimation;
static NewFromStreamFinish(asyncResult: AuGIO.AsyncResult): AuGDKPixBuf.PixbufAnimation;
static NewFromStreamAsync(stream: AuGIO.InputStream, cancellable: AuGIO.Cancellable | undefined | null, callback: (sourceObject: GObject.Object | undefined | null, res: AuGIO.AsyncResult) => void | undefined | null): void;
getHeight(): number;
getIter(startTime: AuGlibEx.TimeVal | undefined | null): AuGDKPixBuf.PixbufAnimationIter;
getStaticImage(): AuGDKPixBuf.Pixbuf;
getWidth(): number;
isStaticImage(): boolean;
//TypeScript is complete garbage:
}
class PixbufAnimationCtor {
}
class PixbufAnimationIter extends GObject.Object {
constructor(initializerList ?: PixbufAnimationIterCtor);
parentInstance : GObject.Object;
advance(currentTime: AuGlibEx.TimeVal | undefined | null): boolean;
getDelayTime(): number;
getPixbuf(): AuGDKPixBuf.Pixbuf;
onCurrentlyLoadingFrame(): boolean;
//TypeScript is complete garbage:
}
class PixbufAnimationIterCtor {
}
class PixbufLoader extends GObject.Object {
constructor(initializerList ?: PixbufLoaderCtor);
parentInstance : GObject.Object;
priv : void;
static New(): AuGDKPixBuf.PixbufLoader;
static NewWithMimeType(mimeType: string): AuGDKPixBuf.PixbufLoader;
static NewWithType(imageType: string): AuGDKPixBuf.PixbufLoader;
close(): boolean;
getAnimation(): AuGDKPixBuf.PixbufAnimation;
getFormat(): AuGDKPixBuf.PixbufFormat;
getPixbuf(): AuGDKPixBuf.Pixbuf;
setSize(width: number, height: number): void;
write(buf: number[], count: number | bigint): boolean;
writeBytes(buffer: AuGlibEx.Bytes): boolean;
//TypeScript is complete garbage:
}
class PixbufLoaderCtor {
}
class PixbufLoaderEventListener extends AuGlibEx.IEventListener {
areaPrepared(): void;
areaUpdated(x: number, y: number, width: number, height: number): void;
closed(): void;
sizePrepared(width: number, height: number): void;
}
class PixbufNonAnim extends AuGDKPixBuf.PixbufAnimation {
constructor(initializerList ?: PixbufNonAnimCtor);
static New(pixbuf: AuGDKPixBuf.Pixbuf): AuGDKPixBuf.PixbufAnimation;
//TypeScript is complete garbage:
}
class PixbufNonAnimCtor {
}
class PixbufSimpleAnim extends AuGDKPixBuf.PixbufAnimation {
constructor(initializerList ?: PixbufSimpleAnimCtor);
loop : boolean;
static New(width: number, height: number, rate: number): AuGDKPixBuf.PixbufSimpleAnim;
addFrame(pixbuf: AuGDKPixBuf.Pixbuf): void;
getLoop(): boolean;
setLoop(loop: boolean): void;
//TypeScript is complete garbage:
}
class PixbufSimpleAnimCtor {
loop ?: boolean;
}
class PixbufSimpleAnimIter extends AuGDKPixBuf.PixbufAnimationIter {
constructor(initializerList ?: PixbufSimpleAnimIterCtor);
//TypeScript is complete garbage:
}
class PixbufSimpleAnimIterCtor {
}
}

6978
Gio.d.ts vendored Normal file

File diff suppressed because it is too large Load Diff

564
Graphene.d.ts vendored Normal file
View File

@ -0,0 +1,564 @@
declare namespace Graphene {
class EulerOrder {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kDefault": EulerOrder
static readonly "kXYz": EulerOrder
static readonly "kYZx": EulerOrder
static readonly "kZxy": EulerOrder
static readonly "kXZy": EulerOrder
static readonly "kYXz": EulerOrder
static readonly "kZyx": EulerOrder
static readonly "kSxyz": EulerOrder
static readonly "kSxyx": EulerOrder
static readonly "kSxzy": EulerOrder
static readonly "kSxzx": EulerOrder
static readonly "kSyzx": EulerOrder
static readonly "kSyzy": EulerOrder
static readonly "kSyxz": EulerOrder
static readonly "kSyxy": EulerOrder
static readonly "kSzxy": EulerOrder
static readonly "kSzxz": EulerOrder
static readonly "kSzyx": EulerOrder
static readonly "kSzyz": EulerOrder
static readonly "kRzyx": EulerOrder
static readonly "kRxyx": EulerOrder
static readonly "kRyzx": EulerOrder
static readonly "kRxzx": EulerOrder
static readonly "kRxzy": EulerOrder
static readonly "kRyzy": EulerOrder
static readonly "kRzxy": EulerOrder
static readonly "kRyxy": EulerOrder
static readonly "kRyxz": EulerOrder
static readonly "kRzxz": EulerOrder
static readonly "kRxyz": EulerOrder
static readonly "kRzyz": EulerOrder
}
class RayIntersectionKind {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kNone": RayIntersectionKind
static readonly "kEnter": RayIntersectionKind
static readonly "kLeave": RayIntersectionKind
}
class Box {
min : Graphene.Vec3;
max : Graphene.Vec3;
static Alloc(): Graphene.Box;
containsBox(b: Graphene.Box): boolean;
containsPoint(point: Graphene.Point3D): boolean;
equal(b: Graphene.Box): boolean;
expand(point: Graphene.Point3D, res: Graphene.Box): void;
expandScalar(scalar: number, res: Graphene.Box): void;
expandVec3(vec: Graphene.Vec3, res: Graphene.Box): void;
free(): void;
getBoundingSphere(sphere: Graphene.Sphere): void;
getCenter(center: Graphene.Point3D): void;
getDepth(): number;
getHeight(): number;
getMax(max: Graphene.Point3D): void;
getMin(min: Graphene.Point3D): void;
getSize(size: Graphene.Vec3): void;
getVertices(vertices: Graphene.Vec3[]): void;
getWidth(): number;
init(min: Graphene.Point3D | undefined | null, max: Graphene.Point3D | undefined | null): Graphene.Box;
initFromBox(src: Graphene.Box): Graphene.Box;
initFromPoints(nPoints: number, points: Graphene.Point3D[]): Graphene.Box;
initFromVec3(min: Graphene.Vec3 | undefined | null, max: Graphene.Vec3 | undefined | null): Graphene.Box;
initFromVectors(nVectors: number, vectors: Graphene.Vec3[]): Graphene.Box;
intersection(b: Graphene.Box, res ?: Graphene.Box): boolean;
union(b: Graphene.Box, res: Graphene.Box): void;
static Empty(): Graphene.Box;
static Infinite(): Graphene.Box;
static MinusOne(): Graphene.Box;
static One(): Graphene.Box;
static OneMinusOne(): Graphene.Box;
static Zero(): Graphene.Box;
}
class Euler {
angles : Graphene.Vec3;
order : Graphene.EulerOrder;
static Alloc(): Graphene.Euler;
equal(b: Graphene.Euler): boolean;
free(): void;
getAlpha(): number;
getBeta(): number;
getGamma(): number;
getOrder(): Graphene.EulerOrder;
getX(): number;
getY(): number;
getZ(): number;
init(x: number, y: number, z: number): Graphene.Euler;
initFromEuler(src: Graphene.Euler | undefined | null): Graphene.Euler;
initFromMatrix(m: Graphene.Matrix | undefined | null, order: Graphene.EulerOrder): Graphene.Euler;
initFromQuaternion(q: Graphene.Quaternion | undefined | null, order: Graphene.EulerOrder): Graphene.Euler;
initFromRadians(x: number, y: number, z: number, order: Graphene.EulerOrder): Graphene.Euler;
initFromVec3(v: Graphene.Vec3 | undefined | null, order: Graphene.EulerOrder): Graphene.Euler;
initWithOrder(x: number, y: number, z: number, order: Graphene.EulerOrder): Graphene.Euler;
reorder(order: Graphene.EulerOrder, res: Graphene.Euler): void;
toMatrix(res: Graphene.Matrix): void;
toQuaternion(res: Graphene.Quaternion): void;
toVec3(res: Graphene.Vec3): void;
}
class Frustum {
planes : Graphene.Plane[];
static Alloc(): Graphene.Frustum;
containsPoint(point: Graphene.Point3D): boolean;
equal(b: Graphene.Frustum): boolean;
free(): void;
getPlanes(planes: Graphene.Plane[]): void;
init(p0: Graphene.Plane, p1: Graphene.Plane, p2: Graphene.Plane, p3: Graphene.Plane, p4: Graphene.Plane, p5: Graphene.Plane): Graphene.Frustum;
initFromFrustum(src: Graphene.Frustum): Graphene.Frustum;
initFromMatrix(matrix: Graphene.Matrix): Graphene.Frustum;
intersectsBox(box: Graphene.Box): boolean;
intersectsSphere(sphere: Graphene.Sphere): boolean;
}
class Matrix {
value : Graphene.Simd4X4F;
static Alloc(): Graphene.Matrix;
decompose(translate: Graphene.Vec3, scale: Graphene.Vec3, rotate: Graphene.Quaternion, shear: Graphene.Vec3, perspective: Graphene.Vec4): boolean;
determinant(): number;
equal(b: Graphene.Matrix): boolean;
equalFast(b: Graphene.Matrix): boolean;
free(): void;
getRow(index: number, res: Graphene.Vec4): void;
getValue(row: number, col: number): number;
getXScale(): number;
getXTranslation(): number;
getYScale(): number;
getYTranslation(): number;
getZScale(): number;
getZTranslation(): number;
initFrom2d(XX: number, YX: number, XY: number, YY: number, X0: number, Y0: number): Graphene.Matrix;
initFromFloat(v: number[]): Graphene.Matrix;
initFromMatrix(src: Graphene.Matrix): Graphene.Matrix;
initFromVec4(v0: Graphene.Vec4, v1: Graphene.Vec4, v2: Graphene.Vec4, v3: Graphene.Vec4): Graphene.Matrix;
initFrustum(left: number, right: number, bottom: number, top: number, zNear: number, zFar: number): Graphene.Matrix;
initIdentity(): Graphene.Matrix;
initLookAt(eye: Graphene.Vec3, center: Graphene.Vec3, up: Graphene.Vec3): Graphene.Matrix;
initOrtho(left: number, right: number, top: number, bottom: number, zNear: number, zFar: number): Graphene.Matrix;
initPerspective(fovy: number, aspect: number, zNear: number, zFar: number): Graphene.Matrix;
initRotate(angle: number, axis: Graphene.Vec3): Graphene.Matrix;
initScale(x: number, y: number, z: number): Graphene.Matrix;
initSkew(XSkew: number, YSkew: number): Graphene.Matrix;
initTranslate(p: Graphene.Point3D): Graphene.Matrix;
interpolate(b: Graphene.Matrix, factor: number, res: Graphene.Matrix): void;
inverse(res: Graphene.Matrix): boolean;
is2d(): boolean;
isBackfaceVisible(): boolean;
isIdentity(): boolean;
isSingular(): boolean;
multiply(b: Graphene.Matrix, res: Graphene.Matrix): void;
near(b: Graphene.Matrix, epsilon: number): boolean;
normalize(res: Graphene.Matrix): void;
perspective(depth: number, res: Graphene.Matrix): void;
print(): void;
projectPoint(p: Graphene.Point, res: Graphene.Point): void;
projectRect(r: Graphene.Rect, res: Graphene.Quad): void;
projectRectBounds(r: Graphene.Rect, res: Graphene.Rect): void;
rotate(angle: number, axis: Graphene.Vec3): void;
rotateEuler(e: Graphene.Euler): void;
rotateQuaternion(q: Graphene.Quaternion): void;
rotateX(angle: number): void;
rotateY(angle: number): void;
rotateZ(angle: number): void;
scale(factorX: number, factorY: number, factorZ: number): void;
skewXY(factor: number): void;
skewXZ(factor: number): void;
skewYZ(factor: number): void;
to2d(XX: number, YX: number, XY: number, YY: number, X0: number, Y0: number): boolean;
toFloat(v: number[]): void;
transformBounds(r: Graphene.Rect, res: Graphene.Rect): void;
transformBox(b: Graphene.Box, res: Graphene.Box): void;
transformPoint(p: Graphene.Point, res: Graphene.Point): void;
transformPoint3d(p: Graphene.Point3D, res: Graphene.Point3D): void;
transformRay(r: Graphene.Ray, res: Graphene.Ray): void;
transformRect(r: Graphene.Rect, res: Graphene.Quad): void;
transformSphere(s: Graphene.Sphere, res: Graphene.Sphere): void;
transformVec3(v: Graphene.Vec3, res: Graphene.Vec3): void;
transformVec4(v: Graphene.Vec4, res: Graphene.Vec4): void;
translate(pos: Graphene.Point3D): void;
transpose(res: Graphene.Matrix): void;
unprojectPoint3d(modelview: Graphene.Matrix, point: Graphene.Point3D, res: Graphene.Point3D): void;
untransformBounds(r: Graphene.Rect, bounds: Graphene.Rect, res: Graphene.Rect): void;
untransformPoint(p: Graphene.Point, bounds: Graphene.Rect, res: Graphene.Point): boolean;
}
class Plane {
normal : Graphene.Vec3;
constant : number;
static Alloc(): Graphene.Plane;
distance(point: Graphene.Point3D): number;
equal(b: Graphene.Plane): boolean;
free(): void;
getConstant(): number;
getNormal(normal: Graphene.Vec3): void;
init(normal: Graphene.Vec3 | undefined | null, constant: number): Graphene.Plane;
initFromPlane(src: Graphene.Plane): Graphene.Plane;
initFromPoint(normal: Graphene.Vec3, point: Graphene.Point3D): Graphene.Plane;
initFromPoints(a: Graphene.Point3D, b: Graphene.Point3D, c: Graphene.Point3D): Graphene.Plane;
initFromVec4(src: Graphene.Vec4): Graphene.Plane;
negate(res: Graphene.Plane): void;
normalize(res: Graphene.Plane): void;
transform(matrix: Graphene.Matrix, normalMatrix: Graphene.Matrix | undefined | null, res: Graphene.Plane): void;
}
class Point {
x : number;
y : number;
static Alloc(): Graphene.Point;
distance(b: Graphene.Point, dX ?: number, dY ?: number): number;
equal(b: Graphene.Point): boolean;
free(): void;
init(x: number, y: number): Graphene.Point;
initFromPoint(src: Graphene.Point): Graphene.Point;
initFromVec2(src: Graphene.Vec2): Graphene.Point;
interpolate(b: Graphene.Point, factor: number, res: Graphene.Point): void;
near(b: Graphene.Point, epsilon: number): boolean;
toVec2(v: Graphene.Vec2): void;
static Zero(): Graphene.Point;
}
class Point3D {
x : number;
y : number;
z : number;
static Alloc(): Graphene.Point3D;
cross(b: Graphene.Point3D, res: Graphene.Point3D): void;
distance(b: Graphene.Point3D, delta ?: Graphene.Vec3): number;
dot(b: Graphene.Point3D): number;
equal(b: Graphene.Point3D): boolean;
free(): void;
init(x: number, y: number, z: number): Graphene.Point3D;
initFromPoint(src: Graphene.Point3D): Graphene.Point3D;
initFromVec3(v: Graphene.Vec3): Graphene.Point3D;
interpolate(b: Graphene.Point3D, factor: number, res: Graphene.Point3D): void;
length(): number;
near(b: Graphene.Point3D, epsilon: number): boolean;
normalize(res: Graphene.Point3D): void;
normalizeViewport(viewport: Graphene.Rect, zNear: number, zFar: number, res: Graphene.Point3D): void;
scale(factor: number, res: Graphene.Point3D): void;
toVec3(v: Graphene.Vec3): void;
static Zero(): Graphene.Point3D;
}
class Quad {
points : Graphene.Point[];
static Alloc(): Graphene.Quad;
bounds(r: Graphene.Rect): void;
contains(p: Graphene.Point): boolean;
free(): void;
getPoint(index: number): Graphene.Point;
init(p1: Graphene.Point, p2: Graphene.Point, p3: Graphene.Point, p4: Graphene.Point): Graphene.Quad;
initFromPoints(points: Graphene.Point[]): Graphene.Quad;
initFromRect(r: Graphene.Rect): Graphene.Quad;
}
class Quaternion {
x : number;
y : number;
z : number;
w : number;
static Alloc(): Graphene.Quaternion;
add(b: Graphene.Quaternion, res: Graphene.Quaternion): void;
dot(b: Graphene.Quaternion): number;
equal(b: Graphene.Quaternion): boolean;
free(): void;
init(x: number, y: number, z: number, w: number): Graphene.Quaternion;
initFromAngleVec3(angle: number, axis: Graphene.Vec3): Graphene.Quaternion;
initFromAngles(degX: number, degY: number, degZ: number): Graphene.Quaternion;
initFromEuler(e: Graphene.Euler): Graphene.Quaternion;
initFromMatrix(m: Graphene.Matrix): Graphene.Quaternion;
initFromQuaternion(src: Graphene.Quaternion): Graphene.Quaternion;
initFromRadians(radX: number, radY: number, radZ: number): Graphene.Quaternion;
initFromVec4(src: Graphene.Vec4): Graphene.Quaternion;
initIdentity(): Graphene.Quaternion;
invert(res: Graphene.Quaternion): void;
multiply(b: Graphene.Quaternion, res: Graphene.Quaternion): void;
normalize(res: Graphene.Quaternion): void;
scale(factor: number, res: Graphene.Quaternion): void;
slerp(b: Graphene.Quaternion, factor: number, res: Graphene.Quaternion): void;
toAngleVec3(angle: number, axis: Graphene.Vec3): void;
toAngles(degX ?: number, degY ?: number, degZ ?: number): void;
toMatrix(m: Graphene.Matrix): void;
toRadians(radX ?: number, radY ?: number, radZ ?: number): void;
toVec4(res: Graphene.Vec4): void;
}
class Ray {
origin : Graphene.Vec3;
direction : Graphene.Vec3;
static Alloc(): Graphene.Ray;
equal(b: Graphene.Ray): boolean;
free(): void;
getClosestPointToPoint(p: Graphene.Point3D, res: Graphene.Point3D): void;
getDirection(direction: Graphene.Vec3): void;
getDistanceToPlane(p: Graphene.Plane): number;
getDistanceToPoint(p: Graphene.Point3D): number;
getOrigin(origin: Graphene.Point3D): void;
getPositionAt(t: number, position: Graphene.Point3D): void;
init(origin: Graphene.Point3D | undefined | null, direction: Graphene.Vec3 | undefined | null): Graphene.Ray;
initFromRay(src: Graphene.Ray): Graphene.Ray;
initFromVec3(origin: Graphene.Vec3 | undefined | null, direction: Graphene.Vec3 | undefined | null): Graphene.Ray;
intersectBox(b: Graphene.Box, tOut: number): Graphene.RayIntersectionKind;
intersectSphere(s: Graphene.Sphere, tOut: number): Graphene.RayIntersectionKind;
intersectTriangle(t: Graphene.Triangle, tOut: number): Graphene.RayIntersectionKind;
intersectsBox(b: Graphene.Box): boolean;
intersectsSphere(s: Graphene.Sphere): boolean;
intersectsTriangle(t: Graphene.Triangle): boolean;
}
class Rect {
origin : Graphene.Point;
size : Graphene.Size;
containsPoint(p: Graphene.Point): boolean;
containsRect(b: Graphene.Rect): boolean;
equal(b: Graphene.Rect): boolean;
expand(p: Graphene.Point, res: Graphene.Rect): void;
free(): void;
getArea(): number;
getBottomLeft(p: Graphene.Point): void;
getBottomRight(p: Graphene.Point): void;
getCenter(p: Graphene.Point): void;
getHeight(): number;
getTopLeft(p: Graphene.Point): void;
getTopRight(p: Graphene.Point): void;
getVertices(vertices: Graphene.Vec2[]): void;
getWidth(): number;
getX(): number;
getY(): number;
init(x: number, y: number, width: number, height: number): Graphene.Rect;
initFromRect(src: Graphene.Rect): Graphene.Rect;
inset(dX: number, dY: number): Graphene.Rect;
insetR(dX: number, dY: number, res: Graphene.Rect): void;
interpolate(b: Graphene.Rect, factor: number, res: Graphene.Rect): void;
intersection(b: Graphene.Rect, res ?: Graphene.Rect): boolean;
normalize(): Graphene.Rect;
normalizeR(res: Graphene.Rect): void;
offset(dX: number, dY: number): Graphene.Rect;
offsetR(dX: number, dY: number, res: Graphene.Rect): void;
round(res: Graphene.Rect): void;
roundExtents(res: Graphene.Rect): void;
roundToPixel(): Graphene.Rect;
scale(sH: number, sV: number, res: Graphene.Rect): void;
union(b: Graphene.Rect, res: Graphene.Rect): void;
static Alloc(): Graphene.Rect;
static Zero(): Graphene.Rect;
}
class Simd4F {
x : number;
y : number;
z : number;
w : number;
}
class Simd4X4F {
x : Graphene.Simd4F;
y : Graphene.Simd4F;
z : Graphene.Simd4F;
w : Graphene.Simd4F;
}
class Size {
width : number;
height : number;
static Alloc(): Graphene.Size;
equal(b: Graphene.Size): boolean;
free(): void;
init(width: number, height: number): Graphene.Size;
initFromSize(src: Graphene.Size): Graphene.Size;
interpolate(b: Graphene.Size, factor: number, res: Graphene.Size): void;
scale(factor: number, res: Graphene.Size): void;
static Zero(): Graphene.Size;
}
class Sphere {
center : Graphene.Vec3;
radius : number;
static Alloc(): Graphene.Sphere;
containsPoint(point: Graphene.Point3D): boolean;
distance(point: Graphene.Point3D): number;
equal(b: Graphene.Sphere): boolean;
free(): void;
getBoundingBox(box: Graphene.Box): void;
getCenter(center: Graphene.Point3D): void;
getRadius(): number;
init(center: Graphene.Point3D | undefined | null, radius: number): Graphene.Sphere;
initFromPoints(nPoints: number, points: Graphene.Point3D[], center: Graphene.Point3D | undefined | null): Graphene.Sphere;
initFromVectors(nVectors: number, vectors: Graphene.Vec3[], center: Graphene.Point3D | undefined | null): Graphene.Sphere;
isEmpty(): boolean;
translate(point: Graphene.Point3D, res: Graphene.Sphere): void;
}
class Triangle {
a : Graphene.Vec3;
b : Graphene.Vec3;
c : Graphene.Vec3;
static Alloc(): Graphene.Triangle;
containsPoint(p: Graphene.Point3D): boolean;
equal(b: Graphene.Triangle): boolean;
free(): void;
getArea(): number;
getBarycoords(p: Graphene.Point3D | undefined | null, res: Graphene.Vec2): boolean;
getBoundingBox(res: Graphene.Box): void;
getMidpoint(res: Graphene.Point3D): void;
getNormal(res: Graphene.Vec3): void;
getPlane(res: Graphene.Plane): void;
getPoints(a ?: Graphene.Point3D, b ?: Graphene.Point3D, c ?: Graphene.Point3D): void;
getUv(p: Graphene.Point3D | undefined | null, uvA: Graphene.Vec2, uvB: Graphene.Vec2, uvC: Graphene.Vec2, res: Graphene.Vec2): boolean;
getVertices(a ?: Graphene.Vec3, b ?: Graphene.Vec3, c ?: Graphene.Vec3): void;
initFromFloat(a: number[], b: number[], c: number[]): Graphene.Triangle;
initFromPoint3d(a: Graphene.Point3D | undefined | null, b: Graphene.Point3D | undefined | null, c: Graphene.Point3D | undefined | null): Graphene.Triangle;
initFromVec3(a: Graphene.Vec3 | undefined | null, b: Graphene.Vec3 | undefined | null, c: Graphene.Vec3 | undefined | null): Graphene.Triangle;
}
class Vec2 {
value : Graphene.Simd4F;
static Alloc(): Graphene.Vec2;
add(b: Graphene.Vec2, res: Graphene.Vec2): void;
divide(b: Graphene.Vec2, res: Graphene.Vec2): void;
dot(b: Graphene.Vec2): number;
equal(v2: Graphene.Vec2): boolean;
free(): void;
getX(): number;
getY(): number;
init(x: number, y: number): Graphene.Vec2;
initFromFloat(src: number[]): Graphene.Vec2;
initFromVec2(src: Graphene.Vec2): Graphene.Vec2;
interpolate(v2: Graphene.Vec2, factor: number, res: Graphene.Vec2): void;
length(): number;
max(b: Graphene.Vec2, res: Graphene.Vec2): void;
min(b: Graphene.Vec2, res: Graphene.Vec2): void;
multiply(b: Graphene.Vec2, res: Graphene.Vec2): void;
near(v2: Graphene.Vec2, epsilon: number): boolean;
negate(res: Graphene.Vec2): void;
normalize(res: Graphene.Vec2): void;
scale(factor: number, res: Graphene.Vec2): void;
subtract(b: Graphene.Vec2, res: Graphene.Vec2): void;
toFloat(dest: number[]): void;
static One(): Graphene.Vec2;
static XAxis(): Graphene.Vec2;
static YAxis(): Graphene.Vec2;
static Zero(): Graphene.Vec2;
}
class Vec3 {
value : Graphene.Simd4F;
static Alloc(): Graphene.Vec3;
add(b: Graphene.Vec3, res: Graphene.Vec3): void;
cross(b: Graphene.Vec3, res: Graphene.Vec3): void;
divide(b: Graphene.Vec3, res: Graphene.Vec3): void;
dot(b: Graphene.Vec3): number;
equal(v2: Graphene.Vec3): boolean;
free(): void;
getX(): number;
getXY(res: Graphene.Vec2): void;
getXY0(res: Graphene.Vec3): void;
getXYz0(res: Graphene.Vec4): void;
getXYz1(res: Graphene.Vec4): void;
getXYzw(w: number, res: Graphene.Vec4): void;
getY(): number;
getZ(): number;
init(x: number, y: number, z: number): Graphene.Vec3;
initFromFloat(src: number[]): Graphene.Vec3;
initFromVec3(src: Graphene.Vec3): Graphene.Vec3;
interpolate(v2: Graphene.Vec3, factor: number, res: Graphene.Vec3): void;
length(): number;
max(b: Graphene.Vec3, res: Graphene.Vec3): void;
min(b: Graphene.Vec3, res: Graphene.Vec3): void;
multiply(b: Graphene.Vec3, res: Graphene.Vec3): void;
near(v2: Graphene.Vec3, epsilon: number): boolean;
negate(res: Graphene.Vec3): void;
normalize(res: Graphene.Vec3): void;
scale(factor: number, res: Graphene.Vec3): void;
subtract(b: Graphene.Vec3, res: Graphene.Vec3): void;
toFloat(dest: number[]): void;
static One(): Graphene.Vec3;
static XAxis(): Graphene.Vec3;
static YAxis(): Graphene.Vec3;
static ZAxis(): Graphene.Vec3;
static Zero(): Graphene.Vec3;
}
class Vec4 {
value : Graphene.Simd4F;
static Alloc(): Graphene.Vec4;
add(b: Graphene.Vec4, res: Graphene.Vec4): void;
divide(b: Graphene.Vec4, res: Graphene.Vec4): void;
dot(b: Graphene.Vec4): number;
equal(v2: Graphene.Vec4): boolean;
free(): void;
getW(): number;
getX(): number;
getXY(res: Graphene.Vec2): void;
getXYz(res: Graphene.Vec3): void;
getY(): number;
getZ(): number;
init(x: number, y: number, z: number, w: number): Graphene.Vec4;
initFromFloat(src: number[]): Graphene.Vec4;
initFromVec2(src: Graphene.Vec2, z: number, w: number): Graphene.Vec4;
initFromVec3(src: Graphene.Vec3, w: number): Graphene.Vec4;
initFromVec4(src: Graphene.Vec4): Graphene.Vec4;
interpolate(v2: Graphene.Vec4, factor: number, res: Graphene.Vec4): void;
length(): number;
max(b: Graphene.Vec4, res: Graphene.Vec4): void;
min(b: Graphene.Vec4, res: Graphene.Vec4): void;
multiply(b: Graphene.Vec4, res: Graphene.Vec4): void;
near(v2: Graphene.Vec4, epsilon: number): boolean;
negate(res: Graphene.Vec4): void;
normalize(res: Graphene.Vec4): void;
scale(factor: number, res: Graphene.Vec4): void;
subtract(b: Graphene.Vec4, res: Graphene.Vec4): void;
toFloat(dest: number[]): void;
static One(): Graphene.Vec4;
static WAxis(): Graphene.Vec4;
static XAxis(): Graphene.Vec4;
static YAxis(): Graphene.Vec4;
static ZAxis(): Graphene.Vec4;
static Zero(): Graphene.Vec4;
}
}

712
Gsk.d.ts vendored Normal file
View File

@ -0,0 +1,712 @@
declare namespace Gsk {
class BlendMode {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kDefault": BlendMode
static readonly "kMultiply": BlendMode
static readonly "kScreen": BlendMode
static readonly "kOverlay": BlendMode
static readonly "kDarken": BlendMode
static readonly "kLighten": BlendMode
static readonly "kColorDodge": BlendMode
static readonly "kColorBurn": BlendMode
static readonly "kHardLight": BlendMode
static readonly "kSoftLight": BlendMode
static readonly "kDifference": BlendMode
static readonly "kExclusion": BlendMode
static readonly "kColor": BlendMode
static readonly "kHue": BlendMode
static readonly "kSaturation": BlendMode
static readonly "kLuminosity": BlendMode
}
class Corner {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kTopLeft": Corner
static readonly "kTopRight": Corner
static readonly "kBottomRight": Corner
static readonly "kBottomLeft": Corner
}
class GLUniformType {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kNone": GLUniformType
static readonly "kFloat": GLUniformType
static readonly "kInt": GLUniformType
static readonly "kUint": GLUniformType
static readonly "kBool": GLUniformType
static readonly "kVec2": GLUniformType
static readonly "kVec3": GLUniformType
static readonly "kVec4": GLUniformType
}
class RenderNodeType {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kNotARenderNode": RenderNodeType
static readonly "kContainerNode": RenderNodeType
static readonly "kCairoNode": RenderNodeType
static readonly "kColorNode": RenderNodeType
static readonly "kLinearGradientNode": RenderNodeType
static readonly "kRepeatingLinearGradientNode": RenderNodeType
static readonly "kRadialGradientNode": RenderNodeType
static readonly "kRepeatingRadialGradientNode": RenderNodeType
static readonly "kConicGradientNode": RenderNodeType
static readonly "kBorderNode": RenderNodeType
static readonly "kTextureNode": RenderNodeType
static readonly "kTextureScaleNode": RenderNodeType
static readonly "kInsetShadowNode": RenderNodeType
static readonly "kOutsetShadowNode": RenderNodeType
static readonly "kTransformNode": RenderNodeType
static readonly "kOpacityNode": RenderNodeType
static readonly "kColorMatrixNode": RenderNodeType
static readonly "kRepeatNode": RenderNodeType
static readonly "kClipNode": RenderNodeType
static readonly "kRoundedClipNode": RenderNodeType
static readonly "kShadowNode": RenderNodeType
static readonly "kBlendNode": RenderNodeType
static readonly "kMaskNode": RenderNodeType
static readonly "kCrossFadeNode": RenderNodeType
static readonly "kTextNode": RenderNodeType
static readonly "kBlurNode": RenderNodeType
static readonly "kDebugNode": RenderNodeType
static readonly "kGlShaderNode": RenderNodeType
}
class ScalingFilter {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kLinear": ScalingFilter
static readonly "kNearest": ScalingFilter
static readonly "kTrilinear": ScalingFilter
}
class SerializationError {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kUnsupportedFormat": SerializationError
static readonly "kUnsupportedVersion": SerializationError
static readonly "kInvalidData": SerializationError
}
class TransformCategory {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kUnknown": TransformCategory
static readonly "kAny": TransformCategory
static readonly "k3d": TransformCategory
static readonly "k2d": TransformCategory
static readonly "k2dAffine": TransformCategory
static readonly "k2dTranslate": TransformCategory
static readonly "kIdentity": TransformCategory
}
class CairoRendererClass {
}
class ColorStop {
offset : number;
color : AuGDK.RGBA;
}
class GLRendererClass {
}
class GLShaderClass {
parentClass : GObject.ObjectClass;
}
class ParseLocation {
bytes : number | bigint;
chars : number | bigint;
lines : number | bigint;
lineBytes : number | bigint;
lineChars : number | bigint;
}
class RendererClass {
}
class RoundedRect {
bounds : Graphene.Rect;
corner : Graphene.Size[];
containsPoint(point: Graphene.Point): boolean;
containsRect(rect: Graphene.Rect): boolean;
init(bounds: Graphene.Rect, topLeft: Graphene.Size, topRight: Graphene.Size, bottomRight: Graphene.Size, bottomLeft: Graphene.Size): Gsk.RoundedRect;
initCopy(src: Gsk.RoundedRect): Gsk.RoundedRect;
initFromRect(bounds: Graphene.Rect, radius: number): Gsk.RoundedRect;
intersectsRect(rect: Graphene.Rect): boolean;
isRectilinear(): boolean;
normalize(): Gsk.RoundedRect;
offset(dx: number, dy: number): Gsk.RoundedRect;
shrink(top: number, right: number, bottom: number, left: number): Gsk.RoundedRect;
}
class ShaderArgsBuilder {
static New(shader: Gsk.GLShader, initialValues: AuGlibEx.Bytes | undefined | null): Gsk.ShaderArgsBuilder;
ref(): Gsk.ShaderArgsBuilder;
setBool(idx: number, value: boolean): void;
setFloat(idx: number, value: number): void;
setInt(idx: number, value: number): void;
setUint(idx: number, value: number): void;
setVec2(idx: number, value: Graphene.Vec2): void;
setVec3(idx: number, value: Graphene.Vec3): void;
setVec4(idx: number, value: Graphene.Vec4): void;
toArgs(): AuGlibEx.Bytes;
unref(): void;
}
class Shadow {
color : AuGDK.RGBA;
dx : number;
dy : number;
radius : number;
}
class Transform {
static New(): Gsk.Transform;
equal(second: Gsk.Transform | undefined | null): boolean;
getCategory(): Gsk.TransformCategory;
invert(): Gsk.Transform;
matrix(matrix: Graphene.Matrix): Gsk.Transform;
perspective(depth: number): Gsk.Transform;
print(string: AuGlibEx.String): void;
ref(): Gsk.Transform;
rotate(angle: number): Gsk.Transform;
rotate3d(angle: number, axis: Graphene.Vec3): Gsk.Transform;
scale(factorX: number, factorY: number): Gsk.Transform;
scale3d(factorX: number, factorY: number, factorZ: number): Gsk.Transform;
skew(skewX: number, skewY: number): Gsk.Transform;
to2d(outXX: number, outYX: number, outXY: number, outYY: number, outDx: number, outDy: number): void;
to2dComponents(outSkewX: number, outSkewY: number, outScaleX: number, outScaleY: number, outAngle: number, outDx: number, outDy: number): void;
toAffine(outScaleX: number, outScaleY: number, outDx: number, outDy: number): void;
toMatrix(outMatrix: Graphene.Matrix): void;
toTranslate(outDx: number, outDy: number): void;
transform(other: Gsk.Transform | undefined | null): Gsk.Transform;
transformBounds(rect: Graphene.Rect, outRect: Graphene.Rect): void;
transformPoint(point: Graphene.Point, outPoint: Graphene.Point): void;
translate(point: Graphene.Point): Gsk.Transform;
translate3d(point: Graphene.Point3D): Gsk.Transform;
unref(): void;
static Parse(string: string, outTransform: Gsk.Transform): boolean;
}
class BlendNode extends Gsk.RenderNode {
constructor(initializerList ?: BlendNodeCtor);
static New(bottom: Gsk.RenderNode, top: Gsk.RenderNode, blendMode: Gsk.BlendMode): Gsk.BlendNode;
getBlendMode(): Gsk.BlendMode;
getBottomChild(): Gsk.RenderNode;
getTopChild(): Gsk.RenderNode;
//TypeScript is complete garbage:
}
class BlendNodeCtor {
}
class BlurNode extends Gsk.RenderNode {
constructor(initializerList ?: BlurNodeCtor);
static New(child: Gsk.RenderNode, radius: number): Gsk.BlurNode;
getChild(): Gsk.RenderNode;
getRadius(): number;
//TypeScript is complete garbage:
}
class BlurNodeCtor {
}
class BorderNode extends Gsk.RenderNode {
constructor(initializerList ?: BorderNodeCtor);
static New(outline: Gsk.RoundedRect, borderWidth: number[], borderColor: AuGDK.RGBA[]): Gsk.BorderNode;
getColors(): AuGDK.RGBA;
getOutline(): Gsk.RoundedRect;
getWidths(): number[];
//TypeScript is complete garbage:
}
class BorderNodeCtor {
}
class CairoNode extends Gsk.RenderNode {
constructor(initializerList ?: CairoNodeCtor);
static New(bounds: Graphene.Rect): Gsk.CairoNode;
getDrawContext(): cairo.Context;
getSurface(): cairo.Surface;
//TypeScript is complete garbage:
}
class CairoNodeCtor {
}
class CairoRenderer extends Gsk.Renderer {
constructor(initializerList ?: CairoRendererCtor);
static New(): Gsk.Renderer;
//TypeScript is complete garbage:
}
class CairoRendererCtor {
realized ?: boolean;
surface ?: AuGDK.Surface;
}
class ClipNode extends Gsk.RenderNode {
constructor(initializerList ?: ClipNodeCtor);
static New(child: Gsk.RenderNode, clip: Graphene.Rect): Gsk.ClipNode;
getChild(): Gsk.RenderNode;
getClip(): Graphene.Rect;
//TypeScript is complete garbage:
}
class ClipNodeCtor {
}
class ColorMatrixNode extends Gsk.RenderNode {
constructor(initializerList ?: ColorMatrixNodeCtor);
static New(child: Gsk.RenderNode, colorMatrix: Graphene.Matrix, colorOffset: Graphene.Vec4): Gsk.ColorMatrixNode;
getChild(): Gsk.RenderNode;
getColorMatrix(): Graphene.Matrix;
getColorOffset(): Graphene.Vec4;
//TypeScript is complete garbage:
}
class ColorMatrixNodeCtor {
}
class ColorNode extends Gsk.RenderNode {
constructor(initializerList ?: ColorNodeCtor);
static New(rgba: AuGDK.RGBA, bounds: Graphene.Rect): Gsk.ColorNode;
getColor(): AuGDK.RGBA;
//TypeScript is complete garbage:
}
class ColorNodeCtor {
}
class ConicGradientNode extends Gsk.RenderNode {
constructor(initializerList ?: ConicGradientNodeCtor);
static New(bounds: Graphene.Rect, center: Graphene.Point, rotation: number, colorStops: Gsk.ColorStop[], nColorStops: number | bigint): Gsk.ConicGradientNode;
getAngle(): number;
getCenter(): Graphene.Point;
getColorStops(nStops ?: number | bigint): Gsk.ColorStop[];
getNColorStops(): number | bigint;
getRotation(): number;
//TypeScript is complete garbage:
}
class ConicGradientNodeCtor {
}
class ContainerNode extends Gsk.RenderNode {
constructor(initializerList ?: ContainerNodeCtor);
static New(children: Gsk.RenderNode[], nChildren: number): Gsk.ContainerNode;
getChild(idx: number): Gsk.RenderNode;
getNChildren(): number;
//TypeScript is complete garbage:
}
class ContainerNodeCtor {
}
class CrossFadeNode extends Gsk.RenderNode {
constructor(initializerList ?: CrossFadeNodeCtor);
static New(start: Gsk.RenderNode, end: Gsk.RenderNode, progress: number): Gsk.CrossFadeNode;
getEndChild(): Gsk.RenderNode;
getProgress(): number;
getStartChild(): Gsk.RenderNode;
//TypeScript is complete garbage:
}
class CrossFadeNodeCtor {
}
class DebugNode extends Gsk.RenderNode {
constructor(initializerList ?: DebugNodeCtor);
static New(child: Gsk.RenderNode, message: string): Gsk.DebugNode;
getChild(): Gsk.RenderNode;
getMessage(): string;
//TypeScript is complete garbage:
}
class DebugNodeCtor {
}
class GLRenderer extends Gsk.Renderer {
constructor(initializerList ?: GLRendererCtor);
static New(): Gsk.Renderer;
//TypeScript is complete garbage:
}
class GLRendererCtor {
realized ?: boolean;
surface ?: AuGDK.Surface;
}
class GLShader extends GObject.Object {
constructor(initializerList ?: GLShaderCtor);
resource : string;
source : AuGlibEx.Bytes;
static NewFromBytes(sourcecode: AuGlibEx.Bytes): Gsk.GLShader;
static NewFromResource(resourcePath: string): Gsk.GLShader;
compile(renderer: Gsk.Renderer): boolean;
findUniformByName(name: string): number;
getArgBool(args: AuGlibEx.Bytes, idx: number): boolean;
getArgFloat(args: AuGlibEx.Bytes, idx: number): number;
getArgInt(args: AuGlibEx.Bytes, idx: number): number;
getArgUint(args: AuGlibEx.Bytes, idx: number): number;
getArgVec2(args: AuGlibEx.Bytes, idx: number, outValue: Graphene.Vec2): void;
getArgVec3(args: AuGlibEx.Bytes, idx: number, outValue: Graphene.Vec3): void;
getArgVec4(args: AuGlibEx.Bytes, idx: number, outValue: Graphene.Vec4): void;
getArgsSize(): number | bigint;
getNTextures(): number;
getNUniforms(): number;
getResource(): string;
getSource(): AuGlibEx.Bytes;
getUniformName(idx: number): string;
getUniformOffset(idx: number): number;
getUniformType(idx: number): Gsk.GLUniformType;
//TypeScript is complete garbage:
}
class GLShaderCtor {
source ?: AuGlibEx.Bytes;
resource ?: string;
}
class GLShaderNode extends Gsk.RenderNode {
constructor(initializerList ?: GLShaderNodeCtor);
static New(shader: Gsk.GLShader, bounds: Graphene.Rect, args: AuGlibEx.Bytes, children: Gsk.RenderNode[] | undefined | null, nChildren: number): Gsk.GLShaderNode;
getArgs(): AuGlibEx.Bytes;
getChild(idx: number): Gsk.RenderNode;
getNChildren(): number;
getShader(): Gsk.GLShader;
//TypeScript is complete garbage:
}
class GLShaderNodeCtor {
}
class InsetShadowNode extends Gsk.RenderNode {
constructor(initializerList ?: InsetShadowNodeCtor);
static New(outline: Gsk.RoundedRect, color: AuGDK.RGBA, dx: number, dy: number, spread: number, blurRadius: number): Gsk.InsetShadowNode;
getBlurRadius(): number;
getColor(): AuGDK.RGBA;
getDx(): number;
getDy(): number;
getOutline(): Gsk.RoundedRect;
getSpread(): number;
//TypeScript is complete garbage:
}
class InsetShadowNodeCtor {
}
class LinearGradientNode extends Gsk.RenderNode {
constructor(initializerList ?: LinearGradientNodeCtor);
static New(bounds: Graphene.Rect, start: Graphene.Point, end: Graphene.Point, colorStops: Gsk.ColorStop[], nColorStops: number | bigint): Gsk.LinearGradientNode;
getColorStops(nStops ?: number | bigint): Gsk.ColorStop[];
getEnd(): Graphene.Point;
getNColorStops(): number | bigint;
getStart(): Graphene.Point;
//TypeScript is complete garbage:
}
class LinearGradientNodeCtor {
}
class MaskNode extends Gsk.RenderNode {
constructor(initializerList ?: MaskNodeCtor);
static New(source: Gsk.RenderNode, mask: Gsk.RenderNode): Gsk.MaskNode;
static GetMask(node: Gsk.BlendNode): Gsk.RenderNode;
static GetSource(node: Gsk.BlendNode): Gsk.RenderNode;
//TypeScript is complete garbage:
}
class MaskNodeCtor {
}
class NglRenderer extends Gsk.Renderer {
constructor(initializerList ?: NglRendererCtor);
static New(): Gsk.Renderer;
//TypeScript is complete garbage:
}
class NglRendererCtor {
realized ?: boolean;
surface ?: AuGDK.Surface;
}
class OpacityNode extends Gsk.RenderNode {
constructor(initializerList ?: OpacityNodeCtor);
static New(child: Gsk.RenderNode, opacity: number): Gsk.OpacityNode;
getChild(): Gsk.RenderNode;
getOpacity(): number;
//TypeScript is complete garbage:
}
class OpacityNodeCtor {
}
class OutsetShadowNode extends Gsk.RenderNode {
constructor(initializerList ?: OutsetShadowNodeCtor);
static New(outline: Gsk.RoundedRect, color: AuGDK.RGBA, dx: number, dy: number, spread: number, blurRadius: number): Gsk.OutsetShadowNode;
getBlurRadius(): number;
getColor(): AuGDK.RGBA;
getDx(): number;
getDy(): number;
getOutline(): Gsk.RoundedRect;
getSpread(): number;
//TypeScript is complete garbage:
}
class OutsetShadowNodeCtor {
}
class RadialGradientNode extends Gsk.RenderNode {
constructor(initializerList ?: RadialGradientNodeCtor);
static New(bounds: Graphene.Rect, center: Graphene.Point, hradius: number, vradius: number, start: number, end: number, colorStops: Gsk.ColorStop[], nColorStops: number | bigint): Gsk.RadialGradientNode;
getCenter(): Graphene.Point;
getColorStops(nStops ?: number | bigint): Gsk.ColorStop[];
getEnd(): number;
getHradius(): number;
getNColorStops(): number | bigint;
getStart(): number;
getVradius(): number;
//TypeScript is complete garbage:
}
class RadialGradientNodeCtor {
}
class RenderNode {
constructor(initializerList ?: RenderNodeCtor);
static Deserialize(bytes: AuGlibEx.Bytes, errorFunc: (start: Gsk.ParseLocation, end: Gsk.ParseLocation, error: AuGlibEx.Error) => void | undefined | null): Gsk.RenderNode;
draw(cr: cairo.Context): void;
getBounds(bounds: Graphene.Rect): void;
getNodeType(): Gsk.RenderNodeType;
ref(): Gsk.RenderNode;
serialize(): AuGlibEx.Bytes;
unref(): void;
writeToFile(filename: string): boolean;
//TypeScript is complete garbage:
}
class RenderNodeCtor {
}
class Renderer extends GObject.Object {
constructor(initializerList ?: RendererCtor);
realized : boolean;
surface : AuGDK.Surface;
static NewForSurface(surface: AuGDK.Surface): Gsk.Renderer;
getSurface(): AuGDK.Surface;
isRealized(): boolean;
realize(surface: AuGDK.Surface | undefined | null): boolean;
render(root: Gsk.RenderNode, region: cairo.Region | undefined | null): void;
renderTexture(root: Gsk.RenderNode, viewport: Graphene.Rect | undefined | null): AuGDK.Texture;
unrealize(): void;
//TypeScript is complete garbage:
}
class RendererCtor {
realized ?: boolean;
surface ?: AuGDK.Surface;
}
class RepeatNode extends Gsk.RenderNode {
constructor(initializerList ?: RepeatNodeCtor);
static New(bounds: Graphene.Rect, child: Gsk.RenderNode, childBounds: Graphene.Rect | undefined | null): Gsk.RepeatNode;
getChild(): Gsk.RenderNode;
getChildBounds(): Graphene.Rect;
//TypeScript is complete garbage:
}
class RepeatNodeCtor {
}
class RepeatingLinearGradientNode extends Gsk.RenderNode {
constructor(initializerList ?: RepeatingLinearGradientNodeCtor);
static New(bounds: Graphene.Rect, start: Graphene.Point, end: Graphene.Point, colorStops: Gsk.ColorStop[], nColorStops: number | bigint): Gsk.RepeatingLinearGradientNode;
//TypeScript is complete garbage:
}
class RepeatingLinearGradientNodeCtor {
}
class RepeatingRadialGradientNode extends Gsk.RenderNode {
constructor(initializerList ?: RepeatingRadialGradientNodeCtor);
static New(bounds: Graphene.Rect, center: Graphene.Point, hradius: number, vradius: number, start: number, end: number, colorStops: Gsk.ColorStop[], nColorStops: number | bigint): Gsk.RepeatingRadialGradientNode;
//TypeScript is complete garbage:
}
class RepeatingRadialGradientNodeCtor {
}
class RoundedClipNode extends Gsk.RenderNode {
constructor(initializerList ?: RoundedClipNodeCtor);
static New(child: Gsk.RenderNode, clip: Gsk.RoundedRect): Gsk.RoundedClipNode;
getChild(): Gsk.RenderNode;
getClip(): Gsk.RoundedRect;
//TypeScript is complete garbage:
}
class RoundedClipNodeCtor {
}
class ShadowNode extends Gsk.RenderNode {
constructor(initializerList ?: ShadowNodeCtor);
static New(child: Gsk.RenderNode, shadows: Gsk.Shadow[], nShadows: number | bigint): Gsk.ShadowNode;
getChild(): Gsk.RenderNode;
getNShadows(): number | bigint;
getShadow(i: number | bigint): Gsk.Shadow;
//TypeScript is complete garbage:
}
class ShadowNodeCtor {
}
class TextNode extends Gsk.RenderNode {
constructor(initializerList ?: TextNodeCtor);
static New(font: AuPango.Font, glyphs: AuPango.GlyphString, color: AuGDK.RGBA, offset: Graphene.Point): Gsk.TextNode;
getColor(): AuGDK.RGBA;
getFont(): AuPango.Font;
getGlyphs(nGlyphs ?: number): AuPango.GlyphInfo[];
getNumGlyphs(): number;
getOffset(): Graphene.Point;
hasColorGlyphs(): boolean;
//TypeScript is complete garbage:
}
class TextNodeCtor {
}
class TextureNode extends Gsk.RenderNode {
constructor(initializerList ?: TextureNodeCtor);
static New(texture: AuGDK.Texture, bounds: Graphene.Rect): Gsk.TextureNode;
getTexture(): AuGDK.Texture;
//TypeScript is complete garbage:
}
class TextureNodeCtor {
}
class TextureScaleNode extends Gsk.RenderNode {
constructor(initializerList ?: TextureScaleNodeCtor);
static New(texture: AuGDK.Texture, bounds: Graphene.Rect, filter: Gsk.ScalingFilter): Gsk.TextureScaleNode;
static GetFilter(node: Gsk.TextureNode): Gsk.ScalingFilter;
static GetTexture(node: Gsk.TextureNode): AuGDK.Texture;
//TypeScript is complete garbage:
}
class TextureScaleNodeCtor {
}
class TransformNode extends Gsk.RenderNode {
constructor(initializerList ?: TransformNodeCtor);
static New(child: Gsk.RenderNode, transform: Gsk.Transform): Gsk.TransformNode;
getChild(): Gsk.RenderNode;
getTransform(): Gsk.Transform;
//TypeScript is complete garbage:
}
class TransformNodeCtor {
}
}

4343
Gst.d.ts vendored Normal file

File diff suppressed because it is too large Load Diff

864
GstBase.d.ts vendored Normal file
View File

@ -0,0 +1,864 @@
declare namespace GstBase {
class AggregatorStartTimeSelection {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kZero": AggregatorStartTimeSelection
static readonly "kFirst": AggregatorStartTimeSelection
static readonly "kSet": AggregatorStartTimeSelection
}
class BaseParseFrameFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kNone": BaseParseFrameFlags
static readonly "kNewFrame": BaseParseFrameFlags
static readonly "kNoFrame": BaseParseFrameFlags
static readonly "kClip": BaseParseFrameFlags
static readonly "kDrop": BaseParseFrameFlags
static readonly "kQueue": BaseParseFrameFlags
}
class BaseSrcFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kStarting": BaseSrcFlags
static readonly "kStarted": BaseSrcFlags
static readonly "kLast": BaseSrcFlags
}
class CollectPadsStateFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kEos": CollectPadsStateFlags
static readonly "kFlushing": CollectPadsStateFlags
static readonly "kNewSegment": CollectPadsStateFlags
static readonly "kWaiting": CollectPadsStateFlags
static readonly "kLocked": CollectPadsStateFlags
}
class AdapterClass {
}
class AggregatorClass {
parentClass : Gst.ElementClass;
flush : (aggregator: GstBase.Aggregator) => Gst.FlowReturn;
clip : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, buf: Gst.Buffer) => Gst.Buffer;
finishBuffer : (aggregator: GstBase.Aggregator, buffer: Gst.Buffer) => Gst.FlowReturn;
sinkEvent : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, event: Gst.Event) => boolean;
sinkQuery : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, query: Gst.Query) => boolean;
srcEvent : (aggregator: GstBase.Aggregator, event: Gst.Event) => boolean;
srcQuery : (aggregator: GstBase.Aggregator, query: Gst.Query) => boolean;
srcActivate : (aggregator: GstBase.Aggregator, mode: Gst.PadMode, active: boolean) => boolean;
aggregate : (aggregator: GstBase.Aggregator, timeout: boolean) => Gst.FlowReturn;
stop : (aggregator: GstBase.Aggregator) => boolean;
start : (aggregator: GstBase.Aggregator) => boolean;
getNextTime : (aggregator: GstBase.Aggregator) => number | bigint;
createNewPad : void;
updateSrcCaps : (self: GstBase.Aggregator, caps: Gst.Caps, ret ?: Gst.Caps) => Gst.FlowReturn;
fixateSrcCaps : (self: GstBase.Aggregator, caps: Gst.Caps) => Gst.Caps;
negotiatedSrcCaps : (self: GstBase.Aggregator, caps: Gst.Caps) => boolean;
decideAllocation : (self: GstBase.Aggregator, query: Gst.Query) => boolean;
proposeAllocation : (self: GstBase.Aggregator, pad: GstBase.AggregatorPad, decideQuery: Gst.Query, query: Gst.Query) => boolean;
negotiate : (self: GstBase.Aggregator) => boolean;
sinkEventPreQueue : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, event: Gst.Event) => Gst.FlowReturn;
sinkQueryPreQueue : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, query: Gst.Query) => boolean;
finishBufferList : (aggregator: GstBase.Aggregator, bufferlist: Gst.BufferList) => Gst.FlowReturn;
peekNextSample : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad) => Gst.Sample;
}
class AggregatorPadClass {
parentClass : Gst.PadClass;
flush : (aggpad: GstBase.AggregatorPad, aggregator: GstBase.Aggregator) => Gst.FlowReturn;
skipBuffer : (aggpad: GstBase.AggregatorPad, aggregator: GstBase.Aggregator, buffer: Gst.Buffer) => boolean;
}
class AggregatorPadPrivate {
}
class AggregatorPrivate {
}
class BaseParseClass {
parentClass : Gst.ElementClass;
start : (parse: GstBase.BaseParse) => boolean;
stop : (parse: GstBase.BaseParse) => boolean;
setSinkCaps : (parse: GstBase.BaseParse, caps: Gst.Caps) => boolean;
handleFrame : (parse: GstBase.BaseParse, frame: GstBase.BaseParseFrame, skipsize: number) => Gst.FlowReturn;
prePushFrame : (parse: GstBase.BaseParse, frame: GstBase.BaseParseFrame) => Gst.FlowReturn;
convert : (parse: GstBase.BaseParse, srcFormat: Gst.Format, srcValue: number | bigint, destFormat: Gst.Format, destValue: number | bigint) => boolean;
sinkEvent : (parse: GstBase.BaseParse, event: Gst.Event) => boolean;
srcEvent : (parse: GstBase.BaseParse, event: Gst.Event) => boolean;
getSinkCaps : (parse: GstBase.BaseParse, filter: Gst.Caps) => Gst.Caps;
detect : (parse: GstBase.BaseParse, buffer: Gst.Buffer) => Gst.FlowReturn;
sinkQuery : (parse: GstBase.BaseParse, query: Gst.Query) => boolean;
srcQuery : (parse: GstBase.BaseParse, query: Gst.Query) => boolean;
}
class BaseParseFrame {
buffer : Gst.Buffer;
outBuffer : Gst.Buffer;
flags : number;
offset : number | bigint;
overhead : number;
size : number;
gstReservedI : number[];
privateFlags : number;
static New(buffer: Gst.Buffer, flags: GstBase.BaseParseFrameFlags, overhead: number): GstBase.BaseParseFrame;
copy(): GstBase.BaseParseFrame;
free(): void;
init(): void;
}
class BaseParsePrivate {
}
class BaseSinkClass {
parentClass : Gst.ElementClass;
getCaps : (sink: GstBase.BaseSink, filter: Gst.Caps) => Gst.Caps;
setCaps : (sink: GstBase.BaseSink, caps: Gst.Caps) => boolean;
fixate : (sink: GstBase.BaseSink, caps: Gst.Caps) => Gst.Caps;
activatePull : (sink: GstBase.BaseSink, active: boolean) => boolean;
getTimes : (sink: GstBase.BaseSink, buffer: Gst.Buffer, start: number | bigint, end: number | bigint) => void;
proposeAllocation : (sink: GstBase.BaseSink, query: Gst.Query) => boolean;
start : (sink: GstBase.BaseSink) => boolean;
stop : (sink: GstBase.BaseSink) => boolean;
unlock : (sink: GstBase.BaseSink) => boolean;
unlockStop : (sink: GstBase.BaseSink) => boolean;
query : (sink: GstBase.BaseSink, query: Gst.Query) => boolean;
event : (sink: GstBase.BaseSink, event: Gst.Event) => boolean;
waitEvent : (sink: GstBase.BaseSink, event: Gst.Event) => Gst.FlowReturn;
prepare : (sink: GstBase.BaseSink, buffer: Gst.Buffer) => Gst.FlowReturn;
prepareList : (sink: GstBase.BaseSink, bufferList: Gst.BufferList) => Gst.FlowReturn;
preroll : (sink: GstBase.BaseSink, buffer: Gst.Buffer) => Gst.FlowReturn;
render : (sink: GstBase.BaseSink, buffer: Gst.Buffer) => Gst.FlowReturn;
renderList : (sink: GstBase.BaseSink, bufferList: Gst.BufferList) => Gst.FlowReturn;
}
class BaseSinkPrivate {
}
class BaseSrcClass {
parentClass : Gst.ElementClass;
getCaps : (src: GstBase.BaseSrc, filter: Gst.Caps | undefined | null) => Gst.Caps;
negotiate : (src: GstBase.BaseSrc) => boolean;
fixate : (src: GstBase.BaseSrc, caps: Gst.Caps) => Gst.Caps;
setCaps : (src: GstBase.BaseSrc, caps: Gst.Caps) => boolean;
decideAllocation : (src: GstBase.BaseSrc, query: Gst.Query) => boolean;
start : (src: GstBase.BaseSrc) => boolean;
stop : (src: GstBase.BaseSrc) => boolean;
getTimes : (src: GstBase.BaseSrc, buffer: Gst.Buffer, start: number | bigint, end: number | bigint) => void;
getSize : (src: GstBase.BaseSrc, size: number | bigint) => boolean;
isSeekable : (src: GstBase.BaseSrc) => boolean;
prepareSeekSegment : (src: GstBase.BaseSrc, seek: Gst.Event, segment: Gst.Segment) => boolean;
doSeek : (src: GstBase.BaseSrc, segment: Gst.Segment) => boolean;
unlock : (src: GstBase.BaseSrc) => boolean;
unlockStop : (src: GstBase.BaseSrc) => boolean;
query : (src: GstBase.BaseSrc, query: Gst.Query) => boolean;
event : (src: GstBase.BaseSrc, event: Gst.Event) => boolean;
create : (src: GstBase.BaseSrc, offset: number | bigint, size: number, buf: Gst.Buffer) => Gst.FlowReturn;
alloc : (src: GstBase.BaseSrc, offset: number | bigint, size: number, buf: Gst.Buffer) => Gst.FlowReturn;
fill : (src: GstBase.BaseSrc, offset: number | bigint, size: number, buf: Gst.Buffer) => Gst.FlowReturn;
}
class BaseSrcPrivate {
}
class BaseTransformClass {
parentClass : Gst.ElementClass;
passthroughOnSameCaps : boolean;
transformIpOnPassthrough : boolean;
transformCaps : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps, filter: Gst.Caps) => Gst.Caps;
fixateCaps : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps, othercaps: Gst.Caps) => Gst.Caps;
acceptCaps : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps) => boolean;
setCaps : (trans: GstBase.BaseTransform, incaps: Gst.Caps, outcaps: Gst.Caps) => boolean;
query : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, query: Gst.Query) => boolean;
decideAllocation : (trans: GstBase.BaseTransform, query: Gst.Query) => boolean;
filterMeta : (trans: GstBase.BaseTransform, query: Gst.Query, api: number, params: Gst.Structure) => boolean;
proposeAllocation : (trans: GstBase.BaseTransform, decideQuery: Gst.Query, query: Gst.Query) => boolean;
transformSize : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps, size: number | bigint, othercaps: Gst.Caps, othersize: number | bigint) => boolean;
getUnitSize : (trans: GstBase.BaseTransform, caps: Gst.Caps, size: number | bigint) => boolean;
start : (trans: GstBase.BaseTransform) => boolean;
stop : (trans: GstBase.BaseTransform) => boolean;
sinkEvent : (trans: GstBase.BaseTransform, event: Gst.Event) => boolean;
srcEvent : (trans: GstBase.BaseTransform, event: Gst.Event) => boolean;
prepareOutputBuffer : (trans: GstBase.BaseTransform, input: Gst.Buffer, outbuf: Gst.Buffer) => Gst.FlowReturn;
copyMetadata : (trans: GstBase.BaseTransform, input: Gst.Buffer, outbuf: Gst.Buffer) => boolean;
transformMeta : (trans: GstBase.BaseTransform, outbuf: Gst.Buffer, meta: Gst.Meta, inbuf: Gst.Buffer) => boolean;
beforeTransform : (trans: GstBase.BaseTransform, buffer: Gst.Buffer) => void;
transform : (trans: GstBase.BaseTransform, inbuf: Gst.Buffer, outbuf: Gst.Buffer) => Gst.FlowReturn;
transformIp : (trans: GstBase.BaseTransform, buf: Gst.Buffer) => Gst.FlowReturn;
submitInputBuffer : (trans: GstBase.BaseTransform, isDiscont: boolean, input: Gst.Buffer) => Gst.FlowReturn;
generateOutput : (trans: GstBase.BaseTransform, outbuf: Gst.Buffer) => Gst.FlowReturn;
}
class BaseTransformPrivate {
}
class BitReader {
data : number[];
size : number;
byte : number;
bit : number;
free(): void;
getBitsUint16(val: number, nbits: number): boolean;
getBitsUint32(val: number, nbits: number): boolean;
getBitsUint64(val: number | bigint, nbits: number): boolean;
getBitsUint8(val: number, nbits: number): boolean;
getPos(): number;
getRemaining(): number;
getSize(): number;
init(data: number[], size: number): void;
peekBitsUint16(val: number, nbits: number): boolean;
peekBitsUint32(val: number, nbits: number): boolean;
peekBitsUint64(val: number | bigint, nbits: number): boolean;
peekBitsUint8(val: number, nbits: number): boolean;
setPos(pos: number): boolean;
skip(nbits: number): boolean;
skipToByte(): boolean;
}
class BitWriter {
data : number;
bitSize : number;
bitCapacity : number;
autoGrow : boolean;
owned : boolean;
alignBytes(trailingBit: number): boolean;
free(): void;
freeAndGetBuffer(): Gst.Buffer;
freeAndGetData(): number[];
getData(): number[];
getRemaining(): number;
getSize(): number;
putBitsUint16(value: number, nbits: number): boolean;
putBitsUint32(value: number, nbits: number): boolean;
putBitsUint64(value: number | bigint, nbits: number): boolean;
putBitsUint8(value: number, nbits: number): boolean;
putBytes(data: number[], nbytes: number): boolean;
reset(): void;
resetAndGetBuffer(): Gst.Buffer;
resetAndGetData(): number[];
setPos(pos: number): boolean;
}
class ByteReader {
data : number[];
size : number;
byte : number;
dupData(size: number, val: number[]): boolean;
dupStringUtf16(str: number[]): boolean;
dupStringUtf32(str: number[]): boolean;
dupStringUtf8(str: string[]): boolean;
free(): void;
getData(size: number, val: number[]): boolean;
getFloat32Be(val: number): boolean;
getFloat32Le(val: number): boolean;
getFloat64Be(val: number): boolean;
getFloat64Le(val: number): boolean;
getInt16Be(val: number): boolean;
getInt16Le(val: number): boolean;
getInt24Be(val: number): boolean;
getInt24Le(val: number): boolean;
getInt32Be(val: number): boolean;
getInt32Le(val: number): boolean;
getInt64Be(val: number | bigint): boolean;
getInt64Le(val: number | bigint): boolean;
getInt8(val: number): boolean;
getPos(): number;
getRemaining(): number;
getSize(): number;
getStringUtf8(str: string[]): boolean;
getUint16Be(val: number): boolean;
getUint16Le(val: number): boolean;
getUint24Be(val: number): boolean;
getUint24Le(val: number): boolean;
getUint32Be(val: number): boolean;
getUint32Le(val: number): boolean;
getUint64Be(val: number | bigint): boolean;
getUint64Le(val: number | bigint): boolean;
getUint8(val: number): boolean;
init(data: number[], size: number): void;
maskedScanUint32(mask: number, pattern: number, offset: number, size: number): number;
maskedScanUint32Peek(mask: number, pattern: number, offset: number, size: number, value: number): number;
peekData(size: number, val: number[]): boolean;
peekFloat32Be(val: number): boolean;
peekFloat32Le(val: number): boolean;
peekFloat64Be(val: number): boolean;
peekFloat64Le(val: number): boolean;
peekInt16Be(val: number): boolean;
peekInt16Le(val: number): boolean;
peekInt24Be(val: number): boolean;
peekInt24Le(val: number): boolean;
peekInt32Be(val: number): boolean;
peekInt32Le(val: number): boolean;
peekInt64Be(val: number | bigint): boolean;
peekInt64Le(val: number | bigint): boolean;
peekInt8(val: number): boolean;
peekStringUtf8(str: string[]): boolean;
peekUint16Be(val: number): boolean;
peekUint16Le(val: number): boolean;
peekUint24Be(val: number): boolean;
peekUint24Le(val: number): boolean;
peekUint32Be(val: number): boolean;
peekUint32Le(val: number): boolean;
peekUint64Be(val: number | bigint): boolean;
peekUint64Le(val: number | bigint): boolean;
peekUint8(val: number): boolean;
setPos(pos: number): boolean;
skip(nbytes: number): boolean;
skipStringUtf16(): boolean;
skipStringUtf32(): boolean;
skipStringUtf8(): boolean;
}
class ByteWriter {
parent : GstBase.ByteReader;
allocSize : number;
fixed : boolean;
owned : boolean;
ensureFreeSpace(size: number): boolean;
fill(value: number, size: number): boolean;
free(): void;
freeAndGetBuffer(): Gst.Buffer;
freeAndGetData(): number;
getRemaining(): number;
init(): void;
initWithData(data: number[], size: number, initialized: boolean): void;
initWithSize(size: number, fixed: boolean): void;
putBuffer(buffer: Gst.Buffer, offset: number | bigint, size: number | bigint): boolean;
putData(data: number[], size: number): boolean;
putFloat32Be(val: number): boolean;
putFloat32Le(val: number): boolean;
putFloat64Be(val: number): boolean;
putFloat64Le(val: number): boolean;
putInt16Be(val: number): boolean;
putInt16Le(val: number): boolean;
putInt24Be(val: number): boolean;
putInt24Le(val: number): boolean;
putInt32Be(val: number): boolean;
putInt32Le(val: number): boolean;
putInt64Be(val: number | bigint): boolean;
putInt64Le(val: number | bigint): boolean;
putInt8(val: number): boolean;
putStringUtf16(data: number[]): boolean;
putStringUtf32(data: number[]): boolean;
putStringUtf8(data: string): boolean;
putUint16Be(val: number): boolean;
putUint16Le(val: number): boolean;
putUint24Be(val: number): boolean;
putUint24Le(val: number): boolean;
putUint32Be(val: number): boolean;
putUint32Le(val: number): boolean;
putUint64Be(val: number | bigint): boolean;
putUint64Le(val: number | bigint): boolean;
putUint8(val: number): boolean;
reset(): void;
resetAndGetBuffer(): Gst.Buffer;
resetAndGetData(): number[];
}
class CollectData {
collect : GstBase.CollectPads;
pad : Gst.Pad;
buffer : Gst.Buffer;
pos : number;
segment : Gst.Segment;
state : GstBase.CollectPadsStateFlags;
priv : GstBase.CollectDataPrivate;
}
class CollectDataPrivate {
}
class CollectPadsClass {
parentClass : Gst.ObjectClass;
}
class CollectPadsPrivate {
}
class DataQueueClass {
parentClass : GObject.ObjectClass;
empty : (queue: GstBase.DataQueue) => void;
full : (queue: GstBase.DataQueue) => void;
}
class DataQueuePrivate {
}
class FlowCombiner {
static New(): GstBase.FlowCombiner;
addPad(pad: Gst.Pad): void;
clear(): void;
free(): void;
ref(): GstBase.FlowCombiner;
removePad(pad: Gst.Pad): void;
reset(): void;
unref(): void;
updateFlow(fret: Gst.FlowReturn): Gst.FlowReturn;
updatePadFlow(pad: Gst.Pad, fret: Gst.FlowReturn): Gst.FlowReturn;
}
class PushSrcClass {
parentClass : GstBase.BaseSrcClass;
create : (src: GstBase.PushSrc, buf: Gst.Buffer) => Gst.FlowReturn;
alloc : (src: GstBase.PushSrc, buf: Gst.Buffer) => Gst.FlowReturn;
fill : (src: GstBase.PushSrc, buf: Gst.Buffer) => Gst.FlowReturn;
}
class Adapter extends GObject.Object {
constructor(initializerList ?: AdapterCtor);
static New(): GstBase.Adapter;
available(): number | bigint;
availableFast(): number | bigint;
clear(): void;
copy(offset: number | bigint, size: number | bigint): AuGlibEx.Bytes;
distanceFromDiscont(): number | bigint;
dtsAtDiscont(): number | bigint;
flush(flush: number | bigint): void;
getBuffer(nbytes: number | bigint): Gst.Buffer;
getBufferFast(nbytes: number | bigint): Gst.Buffer;
getBufferList(nbytes: number | bigint): Gst.BufferList;
getList(nbytes: number | bigint): Gst.Buffer[];
map(size: number | bigint): number[];
maskedScanUint32(mask: number, pattern: number, offset: number | bigint, size: number | bigint): number | bigint;
maskedScanUint32Peek(mask: number, pattern: number, offset: number | bigint, size: number | bigint, value ?: number): number | bigint;
offsetAtDiscont(): number | bigint;
prevDts(distance ?: number | bigint): number | bigint;
prevDtsAtOffset(offset: number | bigint, distance ?: number | bigint): number | bigint;
prevOffset(distance ?: number | bigint): number | bigint;
prevPts(distance ?: number | bigint): number | bigint;
prevPtsAtOffset(offset: number | bigint, distance ?: number | bigint): number | bigint;
ptsAtDiscont(): number | bigint;
push(buf: Gst.Buffer): void;
take(nbytes: number | bigint): number[];
takeBuffer(nbytes: number | bigint): Gst.Buffer;
takeBufferFast(nbytes: number | bigint): Gst.Buffer;
takeBufferList(nbytes: number | bigint): Gst.BufferList;
takeList(nbytes: number | bigint): Gst.Buffer[];
unmap(): void;
//TypeScript is complete garbage:
}
class AdapterCtor {
}
class Aggregator extends Gst.Element {
constructor(initializerList ?: AggregatorCtor);
parent : Gst.Element;
srcpad : Gst.Pad;
priv : GstBase.AggregatorPrivate;
emitSignals : boolean;
latency : number | bigint;
minUpstreamLatency : number | bigint;
startTime : number | bigint;
startTimeSelection : GstBase.AggregatorStartTimeSelection;
finishBuffer(buffer: Gst.Buffer): Gst.FlowReturn;
finishBufferList(bufferlist: Gst.BufferList): Gst.FlowReturn;
getAllocator(allocator ?: Gst.Allocator | undefined | null, params ?: Gst.AllocationParams): void;
getBufferPool(): Gst.BufferPool;
getIgnoreInactivePads(): boolean;
getLatency(): number | bigint;
negotiate(): boolean;
peekNextSample(pad: GstBase.AggregatorPad): Gst.Sample;
selectedSamples(pts: number | bigint, dts: number | bigint, duration: number | bigint, info: Gst.Structure | undefined | null): void;
setIgnoreInactivePads(ignore: boolean): void;
setLatency(minLatency: number | bigint, maxLatency: number | bigint): void;
setSrcCaps(caps: Gst.Caps): void;
simpleGetNextTime(): number | bigint;
updateSegment(segment: Gst.Segment): void;
//TypeScript is complete garbage:
}
class AggregatorCtor {
name ?: string;
parent ?: Gst.Object;
latency ?: number;
minUpstreamLatency ?: number;
startTimeSelection ?: GstBase.AggregatorStartTimeSelection;
startTime ?: number;
emitSignals ?: boolean;
}
class AggregatorEventListener extends AuGlibEx.IEventListener {
samplesSelected(segment: Gst.Segment, pts: number | bigint, dts: number | bigint, duration: number | bigint, info: Gst.Structure | undefined | null): void;
}
class AggregatorPad extends Gst.Pad {
constructor(initializerList ?: AggregatorPadCtor);
parent : Gst.Pad;
segment : Gst.Segment;
priv : GstBase.AggregatorPadPrivate;
emitSignals : boolean;
dropBuffer(): boolean;
hasBuffer(): boolean;
isEos(): boolean;
isInactive(): boolean;
peekBuffer(): Gst.Buffer;
popBuffer(): Gst.Buffer;
//TypeScript is complete garbage:
}
class AggregatorPadCtor {
name ?: string;
parent ?: Gst.Object;
direction ?: Gst.PadDirection;
template ?: Gst.PadTemplate;
offset ?: number | bigint;
emitSignals ?: boolean;
}
class AggregatorPadEventListener extends AuGlibEx.IEventListener {
bufferConsumed(object: Gst.Buffer): void;
}
class BaseParse extends Gst.Element {
constructor(initializerList ?: BaseParseCtor);
element : Gst.Element;
sinkpad : Gst.Pad;
srcpad : Gst.Pad;
flags : number;
segment : Gst.Segment;
priv : GstBase.BaseParsePrivate;
disablePassthrough : boolean;
addIndexEntry(offset: number | bigint, ts: number | bigint, key: boolean, force: boolean): boolean;
convertDefault(srcFormat: Gst.Format, srcValue: number | bigint, destFormat: Gst.Format, destValue: number | bigint): boolean;
drain(): void;
finishFrame(frame: GstBase.BaseParseFrame, size: number): Gst.FlowReturn;
mergeTags(tags: Gst.TagList | undefined | null, mode: Gst.TagMergeMode): void;
pushFrame(frame: GstBase.BaseParseFrame): Gst.FlowReturn;
setAverageBitrate(bitrate: number): void;
setDuration(fmt: Gst.Format, duration: number | bigint, interval: number): void;
setFrameRate(fpsNum: number, fpsDen: number, leadIn: number, leadOut: number): void;
setHasTimingInfo(hasTiming: boolean): void;
setInferTs(inferTs: boolean): void;
setLatency(minLatency: number | bigint, maxLatency: number | bigint): void;
setMinFrameSize(minSize: number): void;
setPassthrough(passthrough: boolean): void;
setPtsInterpolation(ptsInterpolate: boolean): void;
setSyncable(syncable: boolean): void;
setTsAtOffset(offset: number | bigint): void;
//TypeScript is complete garbage:
}
class BaseParseCtor {
name ?: string;
parent ?: Gst.Object;
disablePassthrough ?: boolean;
}
class BaseSink extends Gst.Element {
constructor(initializerList ?: BaseSinkCtor);
element : Gst.Element;
sinkpad : Gst.Pad;
padMode : Gst.PadMode;
offset : number | bigint;
canActivatePull : boolean;
canActivatePush : boolean;
prerollCond : AuGlibEx.Cond;
eos : boolean;
needPreroll : boolean;
havePreroll : boolean;
playingAsync : boolean;
haveNewsegment : boolean;
segment : Gst.Segment;
clockId : void;
sync : boolean;
flushing : boolean;
running : boolean;
maxLateness : number | bigint;
priv : GstBase.BaseSinkPrivate;
_async : boolean;
blocksize : number;
enableLastSample : boolean;
lastSample : Gst.Sample;
maxBitrate : number | bigint;
processingDeadline : number | bigint;
qos : boolean;
renderDelay : number | bigint;
stats : Gst.Structure;
throttleTime : number | bigint;
tsOffset : number | bigint;
doPreroll(obj: Gst.MiniObject): Gst.FlowReturn;
getBlocksize(): number;
getDropOutOfSegment(): boolean;
getLastSample(): Gst.Sample;
getLatency(): number | bigint;
getMaxBitrate(): number | bigint;
getMaxLateness(): number | bigint;
getProcessingDeadline(): number | bigint;
getRenderDelay(): number | bigint;
getStats(): Gst.Structure;
getSync(): boolean;
getThrottleTime(): number | bigint;
getTsOffset(): number | bigint;
isAsyncEnabled(): boolean;
isLastSampleEnabled(): boolean;
isQosEnabled(): boolean;
queryLatency(live ?: boolean, upstreamLive ?: boolean, minLatency ?: number | bigint, maxLatency ?: number | bigint): boolean;
setAsyncEnabled(enabled: boolean): void;
setBlocksize(blocksize: number): void;
setDropOutOfSegment(dropOutOfSegment: boolean): void;
setLastSampleEnabled(enabled: boolean): void;
setMaxBitrate(maxBitrate: number | bigint): void;
setMaxLateness(maxLateness: number | bigint): void;
setProcessingDeadline(processingDeadline: number | bigint): void;
setQosEnabled(enabled: boolean): void;
setRenderDelay(delay: number | bigint): void;
setSync(sync: boolean): void;
setThrottleTime(throttle: number | bigint): void;
setTsOffset(offset: number | bigint): void;
wait(time: number | bigint, jitter ?: number | bigint): Gst.FlowReturn;
waitClock(time: number | bigint, jitter ?: number | bigint): Gst.ClockReturn;
waitPreroll(): Gst.FlowReturn;
//TypeScript is complete garbage:
}
class BaseSinkCtor {
name ?: string;
parent ?: Gst.Object;
sync ?: boolean;
maxLateness ?: number | bigint;
qos ?: boolean;
async ?: boolean;
tsOffset ?: number | bigint;
enableLastSample ?: boolean;
blocksize ?: number;
renderDelay ?: number;
throttleTime ?: number;
maxBitrate ?: number;
processingDeadline ?: number;
}
class BaseSrc extends Gst.Element {
constructor(initializerList ?: BaseSrcCtor);
element : Gst.Element;
srcpad : Gst.Pad;
liveCond : AuGlibEx.Cond;
isLive : boolean;
liveRunning : boolean;
blocksize : number;
canActivatePush : boolean;
randomAccess : boolean;
clockId : void;
segment : Gst.Segment;
needNewsegment : boolean;
numBuffers : number;
numBuffersLeft : number;
typefind : boolean;
running : boolean;
pendingSeek : Gst.Event;
priv : GstBase.BaseSrcPrivate;
doTimestamp : boolean;
getAllocator(allocator ?: Gst.Allocator | undefined | null, params ?: Gst.AllocationParams): void;
getBlocksize(): number;
getBufferPool(): Gst.BufferPool;
getDoTimestamp(): boolean;
isAsync(): boolean;
negotiate(): boolean;
newSeamlessSegment(start: number | bigint, stop: number | bigint, time: number | bigint): boolean;
newSegment(segment: Gst.Segment): boolean;
queryLatency(live ?: boolean, minLatency ?: number | bigint, maxLatency ?: number | bigint): boolean;
setAsync(_async: boolean): void;
setAutomaticEos(automaticEos: boolean): void;
setBlocksize(blocksize: number): void;
setCaps(caps: Gst.Caps): boolean;
setDoTimestamp(timestamp: boolean): void;
setDynamicSize(dynamic: boolean): void;
setFormat(format: Gst.Format): void;
setLive(live: boolean): void;
startComplete(ret: Gst.FlowReturn): void;
startWait(): Gst.FlowReturn;
submitBufferList(bufferList: Gst.BufferList): void;
waitPlaying(): Gst.FlowReturn;
//TypeScript is complete garbage:
}
class BaseSrcCtor {
name ?: string;
parent ?: Gst.Object;
blocksize ?: number;
numBuffers ?: number;
typefind ?: boolean;
doTimestamp ?: boolean;
}
class BaseTransform extends Gst.Element {
constructor(initializerList ?: BaseTransformCtor);
element : Gst.Element;
sinkpad : Gst.Pad;
srcpad : Gst.Pad;
haveSegment : boolean;
segment : Gst.Segment;
queuedBuf : Gst.Buffer;
priv : GstBase.BaseTransformPrivate;
qos : boolean;
getAllocator(allocator ?: Gst.Allocator | undefined | null, params ?: Gst.AllocationParams): void;
getBufferPool(): Gst.BufferPool;
isInPlace(): boolean;
isPassthrough(): boolean;
isQosEnabled(): boolean;
reconfigure(): boolean;
reconfigureSink(): void;
reconfigureSrc(): void;
setGapAware(gapAware: boolean): void;
setInPlace(inPlace: boolean): void;
setPassthrough(passthrough: boolean): void;
setPreferPassthrough(preferPassthrough: boolean): void;
setQosEnabled(enabled: boolean): void;
updateQos(proportion: number, diff: number | bigint, timestamp: number | bigint): void;
updateSrcCaps(updatedCaps: Gst.Caps): boolean;
//TypeScript is complete garbage:
}
class BaseTransformCtor {
name ?: string;
parent ?: Gst.Object;
qos ?: boolean;
}
class CollectPads extends Gst.Object {
constructor(initializerList ?: CollectPadsCtor);
object : Gst.Object;
data : GstBase.CollectData[];
streamLock : AuGlibEx.RecMutex;
priv : GstBase.CollectPadsPrivate;
static New(): GstBase.CollectPads;
addPad(pad: Gst.Pad, size: number, destroyNotify: (data: GstBase.CollectData) => void, lock: boolean): GstBase.CollectData;
available(): number;
clipRunningTime(cdata: GstBase.CollectData, buf: Gst.Buffer, outbuf ?: Gst.Buffer): Gst.FlowReturn;
eventDefault(data: GstBase.CollectData, event: Gst.Event, discard: boolean): boolean;
flush(data: GstBase.CollectData, size: number): number;
peek(data: GstBase.CollectData): Gst.Buffer;
pop(data: GstBase.CollectData): Gst.Buffer;
queryDefault(data: GstBase.CollectData, query: Gst.Query, discard: boolean): boolean;
readBuffer(data: GstBase.CollectData, size: number): Gst.Buffer;
removePad(pad: Gst.Pad): boolean;
setBufferFunction(func: (pads: GstBase.CollectPads, data: GstBase.CollectData, buffer: Gst.Buffer) => Gst.FlowReturn): void;
setClipFunction(clipfunc: (pads: GstBase.CollectPads, data: GstBase.CollectData, inbuffer: Gst.Buffer, outbuffer: Gst.Buffer) => Gst.FlowReturn): void;
setCompareFunction(func: (pads: GstBase.CollectPads, data1: GstBase.CollectData, timestamp1: number | bigint, data2: GstBase.CollectData, timestamp2: number | bigint) => number): void;
setEventFunction(func: (pads: GstBase.CollectPads, pad: GstBase.CollectData, event: Gst.Event) => boolean): void;
setFlushFunction(func: (pads: GstBase.CollectPads) => void): void;
setFlushing(flushing: boolean): void;
setFunction(func: (pads: GstBase.CollectPads) => Gst.FlowReturn): void;
setQueryFunction(func: (pads: GstBase.CollectPads, pad: GstBase.CollectData, query: Gst.Query) => boolean): void;
setWaiting(data: GstBase.CollectData, waiting: boolean): void;
srcEventDefault(pad: Gst.Pad, event: Gst.Event): boolean;
start(): void;
stop(): void;
takeBuffer(data: GstBase.CollectData, size: number): Gst.Buffer;
//TypeScript is complete garbage:
}
class CollectPadsCtor {
name ?: string;
parent ?: Gst.Object;
}
class DataQueue extends GObject.Object {
constructor(initializerList ?: DataQueueCtor);
object : GObject.Object;
priv : GstBase.DataQueuePrivate;
currentLevelBytes : number;
currentLevelTime : number | bigint;
currentLevelVisible : number;
//TypeScript is complete garbage:
}
class DataQueueCtor {
currentLevelVisible ?: number;
currentLevelBytes ?: number;
currentLevelTime ?: number;
}
class PushSrc extends GstBase.BaseSrc {
constructor(initializerList ?: PushSrcCtor);
parent : GstBase.BaseSrc;
//TypeScript is complete garbage:
}
class PushSrcCtor {
name ?: string;
parent ?: Gst.Object;
blocksize ?: number;
numBuffers ?: number;
typefind ?: boolean;
doTimestamp ?: boolean;
}
}

372
GstPlay.d.ts vendored Normal file
View File

@ -0,0 +1,372 @@
declare namespace GstPlay {
class PlayColorBalanceType {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kHue": PlayColorBalanceType
static readonly "kBrightness": PlayColorBalanceType
static readonly "kSaturation": PlayColorBalanceType
static readonly "kContrast": PlayColorBalanceType
}
class PlayError {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kFailed": PlayError
}
class PlayMessage {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kUriLoaded": PlayMessage
static readonly "kPositionUpdated": PlayMessage
static readonly "kDurationChanged": PlayMessage
static readonly "kStateChanged": PlayMessage
static readonly "kBuffering": PlayMessage
static readonly "kEndOfStream": PlayMessage
static readonly "kError": PlayMessage
static readonly "kWarning": PlayMessage
static readonly "kVideoDimensionsChanged": PlayMessage
static readonly "kMediaInfoUpdated": PlayMessage
static readonly "kVolumeChanged": PlayMessage
static readonly "kMuteChanged": PlayMessage
static readonly "kSeekDone": PlayMessage
}
class PlaySnapshotFormat {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kRawNative": PlaySnapshotFormat
static readonly "kRawXRgb": PlaySnapshotFormat
static readonly "kRawBgrx": PlaySnapshotFormat
static readonly "kJpg": PlaySnapshotFormat
static readonly "kPng": PlaySnapshotFormat
}
class PlayState {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kStopped": PlayState
static readonly "kBuffering": PlayState
static readonly "kPaused": PlayState
static readonly "kPlaying": PlayState
}
class PlayVideoRenderer {
}
class PlayAudioInfoClass {
}
class PlayClass {
}
class PlayMediaInfoClass {
}
class PlaySignalAdapterClass {
}
class PlayStreamInfoClass {
}
class PlaySubtitleInfoClass {
}
class PlayVideoInfoClass {
}
class PlayVideoOverlayVideoRendererClass {
}
class PlayVideoRendererInterface {
parentIface : GObject.TypeInterface;
createVideoSink : void;
}
class PlayVisualization {
name : string;
description : string;
copy(): GstPlay.PlayVisualization;
free(): void;
}
class Play extends Gst.Object {
constructor(initializerList ?: PlayCtor);
audioVideoOffset : number | bigint;
currentAudioTrack : GstPlay.PlayAudioInfo;
currentSubtitleTrack : GstPlay.PlaySubtitleInfo;
currentVideoTrack : GstPlay.PlayVideoInfo;
duration : number | bigint;
mediaInfo : GstPlay.PlayMediaInfo;
mute : boolean;
pipeline : Gst.Element;
position : number | bigint;
rate : number;
subtitleVideoOffset : number | bigint;
suburi : string;
uri : string;
videoMultiviewFlags : GstVideo.VideoMultiviewFlags;
videoMultiviewMode : GstVideo.VideoMultiviewFramePacking;
videoRenderer : GstPlay.PlayVideoRenderer;
volume : number;
static New(videoRenderer: GstPlay.PlayVideoRenderer | undefined | null): GstPlay.Play;
static ConfigGetPositionUpdateInterval(config: Gst.Structure): number;
static ConfigGetSeekAccurate(config: Gst.Structure): boolean;
static ConfigGetUserAgent(config: Gst.Structure): string;
static ConfigSetPositionUpdateInterval(config: Gst.Structure, interval: number): void;
static ConfigSetSeekAccurate(config: Gst.Structure, accurate: boolean): void;
static ConfigSetUserAgent(config: Gst.Structure, agent: string | undefined | null): void;
static GetAudioStreams(info: GstPlay.PlayMediaInfo): GstPlay.PlayAudioInfo[];
static GetSubtitleStreams(info: GstPlay.PlayMediaInfo): GstPlay.PlaySubtitleInfo[];
static GetVideoStreams(info: GstPlay.PlayMediaInfo): GstPlay.PlayVideoInfo[];
static IsPlayMessage(msg: Gst.Message): boolean;
static VisualizationsFree(viss: GstPlay.PlayVisualization): void;
static VisualizationsGet(): GstPlay.PlayVisualization[];
getAudioVideoOffset(): number | bigint;
getColorBalance(type: GstPlay.PlayColorBalanceType): number;
getConfig(): Gst.Structure;
getCurrentAudioTrack(): GstPlay.PlayAudioInfo;
getCurrentSubtitleTrack(): GstPlay.PlaySubtitleInfo;
getCurrentVideoTrack(): GstPlay.PlayVideoInfo;
getCurrentVisualization(): string;
getDuration(): number | bigint;
getMediaInfo(): GstPlay.PlayMediaInfo;
getMessageBus(): Gst.Bus;
getMultiviewFlags(): GstVideo.VideoMultiviewFlags;
getMultiviewMode(): GstVideo.VideoMultiviewFramePacking;
getMute(): boolean;
getPipeline(): Gst.Element;
getPosition(): number | bigint;
getRate(): number;
getSubtitleUri(): string;
getSubtitleVideoOffset(): number | bigint;
getUri(): string;
getVideoSnapshot(format: GstPlay.PlaySnapshotFormat, config: Gst.Structure | undefined | null): Gst.Sample;
getVolume(): number;
hasColorBalance(): boolean;
pause(): void;
play(): void;
seek(position: number | bigint): void;
setAudioTrack(streamIndex: number): boolean;
setAudioTrackEnabled(enabled: boolean): void;
setAudioVideoOffset(offset: number | bigint): void;
setColorBalance(type: GstPlay.PlayColorBalanceType, value: number): void;
setConfig(config: Gst.Structure): boolean;
setMultiviewFlags(flags: GstVideo.VideoMultiviewFlags): void;
setMultiviewMode(mode: GstVideo.VideoMultiviewFramePacking): void;
setMute(val: boolean): void;
setRate(rate: number): void;
setSubtitleTrack(streamIndex: number): boolean;
setSubtitleTrackEnabled(enabled: boolean): void;
setSubtitleUri(uri: string | undefined | null): void;
setSubtitleVideoOffset(offset: number | bigint): void;
setUri(uri: string | undefined | null): void;
setVideoTrack(streamIndex: number): boolean;
setVideoTrackEnabled(enabled: boolean): void;
setVisualization(name: string | undefined | null): boolean;
setVisualizationEnabled(enabled: boolean): void;
setVolume(val: number): void;
stop(): void;
//TypeScript is complete garbage:
}
class PlayCtor {
name ?: string;
parent ?: Gst.Object;
videoRenderer ?: GstPlay.PlayVideoRenderer;
uri ?: string;
suburi ?: string;
position ?: number;
duration ?: number;
mediaInfo ?: GstPlay.PlayMediaInfo;
currentAudioTrack ?: GstPlay.PlayAudioInfo;
currentVideoTrack ?: GstPlay.PlayVideoInfo;
currentSubtitleTrack ?: GstPlay.PlaySubtitleInfo;
volume ?: number;
mute ?: boolean;
rate ?: number;
pipeline ?: Gst.Element;
videoMultiviewMode ?: GstVideo.VideoMultiviewFramePacking;
videoMultiviewFlags ?: GstVideo.VideoMultiviewFlags;
audioVideoOffset ?: number | bigint;
subtitleVideoOffset ?: number | bigint;
}
class PlayAudioInfo extends GstPlay.PlayStreamInfo {
constructor(initializerList ?: PlayAudioInfoCtor);
getBitrate(): number;
getChannels(): number;
getLanguage(): string;
getMaxBitrate(): number;
getSampleRate(): number;
//TypeScript is complete garbage:
}
class PlayAudioInfoCtor {
}
class PlayMediaInfo extends GObject.Object {
constructor(initializerList ?: PlayMediaInfoCtor);
getAudioStreams(): GstPlay.PlayAudioInfo[];
getContainerFormat(): string;
getDuration(): number | bigint;
getImageSample(): Gst.Sample;
getNumberOfAudioStreams(): number;
getNumberOfStreams(): number;
getNumberOfSubtitleStreams(): number;
getNumberOfVideoStreams(): number;
getStreamList(): GstPlay.PlayStreamInfo[];
getSubtitleStreams(): GstPlay.PlaySubtitleInfo[];
getTags(): Gst.TagList;
getTitle(): string;
getUri(): string;
getVideoStreams(): GstPlay.PlayVideoInfo[];
isLive(): boolean;
isSeekable(): boolean;
//TypeScript is complete garbage:
}
class PlayMediaInfoCtor {
}
class PlaySignalAdapter extends GObject.Object {
constructor(initializerList ?: PlaySignalAdapterCtor);
play : GstPlay.Play;
static New(play: GstPlay.Play): GstPlay.PlaySignalAdapter;
static NewSyncEmit(play: GstPlay.Play): GstPlay.PlaySignalAdapter;
static NewWithMainContext(play: GstPlay.Play, context: AuGlibEx.MainContext): GstPlay.PlaySignalAdapter;
getPlay(): GstPlay.Play;
//TypeScript is complete garbage:
}
class PlaySignalAdapterCtor {
play ?: GstPlay.Play;
}
class PlaySignalAdapterEventListener extends AuGlibEx.IEventListener {
buffering(object: number): void;
durationChanged(object: number | bigint): void;
endOfStream(): void;
error(object: AuGlibEx.Error, p0: Gst.Structure): void;
mediaInfoUpdated(object: GstPlay.PlayMediaInfo): void;
muteChanged(object: boolean): void;
positionUpdated(object: number | bigint): void;
seekDone(object: number | bigint): void;
stateChanged(object: GstPlay.PlayState): void;
uriLoaded(object: string): void;
videoDimensionsChanged(object: number, p0: number): void;
volumeChanged(object: number): void;
warning(object: AuGlibEx.Error, p0: Gst.Structure): void;
}
class PlayStreamInfo extends GObject.Object {
constructor(initializerList ?: PlayStreamInfoCtor);
getCaps(): Gst.Caps;
getCodec(): string;
getIndex(): number;
getStreamType(): string;
getTags(): Gst.TagList;
//TypeScript is complete garbage:
}
class PlayStreamInfoCtor {
}
class PlaySubtitleInfo extends GstPlay.PlayStreamInfo {
constructor(initializerList ?: PlaySubtitleInfoCtor);
getLanguage(): string;
//TypeScript is complete garbage:
}
class PlaySubtitleInfoCtor {
}
class PlayVideoInfo extends GstPlay.PlayStreamInfo {
constructor(initializerList ?: PlayVideoInfoCtor);
getBitrate(): number;
getFramerate(fpsN: number, fpsD: number): void;
getHeight(): number;
getMaxBitrate(): number;
getPixelAspectRatio(parN: number, parD: number): void;
getWidth(): number;
//TypeScript is complete garbage:
}
class PlayVideoInfoCtor {
}
class PlayVideoOverlayVideoRenderer extends GObject.Object implements GstPlay.PlayVideoRenderer {
constructor(initializerList ?: PlayVideoOverlayVideoRendererCtor);
videoSink : Gst.Element;
windowHandle : void;
static New(): GstPlay.PlayVideoRenderer;
static NewWithSink(videoSink: Gst.Element): GstPlay.PlayVideoRenderer;
expose(): void;
getRenderRectangle(x ?: number, y ?: number, width ?: number, height ?: number): void;
getWindowHandle(): void;
setRenderRectangle(x: number, y: number, width: number, height: number): void;
setWindowHandle(): void;
//TypeScript is complete garbage:
}
class PlayVideoOverlayVideoRendererCtor {
windowHandle ?: number | bigint;
videoSink ?: Gst.Element;
}
}

352
GstPlayer.d.ts vendored Normal file
View File

@ -0,0 +1,352 @@
declare namespace GstPlayer {
class PlayerColorBalanceType {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kHue": PlayerColorBalanceType
static readonly "kBrightness": PlayerColorBalanceType
static readonly "kSaturation": PlayerColorBalanceType
static readonly "kContrast": PlayerColorBalanceType
}
class PlayerError {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kFailed": PlayerError
}
class PlayerSnapshotFormat {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kRawNative": PlayerSnapshotFormat
static readonly "kRawXRgb": PlayerSnapshotFormat
static readonly "kRawBgrx": PlayerSnapshotFormat
static readonly "kJpg": PlayerSnapshotFormat
static readonly "kPng": PlayerSnapshotFormat
}
class PlayerState {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kStopped": PlayerState
static readonly "kBuffering": PlayerState
static readonly "kPaused": PlayerState
static readonly "kPlaying": PlayerState
}
class PlayerSignalDispatcher {
}
class PlayerVideoRenderer {
}
class PlayerAudioInfoClass {
}
class PlayerClass {
}
class PlayerGMainContextSignalDispatcherClass {
}
class PlayerMediaInfoClass {
}
class PlayerSignalDispatcherInterface {
parentIface : GObject.TypeInterface;
dispatch : (self: GstPlayer.PlayerSignalDispatcher, player: GstPlayer.Player, emitter: () => void, destroy: () => void) => void;
}
class PlayerStreamInfoClass {
}
class PlayerSubtitleInfoClass {
}
class PlayerVideoInfoClass {
}
class PlayerVideoOverlayVideoRendererClass {
}
class PlayerVideoRendererInterface {
parentIface : GObject.TypeInterface;
createVideoSink : void;
}
class PlayerVisualization {
name : string;
description : string;
copy(): GstPlayer.PlayerVisualization;
free(): void;
}
class Player extends Gst.Object {
constructor(initializerList ?: PlayerCtor);
audioVideoOffset : number | bigint;
currentAudioTrack : GstPlayer.PlayerAudioInfo;
currentSubtitleTrack : GstPlayer.PlayerSubtitleInfo;
currentVideoTrack : GstPlayer.PlayerVideoInfo;
duration : number | bigint;
mediaInfo : GstPlayer.PlayerMediaInfo;
mute : boolean;
pipeline : Gst.Element;
position : number | bigint;
rate : number;
signalDispatcher : GstPlayer.PlayerSignalDispatcher;
subtitleVideoOffset : number | bigint;
suburi : string;
uri : string;
videoMultiviewFlags : GstVideo.VideoMultiviewFlags;
videoMultiviewMode : GstVideo.VideoMultiviewFramePacking;
videoRenderer : GstPlayer.PlayerVideoRenderer;
volume : number;
static New(videoRenderer: GstPlayer.PlayerVideoRenderer | undefined | null, signalDispatcher: GstPlayer.PlayerSignalDispatcher | undefined | null): GstPlayer.Player;
static ConfigGetPositionUpdateInterval(config: Gst.Structure): number;
static ConfigGetSeekAccurate(config: Gst.Structure): boolean;
static ConfigGetUserAgent(config: Gst.Structure): string;
static ConfigSetPositionUpdateInterval(config: Gst.Structure, interval: number): void;
static ConfigSetSeekAccurate(config: Gst.Structure, accurate: boolean): void;
static ConfigSetUserAgent(config: Gst.Structure, agent: string | undefined | null): void;
static GetAudioStreams(info: GstPlayer.PlayerMediaInfo): GstPlayer.PlayerAudioInfo[];
static GetSubtitleStreams(info: GstPlayer.PlayerMediaInfo): GstPlayer.PlayerSubtitleInfo[];
static GetVideoStreams(info: GstPlayer.PlayerMediaInfo): GstPlayer.PlayerVideoInfo[];
static VisualizationsFree(viss: GstPlayer.PlayerVisualization): void;
static VisualizationsGet(): GstPlayer.PlayerVisualization[];
getAudioVideoOffset(): number | bigint;
getColorBalance(type: GstPlayer.PlayerColorBalanceType): number;
getConfig(): Gst.Structure;
getCurrentAudioTrack(): GstPlayer.PlayerAudioInfo;
getCurrentSubtitleTrack(): GstPlayer.PlayerSubtitleInfo;
getCurrentVideoTrack(): GstPlayer.PlayerVideoInfo;
getCurrentVisualization(): string;
getDuration(): number | bigint;
getMediaInfo(): GstPlayer.PlayerMediaInfo;
getMultiviewFlags(): GstVideo.VideoMultiviewFlags;
getMultiviewMode(): GstVideo.VideoMultiviewFramePacking;
getMute(): boolean;
getPipeline(): Gst.Element;
getPosition(): number | bigint;
getRate(): number;
getSubtitleUri(): string;
getSubtitleVideoOffset(): number | bigint;
getUri(): string;
getVideoSnapshot(format: GstPlayer.PlayerSnapshotFormat, config: Gst.Structure | undefined | null): Gst.Sample;
getVolume(): number;
hasColorBalance(): boolean;
pause(): void;
play(): void;
seek(position: number | bigint): void;
setAudioTrack(streamIndex: number): boolean;
setAudioTrackEnabled(enabled: boolean): void;
setAudioVideoOffset(offset: number | bigint): void;
setColorBalance(type: GstPlayer.PlayerColorBalanceType, value: number): void;
setConfig(config: Gst.Structure): boolean;
setMultiviewFlags(flags: GstVideo.VideoMultiviewFlags): void;
setMultiviewMode(mode: GstVideo.VideoMultiviewFramePacking): void;
setMute(val: boolean): void;
setRate(rate: number): void;
setSubtitleTrack(streamIndex: number): boolean;
setSubtitleTrackEnabled(enabled: boolean): void;
setSubtitleUri(uri: string | undefined | null): void;
setSubtitleVideoOffset(offset: number | bigint): void;
setUri(uri: string | undefined | null): void;
setVideoTrack(streamIndex: number): boolean;
setVideoTrackEnabled(enabled: boolean): void;
setVisualization(name: string | undefined | null): boolean;
setVisualizationEnabled(enabled: boolean): void;
setVolume(val: number): void;
stop(): void;
//TypeScript is complete garbage:
}
class PlayerCtor {
name ?: string;
parent ?: Gst.Object;
videoRenderer ?: GstPlayer.PlayerVideoRenderer;
signalDispatcher ?: GstPlayer.PlayerSignalDispatcher;
uri ?: string;
suburi ?: string;
position ?: number;
duration ?: number;
mediaInfo ?: GstPlayer.PlayerMediaInfo;
currentAudioTrack ?: GstPlayer.PlayerAudioInfo;
currentVideoTrack ?: GstPlayer.PlayerVideoInfo;
currentSubtitleTrack ?: GstPlayer.PlayerSubtitleInfo;
volume ?: number;
mute ?: boolean;
rate ?: number;
pipeline ?: Gst.Element;
videoMultiviewMode ?: GstVideo.VideoMultiviewFramePacking;
videoMultiviewFlags ?: GstVideo.VideoMultiviewFlags;
audioVideoOffset ?: number | bigint;
subtitleVideoOffset ?: number | bigint;
}
class PlayerEventListener extends AuGlibEx.IEventListener {
buffering(object: number): void;
durationChanged(object: number | bigint): void;
endOfStream(): void;
error(object: AuGlibEx.Error): void;
mediaInfoUpdated(object: GstPlayer.PlayerMediaInfo): void;
muteChanged(): void;
positionUpdated(object: number | bigint): void;
seekDone(object: number | bigint): void;
stateChanged(object: GstPlayer.PlayerState): void;
uriLoaded(object: string): void;
videoDimensionsChanged(object: number, p0: number): void;
volumeChanged(): void;
warning(object: AuGlibEx.Error): void;
}
class PlayerAudioInfo extends GstPlayer.PlayerStreamInfo {
constructor(initializerList ?: PlayerAudioInfoCtor);
getBitrate(): number;
getChannels(): number;
getLanguage(): string;
getMaxBitrate(): number;
getSampleRate(): number;
//TypeScript is complete garbage:
}
class PlayerAudioInfoCtor {
}
class PlayerGMainContextSignalDispatcher extends GObject.Object implements GstPlayer.PlayerSignalDispatcher {
constructor(initializerList ?: PlayerGMainContextSignalDispatcherCtor);
applicationContext : AuGlibEx.MainContext;
static New(applicationContext: AuGlibEx.MainContext | undefined | null): GstPlayer.PlayerSignalDispatcher;
//TypeScript is complete garbage:
}
class PlayerGMainContextSignalDispatcherCtor {
applicationContext ?: AuGlibEx.MainContext;
}
class PlayerMediaInfo extends GObject.Object {
constructor(initializerList ?: PlayerMediaInfoCtor);
getAudioStreams(): GstPlayer.PlayerAudioInfo[];
getContainerFormat(): string;
getDuration(): number | bigint;
getImageSample(): Gst.Sample;
getNumberOfAudioStreams(): number;
getNumberOfStreams(): number;
getNumberOfSubtitleStreams(): number;
getNumberOfVideoStreams(): number;
getStreamList(): GstPlayer.PlayerStreamInfo[];
getSubtitleStreams(): GstPlayer.PlayerSubtitleInfo[];
getTags(): Gst.TagList;
getTitle(): string;
getUri(): string;
getVideoStreams(): GstPlayer.PlayerVideoInfo[];
isLive(): boolean;
isSeekable(): boolean;
//TypeScript is complete garbage:
}
class PlayerMediaInfoCtor {
}
class PlayerStreamInfo extends GObject.Object {
constructor(initializerList ?: PlayerStreamInfoCtor);
getCaps(): Gst.Caps;
getCodec(): string;
getIndex(): number;
getStreamType(): string;
getTags(): Gst.TagList;
//TypeScript is complete garbage:
}
class PlayerStreamInfoCtor {
}
class PlayerSubtitleInfo extends GstPlayer.PlayerStreamInfo {
constructor(initializerList ?: PlayerSubtitleInfoCtor);
getLanguage(): string;
//TypeScript is complete garbage:
}
class PlayerSubtitleInfoCtor {
}
class PlayerVideoInfo extends GstPlayer.PlayerStreamInfo {
constructor(initializerList ?: PlayerVideoInfoCtor);
getBitrate(): number;
getFramerate(fpsN: number, fpsD: number): void;
getHeight(): number;
getMaxBitrate(): number;
getPixelAspectRatio(parN: number, parD: number): void;
getWidth(): number;
//TypeScript is complete garbage:
}
class PlayerVideoInfoCtor {
}
class PlayerVideoOverlayVideoRenderer extends GObject.Object implements GstPlayer.PlayerVideoRenderer {
constructor(initializerList ?: PlayerVideoOverlayVideoRendererCtor);
videoSink : Gst.Element;
windowHandle : void;
static New(): GstPlayer.PlayerVideoRenderer;
static NewWithSink(videoSink: Gst.Element): GstPlayer.PlayerVideoRenderer;
expose(): void;
getRenderRectangle(x ?: number, y ?: number, width ?: number, height ?: number): void;
getWindowHandle(): void;
setRenderRectangle(x: number, y: number, width: number, height: number): void;
setWindowHandle(): void;
//TypeScript is complete garbage:
}
class PlayerVideoOverlayVideoRendererCtor {
windowHandle ?: number | bigint;
videoSink ?: Gst.Element;
}
}

1974
GstVideo.d.ts vendored Normal file

File diff suppressed because it is too large Load Diff

18221
Gtk.d.ts vendored Normal file

File diff suppressed because it is too large Load Diff

2425
GtkSource.d.ts vendored Normal file

File diff suppressed because it is too large Load Diff

1193
HarfBuzz.d.ts vendored Normal file

File diff suppressed because it is too large Load Diff

1418
Pango.d.ts vendored Normal file

File diff suppressed because it is too large Load Diff

509
cairo.d.ts vendored Normal file
View File

@ -0,0 +1,509 @@
declare namespace cairo {
class Status {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kSuccess": Status
static readonly "kNoMemory": Status
static readonly "kInvalidRestore": Status
static readonly "kInvalidPopGroup": Status
static readonly "kNoCurrentPoint": Status
static readonly "kInvalidMatrix": Status
static readonly "kInvalidStatus": Status
static readonly "kNullPointer": Status
static readonly "kInvalidString": Status
static readonly "kInvalidPathData": Status
static readonly "kReadError": Status
static readonly "kWriteError": Status
static readonly "kSurfaceFinished": Status
static readonly "kSurfaceTypeMismatch": Status
static readonly "kPatternTypeMismatch": Status
static readonly "kInvalidContent": Status
static readonly "kInvalidFormat": Status
static readonly "kInvalidVisual": Status
static readonly "kFileNotFound": Status
static readonly "kInvalidDash": Status
static readonly "kInvalidDscComment": Status
static readonly "kInvalidIndex": Status
static readonly "kClipNotRepresentable": Status
static readonly "kTempFileError": Status
static readonly "kInvalidStride": Status
static readonly "kFontTypeMismatch": Status
static readonly "kUserFontImmutable": Status
static readonly "kUserFontError": Status
static readonly "kNegativeCount": Status
static readonly "kInvalidClusters": Status
static readonly "kInvalidSlant": Status
static readonly "kInvalidWeight": Status
static readonly "kInvalidSize": Status
static readonly "kUserFontNotImplemented": Status
static readonly "kDeviceTypeMismatch": Status
static readonly "kDeviceError": Status
static readonly "kInvalidMeshConstruction": Status
static readonly "kDeviceFinished": Status
static readonly "kJbig2GlobalMissing": Status
}
class Content {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kColor": Content
static readonly "kAlpha": Content
static readonly "kColorAlpha": Content
}
class Operator {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kClear": Operator
static readonly "kSource": Operator
static readonly "kOver": Operator
static readonly "kIn": Operator
static readonly "kOut": Operator
static readonly "kAtop": Operator
static readonly "kDest": Operator
static readonly "kDestOver": Operator
static readonly "kDestIn": Operator
static readonly "kDestOut": Operator
static readonly "kDestAtop": Operator
static readonly "kXOr": Operator
static readonly "kAdd": Operator
static readonly "kSaturate": Operator
static readonly "kMultiply": Operator
static readonly "kScreen": Operator
static readonly "kOverlay": Operator
static readonly "kDarken": Operator
static readonly "kLighten": Operator
static readonly "kColorDodge": Operator
static readonly "kColorBurn": Operator
static readonly "kHardLight": Operator
static readonly "kSoftLight": Operator
static readonly "kDifference": Operator
static readonly "kExclusion": Operator
static readonly "kHslHue": Operator
static readonly "kHslSaturation": Operator
static readonly "kHslColor": Operator
static readonly "kHslLuminosity": Operator
}
class Antialias {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kDefault": Antialias
static readonly "kNone": Antialias
static readonly "kGray": Antialias
static readonly "kSubpixel": Antialias
static readonly "kFast": Antialias
static readonly "kGood": Antialias
static readonly "kBest": Antialias
}
class FillRule {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kWinding": FillRule
static readonly "kEvenOdd": FillRule
}
class LineCap {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kButt": LineCap
static readonly "kRound": LineCap
static readonly "kSquare": LineCap
}
class LineJoin {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kMiter": LineJoin
static readonly "kRound": LineJoin
static readonly "kBevel": LineJoin
}
class TextClusterFlags {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kBackward": TextClusterFlags
}
class FontSlant {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kNormal": FontSlant
static readonly "kItalic": FontSlant
static readonly "kOblique": FontSlant
}
class FontWeight {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kNormal": FontWeight
static readonly "kBold": FontWeight
}
class SubpixelOrder {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kDefault": SubpixelOrder
static readonly "kRgb": SubpixelOrder
static readonly "kBgr": SubpixelOrder
static readonly "kVrgb": SubpixelOrder
static readonly "kVbgr": SubpixelOrder
}
class HintStyle {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kDefault": HintStyle
static readonly "kNone": HintStyle
static readonly "kSlight": HintStyle
static readonly "kMedium": HintStyle
static readonly "kFull": HintStyle
}
class HintMetrics {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kDefault": HintMetrics
static readonly "kOff": HintMetrics
static readonly "kOn": HintMetrics
}
class FontType {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kToy": FontType
static readonly "kFt": FontType
static readonly "kWin32": FontType
static readonly "kQuartz": FontType
static readonly "kUser": FontType
}
class PathDataType {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kMoveTo": PathDataType
static readonly "kLineTo": PathDataType
static readonly "kCurveTo": PathDataType
static readonly "kClosePath": PathDataType
}
class DeviceType {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kDrm": DeviceType
static readonly "kGl": DeviceType
static readonly "kScript": DeviceType
static readonly "kXCb": DeviceType
static readonly "kXLib": DeviceType
static readonly "kXMl": DeviceType
static readonly "kCogl": DeviceType
static readonly "kWin32": DeviceType
static readonly "kInvalid": DeviceType
}
class SurfaceType {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kImage": SurfaceType
static readonly "kPdf": SurfaceType
static readonly "kPs": SurfaceType
static readonly "kXLib": SurfaceType
static readonly "kXCb": SurfaceType
static readonly "kGlitz": SurfaceType
static readonly "kQuartz": SurfaceType
static readonly "kWin32": SurfaceType
static readonly "kBeos": SurfaceType
static readonly "kDirectfb": SurfaceType
static readonly "kSvg": SurfaceType
static readonly "kOs2": SurfaceType
static readonly "kWin32Printing": SurfaceType
static readonly "kQuartzImage": SurfaceType
static readonly "kScript": SurfaceType
static readonly "kQt": SurfaceType
static readonly "kRecording": SurfaceType
static readonly "kVg": SurfaceType
static readonly "kGl": SurfaceType
static readonly "kDrm": SurfaceType
static readonly "kTee": SurfaceType
static readonly "kXMl": SurfaceType
static readonly "kSkia": SurfaceType
static readonly "kSubsurface": SurfaceType
static readonly "kCogl": SurfaceType
}
class Format {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kInvalid": Format
static readonly "kArgb32": Format
static readonly "kRgb24": Format
static readonly "kA8": Format
static readonly "kA1": Format
static readonly "kRgb16565": Format
static readonly "kRgb30": Format
}
class PatternType {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kSolid": PatternType
static readonly "kSurface": PatternType
static readonly "kLinear": PatternType
static readonly "kRadial": PatternType
static readonly "kMesh": PatternType
static readonly "kRasterSource": PatternType
}
class Extend {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kNone": Extend
static readonly "kRepeat": Extend
static readonly "kReflect": Extend
static readonly "kPad": Extend
}
class Filter {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kFast": Filter
static readonly "kGood": Filter
static readonly "kBest": Filter
static readonly "kNearest": Filter
static readonly "kBilinear": Filter
static readonly "kGaussian": Filter
}
class RegionOverlap {
// Enumerations hack...
toString(radix ? : number | undefined) : string;
toFixed(fractionDigits ? : number | undefined) : string;
toExponential(fractionDigits ? : number | undefined) : string;
toPrecision(precision ? : number | undefined) : string;
valueOf() : number;
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
static [s:number]: string;
static readonly "kIn": RegionOverlap
static readonly "kOut": RegionOverlap
static readonly "kPart": RegionOverlap
}
class Context {
}
class Device {
}
class Surface {
}
class Matrix {
}
class Pattern {
}
class Region {
}
class FontOptions {
}
class FontFace {
}
class ScaledFont {
}
class Path {
}
class Rectangle {
x : number;
y : number;
width : number;
height : number;
}
class RectangleInt {
x : number;
y : number;
width : number;
height : number;
}
}