@idlizer/core 2.1.10-arktscgen-4 → 2.1.10-arktscgen-6

package/build/lib/src/from-idl/webidl2-utils.js

@@ -1,87 +0,0 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { IDLEntity } from "../idl";
-export function isEnum(node) {
-    return node.type === "enum";
-}
-export function isInterface(node) {
-    return node.type === "interface";
-}
-export function isImport(node) {
-    return node.type === "import";
-}
-export function isPackage(node) {
-    return node.type === "package";
-}
-export function isClass(node) {
-    var _a, _b;
-    return isInterface(node)
-        && ((_b = (_a = node.extAttrs.find(it => it.name === "Entity")) === null || _a === void 0 ? void 0 : _a.rhs) === null || _b === void 0 ? void 0 : _b.value) === IDLEntity.Class;
-}
-export function isCallback(node) {
-    return node.type === "callback";
-}
-export function isTypedef(node) {
-    return node.type === "typedef";
-}
-export function isDictionary(node) {
-    return node.type === "dictionary";
-}
-export function isAttribute(node) {
-    return node.type === "attribute";
-}
-export function isOperation(node) {
-    return node.type === "operation";
-}
-export function isConstructor(node) {
-    return node.type === "constructor";
-}
-export function isUnionTypeDescription(node) {
-    return node.union;
-}
-export function isSingleTypeDescription(node) {
-    return (typeof node.idlType === "string");
-}
-export function isSequenceTypeDescription(node) {
-    return node.generic === "sequence";
-}
-export function isPromiseTypeDescription(node) {
-    return node.generic === "Promise";
-}
-export function isRecordTypeDescription(node) {
-    return node.generic === "record";
-}
-export function isConstant(node) {
-    return node.type === "const";
-}
-export function isUnspecifiedGenericTypeDescription(node) {
-    switch (node.generic) {
-        case "FrozenArray":
-        case "ObservableArray":
-        case "Promise":
-        case "record":
-        case "sequence":
-        case "":
-            return false;
-    }
-    return true;
-}
-export function isOptional(node) {
-    return node.extAttrs
-        .map((it) => it.name)
-        .map((it) => it.toLowerCase())
-        .includes("optional");
-}
-//# sourceMappingURL=webidl2-utils.js.map

package/build/lib/src/idl.d.ts

@@ -1,439 +0,0 @@
-import { stringOrNone } from "./util";
-import { Location } from "./diagnostictypes";
-export declare enum IDLKind {
-    Interface = "Interface",
-    Import = "Import",
-    Callback = "Callback",
-    Const = "Const",
-    Property = "Property",
-    Parameter = "Parameter",
-    Method = "Method",
-    Callable = "Callable",
-    Constructor = "Constructor",
-    Enum = "Enum",
-    EnumMember = "EnumMember",
-    Typedef = "Typedef",
-    PrimitiveType = "PrimitiveType",
-    ContainerType = "ContainerType",
-    UnspecifiedGenericType = "UnspecifiedGenericType",
-    ReferenceType = "ReferenceType",
-    UnionType = "UnionType",
-    TypeParameterType = "TypeParameterType",
-    OptionalType = "OptionalType",
-    Version = "Version",
-    Namespace = "Namespace",
-    File = "File"
-}
-export declare enum IDLEntity {
-    Class = "Class",
-    Interface = "Interface",
-    Import = "Import",
-    Intersection = "Intersection",
-    Literal = "Literal",
-    NamedTuple = "NamedTuple",
-    Tuple = "Tuple"
-}
-export declare enum IDLExtendedAttributes {
-    Accessor = "Accessor",
-    Annotations = "Annotations",
-    Async = "Async",
-    CallSignature = "CallSignature",
-    CommonMethod = "CommonMethod",
-    Component = "Component",
-    ComponentInterface = "ComponentInterface",
-    ComponentModifier = "ComponentModifier",
-    Deprecated = "Deprecated",
-    Documentation = "Documentation",
-    DtsName = "DtsName",
-    DtsTag = "DtsTag",
-    Entity = "Entity",
-    Extends = "Extends",
-    ExtensionMethod = "ExtensionMethod",
-    Import = "Import",
-    DefaultExport = "DefaultExport",
-    IndexSignature = "IndexSignature",
-    Interfaces = "Interfaces",
-    NativeModule = "NativeModule",
-    Optional = "Optional",
-    UnionOnlyNull = "OptionalOnlyNull",
-    UnionWithNull = "OptionalWithNull",
-    OriginalEnumMemberName = "OriginalEnumMemberName",
-    OriginalGenericName = "OriginalGenericName",
-    Predefined = "Predefined",
-    Protected = "Protected",
-    Abstract = "Abstract",
-    Synthetic = "Synthetic",
-    Throws = "Throws",
-    TraceKey = "TraceKey",
-    TypeAnnotations = "TypeAnnotations",
-    TypeArguments = "TypeArguments",
-    TypeParameters = "TypeParameters",
-    TypeParametersDefaults = "TypeParametersDefaults",
-    VerbatimDts = "VerbatimDts",
-    HandWrittenImplementation = "HandWrittenImplementation",
-    ExtraMethod = "ExtraMethod",
-    OverloadAlias = "OverloadAlias",
-    OverloadPriority = "OverloadPriority",
-    TransformOnSerialize = "TransformOnSerialize"
-}
-export declare enum IDLAccessorAttribute {
-    Getter = "Getter",
-    Setter = "Setter"
-}
-export interface IDLExtendedAttribute {
-    name: string;
-    value?: string;
-    typesValue?: IDLType[];
-    nameLocation?: Location;
-    valueLocation?: Location;
-}
-export interface IDLNode {
-    _idlNodeBrand: any;
-    kind: IDLKind;
-    parent?: IDLNode;
-    fileName?: string;
-    extendedAttributes?: IDLExtendedAttribute[];
-    documentation?: string;
-    nodeLocation?: Location;
-    nameLocation?: Location;
-    valueLocation?: Location;
-}
-export interface IDLFile extends IDLNode {
-    packageClause: string[];
-    entries: IDLEntry[];
-    text?: string;
-    fileName?: string;
-}
-export interface IDLNamedNode extends IDLNode {
-    _idlNamedNodeBrand: any;
-    name: string;
-}
-export interface IDLEntry extends IDLNode, IDLNamedNode {
-    _idlEntryBrand: any;
-    comment?: string;
-}
-export interface IDLType extends IDLNode {
-    _idlTypeBrand: any;
-}
-export interface IDLTypedef extends IDLEntry {
-    kind: IDLKind.Typedef;
-    type: IDLType;
-    typeParameters?: string[];
-}
-export interface IDLPrimitiveType extends IDLType, IDLNamedNode {
-    kind: IDLKind.PrimitiveType;
-}
-export interface IDLOptionalType extends IDLType {
-    kind: IDLKind.OptionalType;
-    type: IDLType;
-}
-export type IDLContainerKind = 'sequence' | 'record' | 'Promise';
-export interface IDLContainerType extends IDLType {
-    kind: IDLKind.ContainerType;
-    elementType: IDLType[];
-    containerKind: IDLContainerKind;
-}
-export interface IDLReferenceType extends IDLType, IDLNamedNode {
-    kind: IDLKind.ReferenceType;
-    typeArguments?: IDLType[];
-}
-export interface IDLUnspecifiedGenericType extends IDLType, IDLNamedNode {
-    kind: IDLKind.UnspecifiedGenericType;
-    typeArguments: IDLType[];
-}
-export interface IDLUnionType extends IDLType, IDLNamedNode {
-    kind: IDLKind.UnionType;
-    types: IDLType[];
-}
-export interface IDLTypeParameterType extends IDLType, IDLNamedNode {
-    kind: IDLKind.TypeParameterType;
-}
-export interface IDLVersion extends IDLEntry {
-    kind: IDLKind.Version;
-    value: string[];
-}
-export interface IDLVariable extends IDLEntry {
-    type?: IDLType;
-}
-export interface IDLTypedEntry extends IDLEntry {
-    type: IDLType;
-}
-export interface IDLEnum extends IDLEntry {
-    kind: IDLKind.Enum;
-    elements: IDLEnumMember[];
-}
-export interface IDLEnumMember extends IDLEntry {
-    kind: IDLKind.EnumMember;
-    parent: IDLEnum;
-    type: IDLPrimitiveType;
-    initializer: number | string | undefined;
-}
-export interface IDLConstant extends IDLTypedEntry {
-    kind: IDLKind.Const;
-    type: IDLType;
-    value: string;
-}
-export interface IDLProperty extends IDLTypedEntry, IDLNamedNode {
-    kind: IDLKind.Property;
-    type: IDLType;
-    isReadonly: boolean;
-    isStatic: boolean;
-    isOptional: boolean;
-}
-export interface IDLParameter extends IDLTypedEntry, IDLNamedNode {
-    kind: IDLKind.Parameter;
-    isVariadic: boolean;
-    isOptional: boolean;
-    type: IDLType;
-}
-export interface IDLSignature extends IDLEntry {
-    typeParameters?: string[];
-    parameters: IDLParameter[];
-    returnType?: IDLType;
-}
-export interface IDLFunction extends IDLSignature {
-    isAsync: boolean;
-}
-export interface IDLMethod extends IDLFunction, IDLNamedNode {
-    kind: IDLKind.Method;
-    returnType: IDLType;
-    isStatic: boolean;
-    isOptional: boolean;
-    isFree: boolean;
-}
-export interface IDLCallable extends IDLFunction {
-    kind: IDLKind.Callable;
-    returnType: IDLType;
-    isStatic: boolean;
-}
-export interface IDLConstructor extends IDLSignature {
-    kind: IDLKind.Constructor;
-}
-export declare enum IDLInterfaceSubkind {
-    Interface = 0,
-    Class = 1,
-    AnonymousInterface = 2,
-    Tuple = 3
-}
-export interface IDLInterface extends IDLEntry {
-    kind: IDLKind.Interface;
-    subkind: IDLInterfaceSubkind;
-    typeParameters?: string[];
-    inheritance: IDLReferenceType[];
-    constructors: IDLConstructor[];
-    constants: IDLConstant[];
-    properties: IDLProperty[];
-    methods: IDLMethod[];
-    callables: IDLCallable[];
-}
-export interface IDLImport extends IDLEntry {
-    kind: IDLKind.Import;
-    clause: string[];
-}
-export interface IDLNamespace extends IDLEntry {
-    kind: IDLKind.Namespace;
-    members: IDLEntry[];
-}
-export interface IDLCallback extends IDLEntry, IDLSignature {
-    kind: IDLKind.Callback;
-    returnType: IDLType;
-}
-type IDLNodeVisitorVoid = (node: IDLNode) => void;
-type IDLNodeVisitorValue = (node: IDLNode) => () => void;
-type IDLNodeVisitor = IDLNodeVisitorVoid | IDLNodeVisitorValue;
-export declare function forEachChild(node: IDLNode, cbEnter: IDLNodeVisitor, cbLeave?: (entry: IDLNode) => void): void;
-/** Updates tree in place! */
-export declare function updateEachChild(node: IDLNode, op: (node: IDLNode) => IDLNode, cbLeave?: (entry: IDLNode) => void): IDLNode;
-export declare function isNamedNode(type: IDLNode): type is IDLNamedNode;
-export declare function forceAsNamedNode(type: IDLNode): IDLNamedNode;
-export declare function isFile(node: IDLNode): node is IDLFile;
-export declare function isUndefinedType(type: IDLNode): type is IDLPrimitiveType;
-export declare function isVoidType(type: IDLNode): type is IDLPrimitiveType;
-export declare function isPrimitiveType(type: IDLNode): type is IDLPrimitiveType;
-export declare function isContainerType(type: IDLNode): type is IDLContainerType;
-export declare function isReferenceType(type: IDLNode): type is IDLReferenceType;
-export declare function isUnspecifiedGenericType(type: IDLNode): type is IDLUnspecifiedGenericType;
-export declare function isEnum(type: IDLNode): type is IDLEnum;
-export declare function isEnumMember(type: IDLNode): type is IDLEnumMember;
-export declare function isUnionType(type: IDLNode): type is IDLUnionType;
-export declare function isTypeParameterType(type: IDLNode): type is IDLTypeParameterType;
-export declare function isInterface(node: IDLNode): node is IDLInterface;
-export declare function isImport(type: IDLNode): type is IDLImport;
-export declare function isCallable(node: IDLNode): node is IDLCallable;
-export declare function isMethod(node: IDLNode): node is IDLMethod;
-export declare function isParameter(node: IDLNode): node is IDLParameter;
-export declare function isConstructor(node: IDLNode): node is IDLConstructor;
-export declare function isProperty(node: IDLNode): node is IDLProperty;
-export declare function isCallback(node: IDLNode): node is IDLCallback;
-export declare function isInterfaceSubkind(idl: IDLInterface): boolean;
-export declare function isClassSubkind(idl: IDLInterface): boolean;
-export declare function isConstant(node: IDLNode): node is IDLConstant;
-export declare function isTypedef(node: IDLNode): node is IDLTypedef;
-export declare function isType(node: IDLNode): node is IDLType;
-export declare function isEntry(node: IDLNode): node is IDLEntry;
-export declare function isNamespace(node: IDLNode): node is IDLNamespace;
-export declare function isSyntheticEntry(node: IDLNode): boolean;
-export declare function isOptionalType(type: IDLNode): type is IDLOptionalType;
-export declare function isVersion(node: IDLNode): node is IDLVersion;
-export declare function createOptionalType(element: IDLType, nodeInitializer?: IDLNodeInitializer): IDLOptionalType;
-export declare const IDLPointerType: IDLPrimitiveType;
-export declare const IDLVoidType: IDLPrimitiveType;
-export declare const IDLBooleanType: IDLPrimitiveType;
-export declare const IDLI8Type: IDLPrimitiveType;
-export declare const IDLU8Type: IDLPrimitiveType;
-export declare const IDLI16Type: IDLPrimitiveType;
-export declare const IDLU16Type: IDLPrimitiveType;
-export declare const IDLI32Type: IDLPrimitiveType;
-export declare const IDLU32Type: IDLPrimitiveType;
-export declare const IDLI64Type: IDLPrimitiveType;
-export declare const IDLU64Type: IDLPrimitiveType;
-export declare const IDLF16Type: IDLPrimitiveType;
-export declare const IDLF32Type: IDLPrimitiveType;
-export declare const IDLF64Type: IDLPrimitiveType;
-export declare const IDLBigintType: IDLPrimitiveType;
-export declare const IDLNumberType: IDLPrimitiveType;
-export declare const IDLStringType: IDLPrimitiveType;
-export declare const IDLAnyType: IDLPrimitiveType;
-export declare const IDLUndefinedType: IDLPrimitiveType;
-export declare const IDLUnknownType: IDLPrimitiveType;
-export declare const IDLObjectType: IDLPrimitiveType;
-export declare const IDLThisType: IDLPrimitiveType;
-export declare const IDLDate: IDLPrimitiveType;
-export declare const IDLBufferType: IDLPrimitiveType;
-export declare const IDLUint8ArrayType: IDLContainerType;
-export declare const IDLSerializerBuffer: IDLPrimitiveType;
-export declare const IDLFunctionType: IDLPrimitiveType;
-export declare const IDLCustomObjectType: IDLPrimitiveType;
-export declare const IDLInteropReturnBufferType: IDLPrimitiveType;
-export declare const IDLNullTypeName = "idlize.stdlib.Null";
-export type IDLNodeInitializer = {
-    extendedAttributes?: IDLExtendedAttribute[];
-    fileName?: string;
-    documentation?: string;
-    nodeLocation?: Location;
-    nameLocation?: Location;
-    valueLocation?: Location;
-};
-export declare function createNamespace(name: string, members?: IDLEntry[], nodeInitializer?: IDLNodeInitializer): IDLNamespace;
-export declare function linkParentBack<T extends IDLNode>(node: T): T;
-export declare function getNamespacesPathFor(node: IDLNode): IDLNamespace[];
-export declare function getFileFor(node: IDLNode): IDLFile | undefined;
-export declare function isEqualByQualifedName(a?: IDLNamedNode, b?: IDLNamedNode, pattern?: QNPattern): boolean;
-export declare function getPackageClause(node: IDLNode): string[];
-export declare function getPackageName(node: IDLNode): string;
-export declare function isInPackage(entry: IDLEntry | IDLFile, packageName: string, exactMatch?: boolean): boolean;
-export declare function getNamespaceName(a: IDLEntry): string;
-export type QNPattern = "package.namespace.name" | "namespace.name" | "name";
-export declare function deriveQualifiedNameFrom(name: string, from: IDLNode): string;
-export declare function getQualifiedName(a: IDLNode, pattern: QNPattern): string;
-export declare function getFQName(a: IDLNode): string;
-export declare function createVersion(value: string[], nodeInitializer?: IDLNodeInitializer): IDLVersion;
-export declare function fetchNamespaceFrom(pointOfView?: IDLNode): IDLNamespace | undefined;
-export declare function createReferenceType(name: string, typeArguments?: IDLType[], nodeInitializer?: IDLNodeInitializer): IDLReferenceType;
-export declare function createReferenceType(source: IDLEntry, typeArguments?: IDLType[], nodeInitializer?: IDLNodeInitializer): IDLReferenceType;
-export declare function createUnspecifiedGenericType(name: string, typeArguments: IDLType[], nodeInitializer?: IDLNodeInitializer): IDLUnspecifiedGenericType;
-export declare function entityToType(entity: IDLNode): IDLType;
-export declare function createContainerType(container: IDLContainerKind, element: IDLType[], nodeInitializer?: IDLNodeInitializer): IDLContainerType;
-export declare function createUnionType(types: IDLType[], name?: string, nodeInitializer?: IDLNodeInitializer): IDLUnionType;
-export declare function createFile(entries: IDLEntry[], fileName?: string, packageClause?: string[], nodeInitializer?: IDLNodeInitializer): IDLFile;
-export declare function createImport(clause: string[], name?: string, nodeInitializer?: IDLNodeInitializer): IDLImport;
-export declare function createEnum(name: string, elements: IDLEnumMember[], nodeInitializer: IDLNodeInitializer): IDLEnum;
-export declare function createEnumMember(name: string, parent: IDLEnum, type: IDLPrimitiveType, initializer: number | string | undefined, nodeInitializer?: IDLNodeInitializer): IDLEnumMember;
-export declare function createInterface(name: string, subkind: IDLInterfaceSubkind, inheritance?: IDLReferenceType[], constructors?: IDLConstructor[], constants?: IDLConstant[], properties?: IDLProperty[], methods?: IDLMethod[], callables?: IDLCallable[], typeParameters?: string[], nodeInitializer?: IDLNodeInitializer): IDLInterface;
-export declare function createProperty(name: string, type: IDLType, isReadonly?: boolean, isStatic?: boolean, isOptional?: boolean, nodeInitializer?: IDLNodeInitializer): IDLProperty;
-export declare function createParameter(name: string, type: IDLType, isOptional?: boolean, isVariadic?: boolean, nodeInitializer?: IDLNodeInitializer): IDLParameter;
-export type IDLMethodInitializer = {
-    isAsync: boolean;
-    isStatic: boolean;
-    isOptional: boolean;
-    isFree: boolean;
-};
-export declare function createMethod(name: string, parameters: IDLParameter[], returnType: IDLType, methodInitializer?: IDLMethodInitializer, nodeInitializer?: IDLNodeInitializer, typeParameters?: string[]): IDLMethod;
-export type IDLCallableInitializer = {
-    isAsync: boolean;
-    isStatic: boolean;
-};
-export declare function createCallable(name: string, parameters: IDLParameter[], returnType: IDLType, callableInitializer: IDLCallableInitializer, nodeInitializer?: IDLNodeInitializer, typeParameters?: string[]): IDLCallable;
-export declare function createConstructor(parameters: IDLParameter[], returnType: IDLType | undefined, nodeInitializer?: IDLNodeInitializer): IDLConstructor;
-export declare function createCallback(name: string, parameters: IDLParameter[], returnType: IDLType, nodeInitializer?: IDLNodeInitializer, typeParameters?: string[]): IDLCallback;
-export declare function createTypeParameterReference(name: string, nodeInitializer?: IDLNodeInitializer): IDLTypeParameterType;
-export declare function createTypedef(name: string, type: IDLType, typeParameters?: string[], nodeInitializer?: IDLNodeInitializer): IDLTypedef;
-export declare function createConstant(name: string, type: IDLType, value: string, nodeInitializer?: IDLNodeInitializer): IDLConstant;
-export declare function clone<T extends IDLNode>(node: T): T;
-export declare function hasTypeParameters(entry: IDLEntry): boolean;
-export declare function escapeIDLKeyword(name: string): string;
-export declare function unescapeKeyword(name: string): string;
-type PrintedIndentInc = "[[indent-inc]]";
-type PrintedIndentDec = "[[indent-dec]]";
-type PrintedLine = undefined | string | PrintedIndentInc | PrintedIndentDec;
-type PrintTypeOptions = {
-    [key: string]: any;
-};
-export declare function printType(type: IDLType | IDLInterface | undefined, options?: PrintTypeOptions): string;
-export declare function printReturnType(type: IDLType | IDLInterface | undefined): string;
-export declare function printParameters(parameters: IDLParameter[] | undefined): string;
-export declare function printConstructor(idl: IDLConstructor): PrintedLine[];
-export declare function nameWithType(idl: IDLVariable, isVariadic?: boolean, isOptional?: boolean): string;
-export declare function printConstant(idl: IDLConstant): PrintedLine[];
-export declare function printProperty(idl: IDLProperty): PrintedLine[];
-export declare function printExtendedAttributes(idl: IDLNode, indentLevel: number): PrintedLine[];
-export declare const attributesToQuote: Set<IDLExtendedAttributes>;
-export declare function printFunction(idl: IDLFunction): PrintedLine[];
-export declare function printMethod(idl: IDLMethod): PrintedLine[];
-export declare function printPackage(idl: IDLFile): PrintedLine[];
-export declare function printImport(idl: IDLImport): PrintedLine[];
-export declare function printNamespace(idl: IDLNamespace): PrintedLine[];
-export declare function printCallback(idl: IDLCallback): PrintedLine[];
-export declare function printScoped(idl: IDLEntry): PrintedLine[];
-export declare function printInterface(idl: IDLInterface): PrintedLine[];
-export declare function printEnumMember(idl: IDLEnumMember): PrintedLine[];
-export declare function printEnum(idl: IDLEnum, skipInitializers: boolean): PrintedLine[];
-export declare function printTypedef(idl: IDLTypedef): PrintedLine[];
-export declare function printIDL(idl: IDLNode, options?: Partial<IDLPrintOptions>): PrintedLine[];
-export interface IDLPrintOptions {
-    verifyIdl: boolean;
-    disableEnumInitializers: boolean;
-    allowUnknownKinds: boolean;
-}
-export declare function toIDLString(file: IDLFile, options: Partial<IDLPrintOptions>): string;
-export declare function verifyIDLString(source: string): true;
-export declare function hasExtAttribute(node: IDLNode, attribute: IDLExtendedAttributes): boolean;
-export declare function getExtAttribute(node: IDLNode, name: IDLExtendedAttributes): stringOrNone;
-export declare function removeExtAttribute(node: IDLNode, name: IDLExtendedAttributes): void;
-export declare function updateExtAttribute(node: IDLNode, name: IDLExtendedAttributes, value: string | undefined): void;
-export declare function getVerbatimDts(node: IDLEntry): stringOrNone;
-export declare const IDLContainerUtils: {
-    isRecord: (x: IDLNode) => boolean;
-    isSequence: (x: IDLNode) => boolean;
-    isPromise: (x: IDLNode) => boolean;
-};
-/**
- * @returns tuple of qualifier name and real type name
- */
-export declare function decomposeQualifiedName(type: IDLReferenceType): [string | undefined, string];
-export declare function qualifiedNameStartsWith(node: IDLNode | string[], template: string[]): boolean;
-export declare function maybeUnwrapOptionalType(type: IDLType): IDLType;
-export declare function maybeOptional(type: IDLType, optional?: boolean): IDLType;
-export declare const DebugUtils: {
-    debugPrintType: (type: IDLType) => string;
-};
-export declare function forEachFunction(node: IDLNode, cb: (node: IDLFunction) => void): void;
-export declare function asPromise(type?: IDLType): IDLContainerType | undefined;
-export declare function transformMethodsAsync2ReturnPromise(entry: IDLEntry): void;
-export declare function transformMethodsReturnPromise2Async(entry: IDLEntry): void;
-export interface SignatureTag {
-    index: number;
-    name: string;
-    value: string;
-}
-export declare function fetchSignatureTags(node: IDLSignature): SignatureTag[];
-export declare function mixMethodParametersAndTags(node: IDLSignature): (IDLParameter | SignatureTag)[];
-export declare function isHandwritten(decl: IDLEntry): boolean;
-export declare function isStringEnum(decl: IDLEnum): boolean;
-export declare function linearizeNamespaceMembers(entries: IDLEntry[]): IDLEntry[];
-export declare function extremumOfOrdinals(enumEntry: IDLEnum): {
-    low: number;
-    high: number;
-};
-export {};
-//# sourceMappingURL=idl.d.ts.map