export declare class STEPCAFControl_Reader {
  Init(WS: Handle_XSControl_WorkSession, scratch: Standard_Boolean): void;
  ReadFile(filename: Standard_CString): IFSelect_ReturnStatus;
  NbRootsForTransfer(): Graphic3d_ZLayerId;
  TransferOneRoot(num: Graphic3d_ZLayerId, doc: Handle_TDocStd_Document, theProgress: Message_ProgressRange): Standard_Boolean;
  Transfer_1(doc: Handle_TDocStd_Document, theProgress: Message_ProgressRange): Standard_Boolean;
  Perform_1(filename: XCAFDoc_PartId, doc: Handle_TDocStd_Document, theProgress: Message_ProgressRange): Standard_Boolean;
  Perform_2(filename: Standard_CString, doc: Handle_TDocStd_Document, theProgress: Message_ProgressRange): Standard_Boolean;
  ExternFiles(): any;
  ExternFile(name: Standard_CString, ef: Handle_STEPCAFControl_ExternFile): Standard_Boolean;
  ChangeReader(): STEPControl_Reader;
  Reader(): STEPControl_Reader;
  static FindInstance(NAUO: Handle_StepRepr_NextAssemblyUsageOccurrence, STool: Handle_XCAFDoc_ShapeTool, Tool: STEPConstruct_Tool, ShapeLabelMap: XCAFDoc_DataMapOfShapeLabel): TDF_Label;
  SetColorMode(colormode: Standard_Boolean): void;
  GetColorMode(): Standard_Boolean;
  SetNameMode(namemode: Standard_Boolean): void;
  GetNameMode(): Standard_Boolean;
  SetLayerMode(layermode: Standard_Boolean): void;
  GetLayerMode(): Standard_Boolean;
  SetPropsMode(propsmode: Standard_Boolean): void;
  GetPropsMode(): Standard_Boolean;
  SetSHUOMode(shuomode: Standard_Boolean): void;
  GetSHUOMode(): Standard_Boolean;
  SetGDTMode(gdtmode: Standard_Boolean): void;
  GetGDTMode(): Standard_Boolean;
  SetMatMode(matmode: Standard_Boolean): void;
  GetMatMode(): Standard_Boolean;
  SetViewMode(viewmode: Standard_Boolean): void;
  GetViewMode(): Standard_Boolean;
  GetShapeLabelMap(): XCAFDoc_DataMapOfShapeLabel;
  delete(): void;
}

  export declare class STEPCAFControl_Reader_1 extends STEPCAFControl_Reader {
    constructor();
  }

  export declare class STEPCAFControl_Reader_2 extends STEPCAFControl_Reader {
    constructor(WS: Handle_XSControl_WorkSession, scratch: Standard_Boolean);
  }

export declare class Image_PixMap extends Standard_Transient {
  constructor()
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  static IsBigEndianHost(): Standard_Boolean;
  static SwapRgbaBgra(theImage: Image_PixMap): Standard_Boolean;
  static ToBlackWhite(theImage: Image_PixMap): void;
  static FlipY(theImage: Image_PixMap): Standard_Boolean;
  static DefaultAllocator(): Handle_NCollection_BaseAllocator;
  static ImageFormatToString_1(theFormat: Image_Format): Standard_CString;
  static ImageFormatToString_2(theFormat: Image_CompressedFormat): Standard_CString;
  Format(): Image_Format;
  SetFormat(thePixelFormat: Image_Format): void;
  Width(): Standard_ThreadId;
  Height(): Standard_ThreadId;
  SizeX(): Standard_ThreadId;
  SizeY(): Standard_ThreadId;
  Ratio(): Standard_Real;
  IsEmpty(): Standard_Boolean;
  PixelColor(theX: Graphic3d_ZLayerId, theY: Graphic3d_ZLayerId, theToLinearize: Standard_Boolean): Quantity_ColorRGBA;
  SetPixelColor_1(theX: Graphic3d_ZLayerId, theY: Graphic3d_ZLayerId, theColor: Quantity_Color, theToDeLinearize: Standard_Boolean): void;
  SetPixelColor_2(theX: Graphic3d_ZLayerId, theY: Graphic3d_ZLayerId, theColor: Quantity_ColorRGBA, theToDeLinearize: Standard_Boolean): void;
  InitWrapper(thePixelFormat: Image_Format, theDataPtr: Standard_Byte, theSizeX: Standard_ThreadId, theSizeY: Standard_ThreadId, theSizeRowBytes: Standard_ThreadId): Standard_Boolean;
  InitTrash(thePixelFormat: Image_Format, theSizeX: Standard_ThreadId, theSizeY: Standard_ThreadId, theSizeRowBytes: Standard_ThreadId): Standard_Boolean;
  InitCopy(theCopy: Image_PixMap): Standard_Boolean;
  InitZero(thePixelFormat: Image_Format, theSizeX: Standard_ThreadId, theSizeY: Standard_ThreadId, theSizeRowBytes: Standard_ThreadId, theValue: Standard_Byte): Standard_Boolean;
  Clear(): void;
  IsTopDown(): Standard_Boolean;
  SetTopDown(theIsTopDown: Standard_Boolean): void;
  TopDownInc(): Standard_ThreadId;
  Data(): Standard_Byte;
  ChangeData(): Standard_Byte;
  Row(theRow: Standard_ThreadId): Standard_Byte;
  ChangeRow(theRow: Standard_ThreadId): Standard_Byte;
  SizePixelBytes_1(): Standard_ThreadId;
  static SizePixelBytes_2(thePixelFormat: Image_Format): Standard_ThreadId;
  SizeRowBytes(): Standard_ThreadId;
  RowExtraBytes(): Standard_ThreadId;
  MaxRowAligmentBytes(): Standard_ThreadId;
  SizeBytes(): Standard_ThreadId;
  RawValue(theRow: Standard_ThreadId, theCol: Standard_ThreadId): Standard_Byte;
  ChangeRawValue(theRow: Standard_ThreadId, theCol: Standard_ThreadId): Standard_Byte;
  static ConvertFromHalfFloat(theHalf: uint16_t): Standard_ShortReal;
  static ConvertToHalfFloat(theFloat: Standard_ShortReal): uint16_t;
  delete(): void;
}

export declare class Handle_Image_PixMap {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: Image_PixMap): void;
  get(): Image_PixMap;
  delete(): void;
}

  export declare class Handle_Image_PixMap_1 extends Handle_Image_PixMap {
    constructor();
  }

  export declare class Handle_Image_PixMap_2 extends Handle_Image_PixMap {
    constructor(thePtr: Image_PixMap);
  }

  export declare class Handle_Image_PixMap_3 extends Handle_Image_PixMap {
    constructor(theHandle: Handle_Image_PixMap);
  }

  export declare class Handle_Image_PixMap_4 extends Handle_Image_PixMap {
    constructor(theHandle: Handle_Image_PixMap);
  }

export declare type Image_Format = {
  Image_Format_UNKNOWN: {};
  Image_Format_Gray: {};
  Image_Format_Alpha: {};
  Image_Format_RGB: {};
  Image_Format_BGR: {};
  Image_Format_RGB32: {};
  Image_Format_BGR32: {};
  Image_Format_RGBA: {};
  Image_Format_BGRA: {};
  Image_Format_GrayF: {};
  Image_Format_AlphaF: {};
  Image_Format_RGF: {};
  Image_Format_RGBF: {};
  Image_Format_BGRF: {};
  Image_Format_RGBAF: {};
  Image_Format_BGRAF: {};
  Image_Format_RGF_half: {};
  Image_Format_RGBAF_half: {};
}

export declare class CDM_Document extends Standard_Transient {
  Update_1(aToDocument: Handle_CDM_Document, aReferenceIdentifier: Graphic3d_ZLayerId, aModifContext: Standard_Address): void;
  Update_2(ErrorString: TCollection_ExtendedString): Standard_Boolean;
  StorageFormat(): TCollection_ExtendedString;
  Extensions(Extensions: TColStd_SequenceOfExtendedString): void;
  GetAlternativeDocument(aFormat: TCollection_ExtendedString, anAlternativeDocument: Handle_CDM_Document): Standard_Boolean;
  CreateReference_1(anOtherDocument: Handle_CDM_Document): Graphic3d_ZLayerId;
  RemoveReference(aReferenceIdentifier: Graphic3d_ZLayerId): void;
  RemoveAllReferences(): void;
  Document(aReferenceIdentifier: Graphic3d_ZLayerId): Handle_CDM_Document;
  IsInSession(aReferenceIdentifier: Graphic3d_ZLayerId): Standard_Boolean;
  IsStored_1(aReferenceIdentifier: Graphic3d_ZLayerId): Standard_Boolean;
  Name(aReferenceIdentifier: Graphic3d_ZLayerId): TCollection_ExtendedString;
  UpdateFromDocuments(aModifContext: Standard_Address): void;
  ToReferencesNumber(): Graphic3d_ZLayerId;
  FromReferencesNumber(): Graphic3d_ZLayerId;
  ShallowReferences(aDocument: Handle_CDM_Document): Standard_Boolean;
  DeepReferences(aDocument: Handle_CDM_Document): Standard_Boolean;
  CopyReference(aFromDocument: Handle_CDM_Document, aReferenceIdentifier: Graphic3d_ZLayerId): Graphic3d_ZLayerId;
  IsReadOnly_1(): Standard_Boolean;
  IsReadOnly_2(aReferenceIdentifier: Graphic3d_ZLayerId): Standard_Boolean;
  SetIsReadOnly(): void;
  UnsetIsReadOnly(): void;
  Modify(): void;
  Modifications(): Graphic3d_ZLayerId;
  UnModify(): void;
  IsUpToDate(aReferenceIdentifier: Graphic3d_ZLayerId): Standard_Boolean;
  SetIsUpToDate(aReferenceIdentifier: Graphic3d_ZLayerId): void;
  SetComment(aComment: TCollection_ExtendedString): void;
  AddComment(aComment: TCollection_ExtendedString): void;
  SetComments(aComments: TColStd_SequenceOfExtendedString): void;
  Comments(aComments: TColStd_SequenceOfExtendedString): void;
  Comment(): Standard_ExtString;
  IsStored_2(): Standard_Boolean;
  StorageVersion(): Graphic3d_ZLayerId;
  SetMetaData(aMetaData: Handle_CDM_MetaData): void;
  UnsetIsStored(): void;
  MetaData(): Handle_CDM_MetaData;
  Folder(): TCollection_ExtendedString;
  SetRequestedFolder(aFolder: TCollection_ExtendedString): void;
  RequestedFolder(): TCollection_ExtendedString;
  HasRequestedFolder(): Standard_Boolean;
  SetRequestedName(aName: TCollection_ExtendedString): void;
  RequestedName(): TCollection_ExtendedString;
  SetRequestedPreviousVersion(aPreviousVersion: TCollection_ExtendedString): void;
  UnsetRequestedPreviousVersion(): void;
  HasRequestedPreviousVersion(): Standard_Boolean;
  RequestedPreviousVersion(): TCollection_ExtendedString;
  SetRequestedComment(aComment: TCollection_ExtendedString): void;
  RequestedComment(): TCollection_ExtendedString;
  LoadResources(): void;
  FindFileExtension(): Standard_Boolean;
  FileExtension(): TCollection_ExtendedString;
  FindDescription(): Standard_Boolean;
  Description(): TCollection_ExtendedString;
  IsModified(): Standard_Boolean;
  IsOpened_1(): Standard_Boolean;
  Open(anApplication: Handle_CDM_Application): void;
  CanClose(): CDM_CanCloseStatus;
  Close(): void;
  Application(): Handle_CDM_Application;
  CanCloseReference(aDocument: Handle_CDM_Document, aReferenceIdentifier: Graphic3d_ZLayerId): Standard_Boolean;
  CloseReference(aDocument: Handle_CDM_Document, aReferenceIdentifier: Graphic3d_ZLayerId): void;
  IsOpened_2(aReferenceIdentifier: Graphic3d_ZLayerId): Standard_Boolean;
  CreateReference_2(aMetaData: Handle_CDM_MetaData, aReferenceIdentifier: Graphic3d_ZLayerId, anApplication: Handle_CDM_Application, aToDocumentVersion: Graphic3d_ZLayerId, UseStorageConfiguration: Standard_Boolean): void;
  CreateReference_3(aMetaData: Handle_CDM_MetaData, anApplication: Handle_CDM_Application, aDocumentVersion: Graphic3d_ZLayerId, UseStorageConfiguration: Standard_Boolean): Graphic3d_ZLayerId;
  ReferenceCounter(): Graphic3d_ZLayerId;
  Update_3(): void;
  Reference(aReferenceIdentifier: Graphic3d_ZLayerId): Handle_CDM_Reference;
  SetModifications(Modifications: Graphic3d_ZLayerId): void;
  SetReferenceCounter(aReferenceCounter: Graphic3d_ZLayerId): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  delete(): void;
}

export declare class Message_ProgressRange {
  UserBreak(): Standard_Boolean;
  More(): Standard_Boolean;
  IsActive(): Standard_Boolean;
  Close(): void;
  delete(): void;
}

  export declare class Message_ProgressRange_1 extends Message_ProgressRange {
    constructor();
  }

  export declare class Message_ProgressRange_2 extends Message_ProgressRange {
    constructor(theOther: Message_ProgressRange);
  }

export declare class IGESControl_Reader extends XSControl_Reader {
  SetReadVisible(ReadRoot: Standard_Boolean): void;
  GetReadVisible(): Standard_Boolean;
  IGESModel(): Handle_IGESData_IGESModel;
  NbRootsForTransfer(): Graphic3d_ZLayerId;
  PrintTransferInfo(failwarn: IFSelect_PrintFail, mode: IFSelect_PrintCount): void;
  delete(): void;
}

  export declare class IGESControl_Reader_1 extends IGESControl_Reader {
    constructor();
  }

  export declare class IGESControl_Reader_2 extends IGESControl_Reader {
    constructor(WS: Handle_XSControl_WorkSession, scratch: Standard_Boolean);
  }

export declare class TCollection_AsciiString {
  AssignCat_1(other: Standard_Character): void;
  AssignCat_2(other: Graphic3d_ZLayerId): void;
  AssignCat_3(other: Standard_Real): void;
  AssignCat_4(other: Standard_CString): void;
  AssignCat_5(other: XCAFDoc_PartId): void;
  Capitalize(): void;
  Cat_1(other: Standard_Character): XCAFDoc_PartId;
  Cat_2(other: Graphic3d_ZLayerId): XCAFDoc_PartId;
  Cat_3(other: Standard_Real): XCAFDoc_PartId;
  Cat_4(other: Standard_CString): XCAFDoc_PartId;
  Cat_5(other: XCAFDoc_PartId): XCAFDoc_PartId;
  Center(Width: Graphic3d_ZLayerId, Filler: Standard_Character): void;
  ChangeAll(aChar: Standard_Character, NewChar: Standard_Character, CaseSensitive: Standard_Boolean): void;
  Clear(): void;
  Copy_1(fromwhere: Standard_CString): void;
  Copy_2(fromwhere: XCAFDoc_PartId): void;
  Swap(theOther: XCAFDoc_PartId): void;
  FirstLocationInSet(Set: XCAFDoc_PartId, FromIndex: Graphic3d_ZLayerId, ToIndex: Graphic3d_ZLayerId): Graphic3d_ZLayerId;
  FirstLocationNotInSet(Set: XCAFDoc_PartId, FromIndex: Graphic3d_ZLayerId, ToIndex: Graphic3d_ZLayerId): Graphic3d_ZLayerId;
  Insert_1(where: Graphic3d_ZLayerId, what: Standard_Character): void;
  Insert_2(where: Graphic3d_ZLayerId, what: Standard_CString): void;
  Insert_3(where: Graphic3d_ZLayerId, what: XCAFDoc_PartId): void;
  InsertAfter(Index: Graphic3d_ZLayerId, other: XCAFDoc_PartId): void;
  InsertBefore(Index: Graphic3d_ZLayerId, other: XCAFDoc_PartId): void;
  IsEmpty(): Standard_Boolean;
  IsEqual_1(other: Standard_CString): Standard_Boolean;
  IsEqual_2(other: XCAFDoc_PartId): Standard_Boolean;
  IsDifferent_1(other: Standard_CString): Standard_Boolean;
  IsDifferent_2(other: XCAFDoc_PartId): Standard_Boolean;
  IsLess_1(other: Standard_CString): Standard_Boolean;
  IsLess_2(other: XCAFDoc_PartId): Standard_Boolean;
  IsGreater_1(other: Standard_CString): Standard_Boolean;
  IsGreater_2(other: XCAFDoc_PartId): Standard_Boolean;
  StartsWith(theStartString: XCAFDoc_PartId): Standard_Boolean;
  EndsWith(theEndString: XCAFDoc_PartId): Standard_Boolean;
  IntegerValue(): Graphic3d_ZLayerId;
  IsIntegerValue(): Standard_Boolean;
  IsRealValue(theToCheckFull: Standard_Boolean): Standard_Boolean;
  IsAscii(): Standard_Boolean;
  LeftAdjust(): void;
  LeftJustify(Width: Graphic3d_ZLayerId, Filler: Standard_Character): void;
  Length(): Graphic3d_ZLayerId;
  Location_1(other: XCAFDoc_PartId, FromIndex: Graphic3d_ZLayerId, ToIndex: Graphic3d_ZLayerId): Graphic3d_ZLayerId;
  Location_2(N: Graphic3d_ZLayerId, C: Standard_Character, FromIndex: Graphic3d_ZLayerId, ToIndex: Graphic3d_ZLayerId): Graphic3d_ZLayerId;
  LowerCase(): void;
  Prepend(other: XCAFDoc_PartId): void;
  Print(astream: Standard_OStream): void;
  Read(astream: Standard_IStream): void;
  RealValue(): Standard_Real;
  RemoveAll_1(C: Standard_Character, CaseSensitive: Standard_Boolean): void;
  RemoveAll_2(what: Standard_Character): void;
  Remove(where: Graphic3d_ZLayerId, ahowmany: Graphic3d_ZLayerId): void;
  RightAdjust(): void;
  RightJustify(Width: Graphic3d_ZLayerId, Filler: Standard_Character): void;
  Search_1(what: Standard_CString): Graphic3d_ZLayerId;
  Search_2(what: XCAFDoc_PartId): Graphic3d_ZLayerId;
  SearchFromEnd_1(what: Standard_CString): Graphic3d_ZLayerId;
  SearchFromEnd_2(what: XCAFDoc_PartId): Graphic3d_ZLayerId;
  SetValue_1(where: Graphic3d_ZLayerId, what: Standard_Character): void;
  SetValue_2(where: Graphic3d_ZLayerId, what: Standard_CString): void;
  SetValue_3(where: Graphic3d_ZLayerId, what: XCAFDoc_PartId): void;
  Split_1(where: Graphic3d_ZLayerId): XCAFDoc_PartId;
  SubString_1(FromIndex: Graphic3d_ZLayerId, ToIndex: Graphic3d_ZLayerId): XCAFDoc_PartId;
  ToCString(): Standard_CString;
  Token_1(separators: Standard_CString, whichone: Graphic3d_ZLayerId): XCAFDoc_PartId;
  Trunc(ahowmany: Graphic3d_ZLayerId): void;
  UpperCase(): void;
  UsefullLength(): Graphic3d_ZLayerId;
  Value(where: Graphic3d_ZLayerId): Standard_Character;
  static HashCode(theAsciiString: XCAFDoc_PartId, theUpperBound: Graphic3d_ZLayerId): Graphic3d_ZLayerId;
  static IsEqual_3(string1: XCAFDoc_PartId, string2: XCAFDoc_PartId): Standard_Boolean;
  static IsEqual_4(string1: XCAFDoc_PartId, string2: Standard_CString): Standard_Boolean;
  static IsSameString(theString1: XCAFDoc_PartId, theString2: XCAFDoc_PartId, theIsCaseSensitive: Standard_Boolean): Standard_Boolean;
  delete(): void;
}

  export declare class TCollection_AsciiString_1 extends TCollection_AsciiString {
    constructor();
  }

  export declare class TCollection_AsciiString_2 extends TCollection_AsciiString {
    constructor(message: Standard_CString);
  }

  export declare class TCollection_AsciiString_3 extends TCollection_AsciiString {
    constructor(message: Standard_CString, aLen: Graphic3d_ZLayerId);
  }

  export declare class TCollection_AsciiString_4 extends TCollection_AsciiString {
    constructor(aChar: Standard_Character);
  }

  export declare class TCollection_AsciiString_5 extends TCollection_AsciiString {
    constructor(length: Graphic3d_ZLayerId, filler: Standard_Character);
  }

  export declare class TCollection_AsciiString_6 extends TCollection_AsciiString {
    constructor(value: Graphic3d_ZLayerId);
  }

  export declare class TCollection_AsciiString_7 extends TCollection_AsciiString {
    constructor(value: Standard_Real);
  }

  export declare class TCollection_AsciiString_8 extends TCollection_AsciiString {
    constructor(astring: XCAFDoc_PartId);
  }

  export declare class TCollection_AsciiString_9 extends TCollection_AsciiString {
    constructor(theOther: XCAFDoc_PartId);
  }

  export declare class TCollection_AsciiString_10 extends TCollection_AsciiString {
    constructor(astring: XCAFDoc_PartId, message: Standard_Character);
  }

  export declare class TCollection_AsciiString_11 extends TCollection_AsciiString {
    constructor(astring: XCAFDoc_PartId, message: Standard_CString);
  }

  export declare class TCollection_AsciiString_12 extends TCollection_AsciiString {
    constructor(astring: XCAFDoc_PartId, message: XCAFDoc_PartId);
  }

  export declare class TCollection_AsciiString_13 extends TCollection_AsciiString {
    constructor(astring: TCollection_ExtendedString, replaceNonAscii: Standard_Character);
  }

  export declare class TCollection_AsciiString_14 extends TCollection_AsciiString {
    constructor(theStringUtf: Standard_WideChar);
  }

export declare class TCollection_ExtendedString {
  AssignCat_1(other: TCollection_ExtendedString): void;
  AssignCat_2(theChar: Standard_Utf16Char): void;
  Cat(other: TCollection_ExtendedString): TCollection_ExtendedString;
  ChangeAll(aChar: Standard_ExtCharacter, NewChar: Standard_ExtCharacter): void;
  Clear(): void;
  Copy(fromwhere: TCollection_ExtendedString): void;
  Swap(theOther: TCollection_ExtendedString): void;
  Insert_1(where: Graphic3d_ZLayerId, what: Standard_ExtCharacter): void;
  Insert_2(where: Graphic3d_ZLayerId, what: TCollection_ExtendedString): void;
  IsEmpty(): Standard_Boolean;
  IsEqual_1(other: Standard_ExtString): Standard_Boolean;
  IsEqual_2(other: TCollection_ExtendedString): Standard_Boolean;
  IsDifferent_1(other: Standard_ExtString): Standard_Boolean;
  IsDifferent_2(other: TCollection_ExtendedString): Standard_Boolean;
  IsLess_1(other: Standard_ExtString): Standard_Boolean;
  IsLess_2(other: TCollection_ExtendedString): Standard_Boolean;
  IsGreater_1(other: Standard_ExtString): Standard_Boolean;
  IsGreater_2(other: TCollection_ExtendedString): Standard_Boolean;
  StartsWith(theStartString: TCollection_ExtendedString): Standard_Boolean;
  EndsWith(theEndString: TCollection_ExtendedString): Standard_Boolean;
  IsAscii(): Standard_Boolean;
  Length(): Graphic3d_ZLayerId;
  Print(astream: Standard_OStream): void;
  RemoveAll(what: Standard_ExtCharacter): void;
  Remove(where: Graphic3d_ZLayerId, ahowmany: Graphic3d_ZLayerId): void;
  Search(what: TCollection_ExtendedString): Graphic3d_ZLayerId;
  SearchFromEnd(what: TCollection_ExtendedString): Graphic3d_ZLayerId;
  SetValue_1(where: Graphic3d_ZLayerId, what: Standard_ExtCharacter): void;
  SetValue_2(where: Graphic3d_ZLayerId, what: TCollection_ExtendedString): void;
  Split(where: Graphic3d_ZLayerId): TCollection_ExtendedString;
  Token(separators: Standard_ExtString, whichone: Graphic3d_ZLayerId): TCollection_ExtendedString;
  ToExtString(): Standard_ExtString;
  Trunc(ahowmany: Graphic3d_ZLayerId): void;
  Value(where: Graphic3d_ZLayerId): Standard_ExtCharacter;
  static HashCode(theString: TCollection_ExtendedString, theUpperBound: Graphic3d_ZLayerId): Graphic3d_ZLayerId;
  static IsEqual_3(theString1: TCollection_ExtendedString, theString2: TCollection_ExtendedString): Standard_Boolean;
  LengthOfCString(): Graphic3d_ZLayerId;
  delete(): void;
}

  export declare class TCollection_ExtendedString_1 extends TCollection_ExtendedString {
    constructor();
  }

  export declare class TCollection_ExtendedString_2 extends TCollection_ExtendedString {
    constructor(astring: Standard_CString, isMultiByte: Standard_Boolean);
  }

  export declare class TCollection_ExtendedString_3 extends TCollection_ExtendedString {
    constructor(astring: Standard_ExtString);
  }

  export declare class TCollection_ExtendedString_4 extends TCollection_ExtendedString {
    constructor(theStringUtf: Standard_WideChar);
  }

  export declare class TCollection_ExtendedString_5 extends TCollection_ExtendedString {
    constructor(aChar: Standard_Character);
  }

  export declare class TCollection_ExtendedString_6 extends TCollection_ExtendedString {
    constructor(aChar: Standard_ExtCharacter);
  }

  export declare class TCollection_ExtendedString_7 extends TCollection_ExtendedString {
    constructor(length: Graphic3d_ZLayerId, filler: Standard_ExtCharacter);
  }

  export declare class TCollection_ExtendedString_8 extends TCollection_ExtendedString {
    constructor(value: Graphic3d_ZLayerId);
  }

  export declare class TCollection_ExtendedString_9 extends TCollection_ExtendedString {
    constructor(value: Standard_Real);
  }

  export declare class TCollection_ExtendedString_10 extends TCollection_ExtendedString {
    constructor(astring: TCollection_ExtendedString);
  }

  export declare class TCollection_ExtendedString_11 extends TCollection_ExtendedString {
    constructor(theOther: TCollection_ExtendedString);
  }

  export declare class TCollection_ExtendedString_12 extends TCollection_ExtendedString {
    constructor(astring: XCAFDoc_PartId, isMultiByte: Standard_Boolean);
  }

export declare class BRepMesh_IncrementalMesh extends BRepMesh_DiscretRoot {
  Perform_1(theRange: Message_ProgressRange): void;
  Perform_2(theContext: any, theRange: Message_ProgressRange): void;
  Parameters(): IMeshTools_Parameters;
  ChangeParameters(): IMeshTools_Parameters;
  IsModified(): Standard_Boolean;
  GetStatusFlags(): Graphic3d_ZLayerId;
  static Discret(theShape: TopoDS_Shape, theLinDeflection: Standard_Real, theAngDeflection: Standard_Real, theAlgo: BRepMesh_DiscretRoot): Graphic3d_ZLayerId;
  static IsParallelDefault(): Standard_Boolean;
  static SetParallelDefault(isInParallel: Standard_Boolean): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  delete(): void;
}

  export declare class BRepMesh_IncrementalMesh_1 extends BRepMesh_IncrementalMesh {
    constructor();
  }

  export declare class BRepMesh_IncrementalMesh_2 extends BRepMesh_IncrementalMesh {
    constructor(theShape: TopoDS_Shape, theLinDeflection: Standard_Real, isRelative: Standard_Boolean, theAngDeflection: Standard_Real, isInParallel: Standard_Boolean);
  }

  export declare class BRepMesh_IncrementalMesh_3 extends BRepMesh_IncrementalMesh {
    constructor(theShape: TopoDS_Shape, theParameters: IMeshTools_Parameters, theRange: Message_ProgressRange);
  }

export declare class BRepMesh_DiscretRoot extends Standard_Transient {
  SetShape(theShape: TopoDS_Shape): void;
  Shape(): TopoDS_Shape;
  IsDone(): Standard_Boolean;
  Perform(theRange: Message_ProgressRange): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  delete(): void;
}

export declare class XSControl_Reader {
  SetNorm(norm: Standard_CString): Standard_Boolean;
  SetWS(WS: Handle_XSControl_WorkSession, scratch: Standard_Boolean): void;
  WS(): Handle_XSControl_WorkSession;
  ReadFile(filename: Standard_CString): IFSelect_ReturnStatus;
  ReadStream(theName: Standard_CString, theIStream: Standard_IStream): IFSelect_ReturnStatus;
  Model(): Handle_Interface_InterfaceModel;
  GiveList_1(first: Standard_CString, second: Standard_CString): Handle_TColStd_HSequenceOfTransient;
  GiveList_2(first: Standard_CString, ent: Handle_Standard_Transient): Handle_TColStd_HSequenceOfTransient;
  NbRootsForTransfer(): Graphic3d_ZLayerId;
  RootForTransfer(num: Graphic3d_ZLayerId): Handle_Standard_Transient;
  TransferOneRoot(num: Graphic3d_ZLayerId, theProgress: Message_ProgressRange): Standard_Boolean;
  TransferOne(num: Graphic3d_ZLayerId, theProgress: Message_ProgressRange): Standard_Boolean;
  TransferEntity(start: Handle_Standard_Transient, theProgress: Message_ProgressRange): Standard_Boolean;
  TransferList(list: Handle_TColStd_HSequenceOfTransient, theProgress: Message_ProgressRange): Graphic3d_ZLayerId;
  TransferRoots(theProgress: Message_ProgressRange): Graphic3d_ZLayerId;
  ClearShapes(): void;
  NbShapes(): Graphic3d_ZLayerId;
  Shape(num: Graphic3d_ZLayerId): TopoDS_Shape;
  OneShape(): TopoDS_Shape;
  PrintCheckLoad_1(failsonly: Standard_Boolean, mode: IFSelect_PrintCount): void;
  PrintCheckLoad_2(theStream: Standard_OStream, failsonly: Standard_Boolean, mode: IFSelect_PrintCount): void;
  PrintCheckTransfer_1(failsonly: Standard_Boolean, mode: IFSelect_PrintCount): void;
  PrintCheckTransfer_2(theStream: Standard_OStream, failsonly: Standard_Boolean, mode: IFSelect_PrintCount): void;
  PrintStatsTransfer_1(what: Graphic3d_ZLayerId, mode: Graphic3d_ZLayerId): void;
  PrintStatsTransfer_2(theStream: Standard_OStream, what: Graphic3d_ZLayerId, mode: Graphic3d_ZLayerId): void;
  GetStatsTransfer(list: Handle_TColStd_HSequenceOfTransient, nbMapped: Graphic3d_ZLayerId, nbWithResult: Graphic3d_ZLayerId, nbWithFail: Graphic3d_ZLayerId): void;
  delete(): void;
}

  export declare class XSControl_Reader_1 extends XSControl_Reader {
    constructor();
  }

  export declare class XSControl_Reader_2 extends XSControl_Reader {
    constructor(norm: Standard_CString);
  }

  export declare class XSControl_Reader_3 extends XSControl_Reader {
    constructor(WS: Handle_XSControl_WorkSession, scratch: Standard_Boolean);
  }

export declare class OpenGl_GraphicDriver extends Graphic3d_GraphicDriver {
  constructor(theDisp: Handle_Aspect_DisplayConnection, theToInitialize: Standard_Boolean)
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  ReleaseContext(): void;
  InitContext(): Standard_Boolean;
  InitEglContext(theEglDisplay: Aspect_Display, theEglContext: Aspect_RenderingContext, theEglConfig: C_f): Standard_Boolean;
  InquireLimit(theType: Graphic3d_TypeOfLimit): Graphic3d_ZLayerId;
  CreateStructure(theManager: Handle_Graphic3d_StructureManager): Handle_Graphic3d_CStructure;
  RemoveStructure(theCStructure: Handle_Graphic3d_CStructure): void;
  CreateView(theMgr: Handle_Graphic3d_StructureManager): Handle_Graphic3d_CView;
  RemoveView(theView: Handle_Graphic3d_CView): void;
  CreateRenderWindow(theWindow: Handle_Aspect_Window, theContext: Aspect_RenderingContext): Handle_OpenGl_Window;
  TextSize(theView: Handle_Graphic3d_CView, theText: Standard_CString, theHeight: Standard_ShortReal, theWidth: Standard_ShortReal, theAscent: Standard_ShortReal, theDescent: Standard_ShortReal): void;
  DefaultTextHeight(): Standard_ShortReal;
  ViewExists(theWindow: Handle_Aspect_Window, theView: Handle_Graphic3d_CView): Standard_Boolean;
  InsertLayerBefore(theNewLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings, theLayerAfter: Graphic3d_ZLayerId): void;
  InsertLayerAfter(theNewLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings, theLayerBefore: Graphic3d_ZLayerId): void;
  RemoveZLayer(theLayerId: Graphic3d_ZLayerId): void;
  SetZLayerSettings(theLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings): void;
  SetBuffersNoSwap(theIsNoSwap: Standard_Boolean): void;
  EnableVBO(theToTurnOn: Standard_Boolean): void;
  IsVerticalSync(): Standard_Boolean;
  SetVerticalSync(theToEnable: Standard_Boolean): void;
  MemoryInfo(theFreeBytes: Standard_ThreadId, theInfo: XCAFDoc_PartId): Standard_Boolean;
  GetSharedContext(theBound: Standard_Boolean): Handle_OpenGl_Context;
  getRawGlDisplay(): Aspect_Display;
  getRawGlContext(): Aspect_RenderingContext;
  getRawGlConfig(): C_f;
  setDeviceLost(): void;
  GetStateCounter(): OpenGl_StateCounter;
  GetNextPrimitiveArrayUID(): Standard_ThreadId;
  delete(): void;
}

export declare class Standard_Failure extends Standard_Transient {
  Print(theStream: Standard_OStream): void;
  GetMessageString(): Standard_CString;
  SetMessageString(theMessage: Standard_CString): void;
  GetStackString(): Standard_CString;
  SetStackString(theStack: Standard_CString): void;
  Reraise_1(): void;
  Reraise_2(aMessage: Standard_CString): void;
  Reraise_3(aReason: Standard_SStream): void;
  static Raise_1(aMessage: Standard_CString): void;
  static Raise_2(aReason: Standard_SStream): void;
  static NewInstance_1(theMessage: Standard_CString): Handle_Standard_Failure;
  static NewInstance_2(theMessage: Standard_CString, theStackTrace: Standard_CString): Handle_Standard_Failure;
  static DefaultStackTraceLength(): Graphic3d_ZLayerId;
  static SetDefaultStackTraceLength(theNbStackTraces: Graphic3d_ZLayerId): void;
  Jump(): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  delete(): void;
}

  export declare class Standard_Failure_1 extends Standard_Failure {
    constructor();
  }

  export declare class Standard_Failure_2 extends Standard_Failure {
    constructor(f: Standard_Failure);
  }

  export declare class Standard_Failure_3 extends Standard_Failure {
    constructor(theDesc: Standard_CString);
  }

  export declare class Standard_Failure_4 extends Standard_Failure {
    constructor(theDesc: Standard_CString, theStackTrace: Standard_CString);
  }

export declare class Standard_Transient {
  Delete(): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  IsInstance_1(theType: Handle_Standard_Type): Standard_Boolean;
  IsInstance_2(theTypeName: Standard_CString): Standard_Boolean;
  IsKind_1(theType: Handle_Standard_Type): Standard_Boolean;
  IsKind_2(theTypeName: Standard_CString): Standard_Boolean;
  This(): Standard_Transient;
  GetRefCount(): Graphic3d_ZLayerId;
  IncrementRefCounter(): void;
  DecrementRefCounter(): Graphic3d_ZLayerId;
  delete(): void;
}

  export declare class Standard_Transient_1 extends Standard_Transient {
    constructor();
  }

  export declare class Standard_Transient_2 extends Standard_Transient {
    constructor(a: Standard_Transient);
  }

export declare class XCAFPrs_Style {
  constructor()
  IsEmpty(): Standard_Boolean;
  Material(): Handle_XCAFDoc_VisMaterial;
  SetMaterial(theMaterial: Handle_XCAFDoc_VisMaterial): void;
  IsSetColorSurf(): Standard_Boolean;
  GetColorSurf(): Quantity_Color;
  SetColorSurf_1(theColor: Quantity_Color): void;
  GetColorSurfRGBA(): Quantity_ColorRGBA;
  SetColorSurf_2(theColor: Quantity_ColorRGBA): void;
  UnSetColorSurf(): void;
  IsSetColorCurv(): Standard_Boolean;
  GetColorCurv(): Quantity_Color;
  SetColorCurv(col: Quantity_Color): void;
  UnSetColorCurv(): void;
  SetVisibility(theVisibility: Standard_Boolean): void;
  IsVisible(): Standard_Boolean;
  BaseColorTexture(): any;
  IsEqual_1(theOther: XCAFPrs_Style): Standard_Boolean;
  static HashCode(theStyle: XCAFPrs_Style, theUpperBound: Graphic3d_ZLayerId): Graphic3d_ZLayerId;
  static IsEqual_2(theS1: XCAFPrs_Style, theS2: XCAFPrs_Style): Standard_Boolean;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare class XCAFPrs_AISObject extends AIS_ColoredShape {
  constructor(theLabel: TDF_Label)
  GetLabel(): TDF_Label;
  SetLabel(theLabel: TDF_Label): void;
  DispatchStyles(theToSyncStyles: Standard_Boolean): void;
  SetMaterial(theMaterial: Graphic3d_MaterialAspect): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  delete(): void;
}

export declare class Wasm_Window extends Aspect_Window {
  constructor(theCanvasId: XCAFDoc_PartId, theToScaleBacking: Standard_Boolean)
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  static MouseButtonsFromNative(theButtons: number): Aspect_VKeyMouse;
  static VirtualKeyFromNative(theKey: Graphic3d_ZLayerId): Aspect_VKey;
  IsMapped(): Standard_Boolean;
  Map(): void;
  Unmap(): void;
  DoResize(): Aspect_TypeOfResize;
  DoMapping(): Standard_Boolean;
  Ratio(): Standard_Real;
  Position(theX1: Graphic3d_ZLayerId, theY1: Graphic3d_ZLayerId, theX2: Graphic3d_ZLayerId, theY2: Graphic3d_ZLayerId): void;
  Size(theWidth: Graphic3d_ZLayerId, theHeight: Graphic3d_ZLayerId): void;
  SetSizeLogical(theSize: OpenGl_Vec2d): void;
  SetSizeBacking(theSize: OpenGl_Vec2i): void;
  CanvasId(): XCAFDoc_PartId;
  NativeHandle(): Aspect_Drawable;
  NativeParentHandle(): Aspect_Drawable;
  NativeFBConfig(): Aspect_FBConfig;
  DevicePixelRatio(): Standard_Real;
  SetDevicePixelRatio(theDevicePixelRatio: Standard_Real): void;
  InvalidateContent(theDisp: Handle_Aspect_DisplayConnection): void;
  ProcessMessage(theListener: Aspect_WindowInputListener, theEventType: Standard_Integer, theEvent: C_f): Standard_Boolean;
  ProcessMouseEvent(theListener: Aspect_WindowInputListener, theEventType: Standard_Integer, theEvent: EmscriptenMouseEvent): Standard_Boolean;
  ProcessWheelEvent(theListener: Aspect_WindowInputListener, theEventType: Standard_Integer, theEvent: EmscriptenWheelEvent): Standard_Boolean;
  ProcessTouchEvent(theListener: Aspect_WindowInputListener, theEventType: Standard_Integer, theEvent: EmscriptenTouchEvent): Standard_Boolean;
  ProcessKeyEvent(theListener: Aspect_WindowInputListener, theEventType: Standard_Integer, theEvent: EmscriptenKeyboardEvent): Standard_Boolean;
  ProcessUiEvent(theListener: Aspect_WindowInputListener, theEventType: Standard_Integer, theEvent: EmscriptenUiEvent): Standard_Boolean;
  ProcessFocusEvent(theListener: Aspect_WindowInputListener, theEventType: Standard_Integer, theEvent: EmscriptenFocusEvent): Standard_Boolean;
  delete(): void;
}

export declare type IFSelect_ReturnStatus = {
  IFSelect_RetVoid: {};
  IFSelect_RetDone: {};
  IFSelect_RetError: {};
  IFSelect_RetFail: {};
  IFSelect_RetStop: {};
}

export declare class Aspect_Window extends Standard_Transient {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  SetBackground_1(ABack: Aspect_Background): void;
  SetBackground_2(color: Quantity_Color): void;
  SetBackground_3(ABackground: Aspect_GradientBackground): void;
  SetBackground_4(theFirstColor: Quantity_Color, theSecondColor: Quantity_Color, theFillMethod: Aspect_GradientFillMethod): void;
  Map(): void;
  Unmap(): void;
  DoResize(): Aspect_TypeOfResize;
  DoMapping(): Standard_Boolean;
  Background(): Aspect_Background;
  BackgroundFillMethod(): Aspect_FillMethod;
  GradientBackground(): Aspect_GradientBackground;
  IsMapped(): Standard_Boolean;
  IsVirtual(): Standard_Boolean;
  SetVirtual(theVirtual: Standard_Boolean): void;
  Ratio(): Standard_Real;
  Position(X1: Graphic3d_ZLayerId, Y1: Graphic3d_ZLayerId, X2: Graphic3d_ZLayerId, Y2: Graphic3d_ZLayerId): void;
  Size(Width: Graphic3d_ZLayerId, Height: Graphic3d_ZLayerId): void;
  NativeHandle(): Aspect_Drawable;
  NativeParentHandle(): Aspect_Drawable;
  NativeFBConfig(): Aspect_FBConfig;
  DisplayConnection(): Handle_Aspect_DisplayConnection;
  SetTitle(theTitle: XCAFDoc_PartId): void;
  InvalidateContent(theDisp: Handle_Aspect_DisplayConnection): void;
  DevicePixelRatio(): Standard_Real;
  ConvertPointToBacking(thePnt: OpenGl_Vec2d): OpenGl_Vec2d;
  ConvertPointFromBacking(thePnt: OpenGl_Vec2d): OpenGl_Vec2d;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare class Handle_Aspect_Window {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: Aspect_Window): void;
  get(): Aspect_Window;
  delete(): void;
}

  export declare class Handle_Aspect_Window_1 extends Handle_Aspect_Window {
    constructor();
  }

  export declare class Handle_Aspect_Window_2 extends Handle_Aspect_Window {
    constructor(thePtr: Aspect_Window);
  }

  export declare class Handle_Aspect_Window_3 extends Handle_Aspect_Window {
    constructor(theHandle: Handle_Aspect_Window);
  }

  export declare class Handle_Aspect_Window_4 extends Handle_Aspect_Window {
    constructor(theHandle: Handle_Aspect_Window);
  }

export declare type Aspect_TypeOfResize = {
  Aspect_TOR_UNKNOWN: {};
  Aspect_TOR_NO_BORDER: {};
  Aspect_TOR_TOP_BORDER: {};
  Aspect_TOR_RIGHT_BORDER: {};
  Aspect_TOR_BOTTOM_BORDER: {};
  Aspect_TOR_LEFT_BORDER: {};
  Aspect_TOR_TOP_AND_RIGHT_BORDER: {};
  Aspect_TOR_RIGHT_AND_BOTTOM_BORDER: {};
  Aspect_TOR_BOTTOM_AND_LEFT_BORDER: {};
  Aspect_TOR_LEFT_AND_TOP_BORDER: {};
}

export declare type Aspect_GradientFillMethod = {
  Aspect_GradientFillMethod_None: {};
  Aspect_GradientFillMethod_Horizontal: {};
  Aspect_GradientFillMethod_Vertical: {};
  Aspect_GradientFillMethod_Diagonal1: {};
  Aspect_GradientFillMethod_Diagonal2: {};
  Aspect_GradientFillMethod_Corner1: {};
  Aspect_GradientFillMethod_Corner2: {};
  Aspect_GradientFillMethod_Corner3: {};
  Aspect_GradientFillMethod_Corner4: {};
  Aspect_GradientFillMethod_Elliptical: {};
  Aspect_GFM_NONE: {};
  Aspect_GFM_HOR: {};
  Aspect_GFM_VER: {};
  Aspect_GFM_DIAG1: {};
  Aspect_GFM_DIAG2: {};
  Aspect_GFM_CORNER1: {};
  Aspect_GFM_CORNER2: {};
  Aspect_GFM_CORNER3: {};
  Aspect_GFM_CORNER4: {};
}

export declare class Handle_Aspect_DisplayConnection {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: Aspect_DisplayConnection): void;
  get(): Aspect_DisplayConnection;
  delete(): void;
}

  export declare class Handle_Aspect_DisplayConnection_1 extends Handle_Aspect_DisplayConnection {
    constructor();
  }

  export declare class Handle_Aspect_DisplayConnection_2 extends Handle_Aspect_DisplayConnection {
    constructor(thePtr: Aspect_DisplayConnection);
  }

  export declare class Handle_Aspect_DisplayConnection_3 extends Handle_Aspect_DisplayConnection {
    constructor(theHandle: Handle_Aspect_DisplayConnection);
  }

  export declare class Handle_Aspect_DisplayConnection_4 extends Handle_Aspect_DisplayConnection {
    constructor(theHandle: Handle_Aspect_DisplayConnection);
  }

export declare class Aspect_WindowInputListener {
  EventTime(): Standard_Real;
  ProcessExpose(): void;
  ProcessConfigure(theIsResized: Standard_Boolean): void;
  ProcessInput(): void;
  ProcessFocus(theIsActivated: Standard_Boolean): void;
  ProcessClose(): void;
  KeyDown(theKey: Aspect_VKey, theTime: Standard_Real, thePressure: Standard_Real): void;
  KeyUp(theKey: Aspect_VKey, theTime: Standard_Real): void;
  KeyFromAxis(theNegative: Aspect_VKey, thePositive: Aspect_VKey, theTime: Standard_Real, thePressure: Standard_Real): void;
  UpdateMouseScroll(theDelta: Aspect_ScrollDelta): Standard_Boolean;
  UpdateMouseButtons(thePoint: OpenGl_Vec2i, theButtons: Aspect_VKeyMouse, theModifiers: Aspect_VKeyFlags, theIsEmulated: Standard_Boolean): Standard_Boolean;
  UpdateMousePosition(thePoint: OpenGl_Vec2i, theButtons: Aspect_VKeyMouse, theModifiers: Aspect_VKeyFlags, theIsEmulated: Standard_Boolean): Standard_Boolean;
  PressMouseButton(thePoint: OpenGl_Vec2i, theButton: Aspect_VKeyMouse, theModifiers: Aspect_VKeyFlags, theIsEmulated: Standard_Boolean): Standard_Boolean;
  ReleaseMouseButton(thePoint: OpenGl_Vec2i, theButton: Aspect_VKeyMouse, theModifiers: Aspect_VKeyFlags, theIsEmulated: Standard_Boolean): Standard_Boolean;
  PressedMouseButtons(): Aspect_VKeyMouse;
  LastMouseFlags(): Aspect_VKeyFlags;
  LastMousePosition(): OpenGl_Vec2i;
  HasTouchPoints(): Standard_Boolean;
  TouchPoints(): Aspect_TouchMap;
  AddTouchPoint(theId: Standard_ThreadId, thePnt: OpenGl_Vec2d, theClearBefore: Standard_Boolean): void;
  RemoveTouchPoint(theId: Standard_ThreadId, theClearSelectPnts: Standard_Boolean): Standard_Boolean;
  UpdateTouchPoint(theId: Standard_ThreadId, thePnt: OpenGl_Vec2d): void;
  Get3dMouseTranslationScale(): Standard_ShortReal;
  Set3dMouseTranslationScale(theScale: Standard_ShortReal): void;
  Get3dMouseRotationScale(): Standard_ShortReal;
  Set3dMouseRotationScale(theScale: Standard_ShortReal): void;
  To3dMousePreciseInput(): Standard_Boolean;
  Set3dMousePreciseInput(theIsQuadric: Standard_Boolean): void;
  Get3dMouseIsNoRotate(): any;
  Change3dMouseIsNoRotate(): any;
  Get3dMouseToReverse(): any;
  Change3dMouseToReverse(): any;
  Update3dMouse(theEvent: WNT_HIDSpaceMouse): Standard_Boolean;
  update3dMouseTranslation(theEvent: WNT_HIDSpaceMouse): Standard_Boolean;
  update3dMouseRotation(theEvent: WNT_HIDSpaceMouse): Standard_Boolean;
  update3dMouseKeys(theEvent: WNT_HIDSpaceMouse): Standard_Boolean;
  delete(): void;
}

export declare class Quantity_Color {
  Name_1(): Quantity_NameOfColor;
  SetValues_1(theName: Quantity_NameOfColor): void;
  Rgb(): any;
  Values(theC1: Standard_Real, theC2: Standard_Real, theC3: Standard_Real, theType: Quantity_TypeOfColor): void;
  SetValues_2(theC1: Standard_Real, theC2: Standard_Real, theC3: Standard_Real, theType: Quantity_TypeOfColor): void;
  Red(): Standard_Real;
  Green(): Standard_Real;
  Blue(): Standard_Real;
  Hue(): Standard_Real;
  Light(): Standard_Real;
  ChangeIntensity(theDelta: Standard_Real): void;
  Saturation(): Standard_Real;
  ChangeContrast(theDelta: Standard_Real): void;
  IsDifferent(theOther: Quantity_Color): Standard_Boolean;
  IsEqual(theOther: Quantity_Color): Standard_Boolean;
  Distance(theColor: Quantity_Color): Standard_Real;
  SquareDistance(theColor: Quantity_Color): Standard_Real;
  Delta(theColor: Quantity_Color, DC: Standard_Real, DI: Standard_Real): void;
  DeltaE2000(theOther: Quantity_Color): Standard_Real;
  static Name_2(theR: Standard_Real, theG: Standard_Real, theB: Standard_Real): Quantity_NameOfColor;
  static StringName(theColor: Quantity_NameOfColor): Standard_CString;
  static ColorFromName_1(theName: Standard_CString, theColor: Quantity_NameOfColor): Standard_Boolean;
  static ColorFromName_2(theColorNameString: Standard_CString, theColor: Quantity_Color): Standard_Boolean;
  static ColorFromHex(theHexColorString: Standard_CString, theColor: Quantity_Color): Standard_Boolean;
  static ColorToHex(theColor: Quantity_Color, theToPrefixHash: Standard_Boolean): XCAFDoc_PartId;
  static Convert_sRGB_To_HLS(theRgb: NCollection_Vec3<float>): any;
  static Convert_HLS_To_sRGB(theHls: NCollection_Vec3<float>): any;
  static Convert_LinearRGB_To_HLS(theRgb: NCollection_Vec3<float>): any;
  static Convert_HLS_To_LinearRGB(theHls: NCollection_Vec3<float>): any;
  static Convert_LinearRGB_To_Lab(theRgb: NCollection_Vec3<float>): any;
  static Convert_Lab_To_Lch(theLab: NCollection_Vec3<float>): any;
  static Convert_Lab_To_LinearRGB(theLab: NCollection_Vec3<float>): any;
  static Convert_Lch_To_Lab(theLch: NCollection_Vec3<float>): any;
  static Color2argb(theColor: Quantity_Color, theARGB: Graphic3d_ZLayerId): void;
  static Argb2color(theARGB: Graphic3d_ZLayerId, theColor: Quantity_Color): void;
  static Convert_LinearRGB_To_sRGB_1(theLinearValue: Standard_Real): Standard_Real;
  static Convert_LinearRGB_To_sRGB_2(theLinearValue: Standard_ShortReal): Standard_ShortReal;
  static Convert_sRGB_To_LinearRGB_1(thesRGBValue: Standard_Real): Standard_Real;
  static Convert_sRGB_To_LinearRGB_2(thesRGBValue: Standard_ShortReal): Standard_ShortReal;
  static Convert_LinearRGB_To_sRGB_approx22_1(theLinearValue: Standard_ShortReal): Standard_ShortReal;
  static Convert_sRGB_To_LinearRGB_approx22_1(thesRGBValue: Standard_ShortReal): Standard_ShortReal;
  static Convert_LinearRGB_To_sRGB_approx22_2(theRGB: NCollection_Vec3<float>): any;
  static Convert_sRGB_To_LinearRGB_approx22_2(theRGB: NCollection_Vec3<float>): any;
  static HlsRgb(theH: Standard_Real, theL: Standard_Real, theS: Standard_Real, theR: Standard_Real, theG: Standard_Real, theB: Standard_Real): void;
  static RgbHls(theR: Standard_Real, theG: Standard_Real, theB: Standard_Real, theH: Standard_Real, theL: Standard_Real, theS: Standard_Real): void;
  static Epsilon(): Standard_Real;
  static SetEpsilon(theEpsilon: Standard_Real): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  InitFromJson(theSStream: Standard_SStream, theStreamPos: Graphic3d_ZLayerId): Standard_Boolean;
  delete(): void;
}

  export declare class Quantity_Color_1 extends Quantity_Color {
    constructor();
  }

  export declare class Quantity_Color_2 extends Quantity_Color {
    constructor(theName: Quantity_NameOfColor);
  }

  export declare class Quantity_Color_3 extends Quantity_Color {
    constructor(theC1: Standard_Real, theC2: Standard_Real, theC3: Standard_Real, theType: Quantity_TypeOfColor);
  }

  export declare class Quantity_Color_4 extends Quantity_Color {
    constructor(theRgb: NCollection_Vec3<float>);
  }

export declare class Quantity_ColorRGBA {
  SetValues(theRed: Standard_ShortReal, theGreen: Standard_ShortReal, theBlue: Standard_ShortReal, theAlpha: Standard_ShortReal): void;
  GetRGB(): Quantity_Color;
  ChangeRGB(): Quantity_Color;
  SetRGB(theRgb: Quantity_Color): void;
  Alpha(): Standard_ShortReal;
  SetAlpha(theAlpha: Standard_ShortReal): void;
  IsDifferent(theOther: Quantity_ColorRGBA): Standard_Boolean;
  IsEqual(theOther: Quantity_ColorRGBA): Standard_Boolean;
  static ColorFromName(theColorNameString: Standard_CString, theColor: Quantity_ColorRGBA): Standard_Boolean;
  static ColorFromHex(theHexColorString: Standard_Character, theColor: Quantity_ColorRGBA, theAlphaComponentIsOff: Standard_Boolean): Standard_Boolean;
  static ColorToHex(theColor: Quantity_ColorRGBA, theToPrefixHash: Standard_Boolean): XCAFDoc_PartId;
  static Convert_LinearRGB_To_sRGB(theRGB: NCollection_Vec4<float>): any;
  static Convert_sRGB_To_LinearRGB(theRGB: NCollection_Vec4<float>): any;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  InitFromJson(theSStream: Standard_SStream, theStreamPos: Graphic3d_ZLayerId): Standard_Boolean;
  delete(): void;
}

  export declare class Quantity_ColorRGBA_1 extends Quantity_ColorRGBA {
    constructor();
  }

  export declare class Quantity_ColorRGBA_2 extends Quantity_ColorRGBA {
    constructor(theRgb: Quantity_Color);
  }

  export declare class Quantity_ColorRGBA_3 extends Quantity_ColorRGBA {
    constructor(theRgb: Quantity_Color, theAlpha: Standard_ShortReal);
  }

  export declare class Quantity_ColorRGBA_4 extends Quantity_ColorRGBA {
    constructor(theRgba: NCollection_Vec4<float>);
  }

  export declare class Quantity_ColorRGBA_5 extends Quantity_ColorRGBA {
    constructor(theRed: Standard_ShortReal, theGreen: Standard_ShortReal, theBlue: Standard_ShortReal, theAlpha: Standard_ShortReal);
  }

export declare type Quantity_TypeOfColor = {
  Quantity_TOC_RGB: {};
  Quantity_TOC_sRGB: {};
  Quantity_TOC_HLS: {};
  Quantity_TOC_CIELab: {};
  Quantity_TOC_CIELch: {};
}

export declare class Graphic3d_DataStructureManager extends Standard_Transient {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  delete(): void;
}

export declare class Handle_Graphic3d_SequenceOfHClipPlane {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: Graphic3d_SequenceOfHClipPlane): void;
  get(): Graphic3d_SequenceOfHClipPlane;
  delete(): void;
}

  export declare class Handle_Graphic3d_SequenceOfHClipPlane_1 extends Handle_Graphic3d_SequenceOfHClipPlane {
    constructor();
  }

  export declare class Handle_Graphic3d_SequenceOfHClipPlane_2 extends Handle_Graphic3d_SequenceOfHClipPlane {
    constructor(thePtr: Graphic3d_SequenceOfHClipPlane);
  }

  export declare class Handle_Graphic3d_SequenceOfHClipPlane_3 extends Handle_Graphic3d_SequenceOfHClipPlane {
    constructor(theHandle: Handle_Graphic3d_SequenceOfHClipPlane);
  }

  export declare class Handle_Graphic3d_SequenceOfHClipPlane_4 extends Handle_Graphic3d_SequenceOfHClipPlane {
    constructor(theHandle: Handle_Graphic3d_SequenceOfHClipPlane);
  }

export declare class Graphic3d_SequenceOfHClipPlane extends Standard_Transient {
  constructor()
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  ToOverrideGlobal(): Standard_Boolean;
  SetOverrideGlobal(theToOverride: Standard_Boolean): void;
  IsEmpty(): Standard_Boolean;
  Size(): Graphic3d_ZLayerId;
  Append(theItem: Handle_Graphic3d_ClipPlane): Standard_Boolean;
  Remove_1(theItem: Handle_Graphic3d_ClipPlane): Standard_Boolean;
  Remove_2(theItem: any): void;
  Clear(): void;
  First(): Handle_Graphic3d_ClipPlane;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare class Handle_Graphic3d_CView {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: Graphic3d_CView): void;
  get(): Graphic3d_CView;
  delete(): void;
}

  export declare class Handle_Graphic3d_CView_1 extends Handle_Graphic3d_CView {
    constructor();
  }

  export declare class Handle_Graphic3d_CView_2 extends Handle_Graphic3d_CView {
    constructor(thePtr: Graphic3d_CView);
  }

  export declare class Handle_Graphic3d_CView_3 extends Handle_Graphic3d_CView {
    constructor(theHandle: Handle_Graphic3d_CView);
  }

  export declare class Handle_Graphic3d_CView_4 extends Handle_Graphic3d_CView {
    constructor(theHandle: Handle_Graphic3d_CView);
  }

export declare class Graphic3d_CView extends Graphic3d_DataStructureManager {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  Identification(): Graphic3d_ZLayerId;
  Activate(): void;
  Deactivate(): void;
  IsActive(): Standard_Boolean;
  Remove(): void;
  IsRemoved(): Standard_Boolean;
  Camera(): Handle_Graphic3d_Camera;
  SetCamera(theCamera: Handle_Graphic3d_Camera): void;
  ShadingModel(): V3d_TypeOfShadingModel;
  SetShadingModel(theModel: V3d_TypeOfShadingModel): void;
  BackfacingModel(): V3d_TypeOfBackfacingModel;
  SetBackfacingModel(theModel: V3d_TypeOfBackfacingModel): void;
  VisualizationType(): Graphic3d_TypeOfVisualization;
  SetVisualizationType(theType: Graphic3d_TypeOfVisualization): void;
  SetComputedMode(theMode: Standard_Boolean): void;
  ComputedMode(): Standard_Boolean;
  ReCompute(theStructure: Handle_Graphic3d_Structure): void;
  Update(theLayerId: Graphic3d_ZLayerId): void;
  Compute(): void;
  ContainsFacet_1(): Standard_Boolean;
  ContainsFacet_2(theSet: Graphic3d_MapOfStructure): Standard_Boolean;
  DisplayedStructures(theStructures: Graphic3d_MapOfStructure): void;
  NumberOfDisplayedStructures(): Graphic3d_ZLayerId;
  HiddenObjects(): any;
  ChangeHiddenObjects(): any;
  IsComputed_1(theStructId: Graphic3d_ZLayerId, theComputedStruct: Handle_Graphic3d_Structure): Standard_Boolean;
  MinMaxValues_1(theToIncludeAuxiliary: Standard_Boolean): Bnd_Box;
  MinMaxValues_2(theSet: Graphic3d_MapOfStructure, theToIncludeAuxiliary: Standard_Boolean): Bnd_Box;
  StructureManager(): Handle_Graphic3d_StructureManager;
  Redraw(): void;
  RedrawImmediate(): void;
  Invalidate(): void;
  IsInvalidated(): Standard_Boolean;
  Resized(): void;
  SetImmediateModeDrawToFront(theDrawToFrontBuffer: Standard_Boolean): Standard_Boolean;
  SetWindow(theWindow: Handle_Aspect_Window, theContext: Aspect_RenderingContext): void;
  Window(): Handle_Aspect_Window;
  IsDefined(): Standard_Boolean;
  BufferDump(theImage: Image_PixMap, theBufferType: Graphic3d_BufferType): Standard_Boolean;
  InvalidateBVHData(theLayerId: Graphic3d_ZLayerId): void;
  InsertLayerBefore(theNewLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings, theLayerAfter: Graphic3d_ZLayerId): void;
  InsertLayerAfter(theNewLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings, theLayerBefore: Graphic3d_ZLayerId): void;
  ZLayerMax(): Graphic3d_ZLayerId;
  Layers(): any;
  Layer(theLayerId: Graphic3d_ZLayerId): any;
  InvalidateZLayerBoundingBox(theLayerId: Graphic3d_ZLayerId): void;
  RemoveZLayer(theLayerId: Graphic3d_ZLayerId): void;
  SetZLayerSettings(theLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings): void;
  ConsiderZoomPersistenceObjects(): Standard_Real;
  FBO(): Handle_Standard_Transient;
  SetFBO(theFbo: Handle_Standard_Transient): void;
  FBOCreate(theWidth: Graphic3d_ZLayerId, theHeight: Graphic3d_ZLayerId): Handle_Standard_Transient;
  FBORelease(theFbo: Handle_Standard_Transient): void;
  FBOGetDimensions(theFbo: Handle_Standard_Transient, theWidth: Graphic3d_ZLayerId, theHeight: Graphic3d_ZLayerId, theWidthMax: Graphic3d_ZLayerId, theHeightMax: Graphic3d_ZLayerId): void;
  FBOChangeViewport(theFbo: Handle_Standard_Transient, theWidth: Graphic3d_ZLayerId, theHeight: Graphic3d_ZLayerId): void;
  CopySettings(theOther: Handle_Graphic3d_CView): void;
  RenderingParams(): Graphic3d_RenderingParams;
  ChangeRenderingParams(): Graphic3d_RenderingParams;
  Background(): Aspect_Background;
  SetBackground(theBackground: Aspect_Background): void;
  GradientBackground(): Aspect_GradientBackground;
  SetGradientBackground(theBackground: Aspect_GradientBackground): void;
  BackgroundImage(): Handle_Graphic3d_TextureMap;
  BackgroundCubeMap(): Handle_Graphic3d_CubeMap;
  IBLCubeMap(): Handle_Graphic3d_CubeMap;
  SetBackgroundImage(theTextureMap: Handle_Graphic3d_TextureMap, theToUpdatePBREnv: Standard_Boolean): void;
  BackgroundImageStyle(): Aspect_FillMethod;
  SetBackgroundImageStyle(theFillStyle: Aspect_FillMethod): void;
  BackgroundType(): Graphic3d_TypeOfBackground;
  SetBackgroundType(theType: Graphic3d_TypeOfBackground): void;
  SetImageBasedLighting(theToEnableIBL: Standard_Boolean): void;
  TextureEnv(): Handle_Graphic3d_TextureEnv;
  SetTextureEnv(theTextureEnv: Handle_Graphic3d_TextureEnv): void;
  Lights(): Handle_Graphic3d_LightSet;
  SetLights(theLights: Handle_Graphic3d_LightSet): void;
  ClipPlanes(): Handle_Graphic3d_SequenceOfHClipPlane;
  SetClipPlanes(thePlanes: Handle_Graphic3d_SequenceOfHClipPlane): void;
  DiagnosticInformation(theDict: TColStd_IndexedDataMapOfStringString, theFlags: Graphic3d_DiagnosticInfo): void;
  StatisticInformation_1(): XCAFDoc_PartId;
  StatisticInformation_2(theDict: TColStd_IndexedDataMapOfStringString): void;
  UnitFactor(): Standard_Real;
  SetUnitFactor(theFactor: Standard_Real): void;
  XRSession(): any;
  SetXRSession(theSession: any): void;
  IsActiveXR(): Standard_Boolean;
  InitXR(): Standard_Boolean;
  ReleaseXR(): void;
  ProcessXRInput(): void;
  SetupXRPosedCamera(): void;
  UnsetXRPosedCamera(): void;
  PosedXRCamera(): Handle_Graphic3d_Camera;
  SetPosedXRCamera(theCamera: Handle_Graphic3d_Camera): void;
  BaseXRCamera(): Handle_Graphic3d_Camera;
  SetBaseXRCamera(theCamera: Handle_Graphic3d_Camera): void;
  PoseXRToWorld(thePoseXR: gp_Trsf): gp_Trsf;
  ViewAxisInWorld(thePoseXR: gp_Trsf): gp_Ax1;
  SynchronizeXRBaseToPosedCamera(): void;
  SynchronizeXRPosedToBaseCamera(): void;
  ComputeXRPosedCameraFromBase(theCam: Graphic3d_Camera, theXRTrsf: gp_Trsf): void;
  ComputeXRBaseCameraFromPosed(theCamPosed: Graphic3d_Camera, thePoseTrsf: gp_Trsf): void;
  TurnViewXRCamera(theTrsfTurn: gp_Trsf): void;
  GetGraduatedTrihedron(): Graphic3d_GraduatedTrihedron;
  GraduatedTrihedronDisplay(theTrihedronData: Graphic3d_GraduatedTrihedron): void;
  GraduatedTrihedronErase(): void;
  GraduatedTrihedronMinMaxValues(theMin: OpenGl_Vec3, theMax: OpenGl_Vec3): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare class Graphic3d_Texture2D extends Graphic3d_TextureMap {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  static NumberOfTextures(): Graphic3d_ZLayerId;
  static TextureName(theRank: Graphic3d_ZLayerId): XCAFDoc_PartId;
  Name(): Graphic3d_NameOfTexture2D;
  SetImage(thePixMap: Handle_Image_PixMap): void;
  HasMipMaps(): Standard_Boolean;
  SetMipMaps(theToUse: Standard_Boolean): void;
  delete(): void;
}

export declare class Graphic3d_TransformPers extends Standard_Transient {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  static IsZoomOrRotate_1(theMode: Graphic3d_TransModeFlags): Standard_Boolean;
  static IsTrihedronOr2d_1(theMode: Graphic3d_TransModeFlags): Standard_Boolean;
  IsZoomOrRotate_2(): Standard_Boolean;
  IsTrihedronOr2d_2(): Standard_Boolean;
  Mode(): Graphic3d_TransModeFlags;
  Flags(): Graphic3d_TransModeFlags;
  SetPersistence_1(theMode: Graphic3d_TransModeFlags, thePnt: gp_Pnt): void;
  SetPersistence_2(theMode: Graphic3d_TransModeFlags, theCorner: Aspect_TypeOfTriedronPosition, theOffset: OpenGl_Vec2i): void;
  AnchorPoint(): gp_Pnt;
  SetAnchorPoint(thePnt: gp_Pnt): void;
  Corner2d(): Aspect_TypeOfTriedronPosition;
  SetCorner2d(thePos: Aspect_TypeOfTriedronPosition): void;
  Offset2d(): OpenGl_Vec2i;
  SetOffset2d(theOffset: OpenGl_Vec2i): void;
  persistentScale(theCamera: Handle_Graphic3d_Camera, a1: Graphic3d_ZLayerId, theViewportHeight: Graphic3d_ZLayerId): Standard_Real;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

  export declare class Graphic3d_TransformPers_1 extends Graphic3d_TransformPers {
    constructor(theMode: Graphic3d_TransModeFlags);
  }

  export declare class Graphic3d_TransformPers_2 extends Graphic3d_TransformPers {
    constructor(theMode: Graphic3d_TransModeFlags, thePnt: gp_Pnt);
  }

  export declare class Graphic3d_TransformPers_3 extends Graphic3d_TransformPers {
    constructor(theMode: Graphic3d_TransModeFlags, theCorner: Aspect_TypeOfTriedronPosition, theOffset: OpenGl_Vec2i);
  }

export declare class Handle_Graphic3d_TransformPers {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: Graphic3d_TransformPers): void;
  get(): Graphic3d_TransformPers;
  delete(): void;
}

  export declare class Handle_Graphic3d_TransformPers_1 extends Handle_Graphic3d_TransformPers {
    constructor();
  }

  export declare class Handle_Graphic3d_TransformPers_2 extends Handle_Graphic3d_TransformPers {
    constructor(thePtr: Graphic3d_TransformPers);
  }

  export declare class Handle_Graphic3d_TransformPers_3 extends Handle_Graphic3d_TransformPers {
    constructor(theHandle: Handle_Graphic3d_TransformPers);
  }

  export declare class Handle_Graphic3d_TransformPers_4 extends Handle_Graphic3d_TransformPers {
    constructor(theHandle: Handle_Graphic3d_TransformPers);
  }

export declare class Graphic3d_Vec2i {
  static Length(): number;
  SetValues(theX: Standard_Integer, theY: Standard_Integer): void;
  x_1(): Standard_Integer;
  y_1(): Standard_Integer;
  xy(): Graphic3d_Vec2i;
  yx(): Graphic3d_Vec2i;
  x_2(): Standard_Integer;
  y_2(): Standard_Integer;
  IsEqual(theOther: Graphic3d_Vec2i): boolean;
  GetData(): Standard_Integer;
  ChangeData(): Standard_Integer;
  Multiply(theFactor: Standard_Integer): void;
  Multiplied(theFactor: Standard_Integer): Graphic3d_Vec2i;
  cwiseMin(theVec: Graphic3d_Vec2i): Graphic3d_Vec2i;
  cwiseMax(theVec: Graphic3d_Vec2i): Graphic3d_Vec2i;
  maxComp(): Standard_Integer;
  minComp(): Standard_Integer;
  Dot(theOther: Graphic3d_Vec2i): Standard_Integer;
  Modulus(): Standard_Integer;
  SquareModulus(): Standard_Integer;
  static DX(): Graphic3d_Vec2i;
  static DY(): Graphic3d_Vec2i;
  DumpJson(theOStream: Standard_OStream, theDepth: Standard_Integer): void;
  delete(): void;
}

  export declare class Graphic3d_Vec2i_1 extends Graphic3d_Vec2i {
    constructor();
  }

  export declare class Graphic3d_Vec2i_2 extends Graphic3d_Vec2i {
    constructor(theXY: Standard_Integer);
  }

  export declare class Graphic3d_Vec2i_3 extends Graphic3d_Vec2i {
    constructor(theX: Standard_Integer, theY: Standard_Integer);
  }

export declare class Graphic3d_PresentationAttributes extends Standard_Transient {
  constructor()
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  Method(): Aspect_TypeOfHighlightMethod;
  SetMethod(theMethod: Aspect_TypeOfHighlightMethod): void;
  ColorRGBA(): Quantity_ColorRGBA;
  Color(): Quantity_Color;
  SetColor(theColor: Quantity_Color): void;
  Transparency(): Standard_ShortReal;
  SetTransparency(theTranspCoef: Standard_ShortReal): void;
  ZLayer(): Graphic3d_ZLayerId;
  SetZLayer(theLayer: Graphic3d_ZLayerId): void;
  DisplayMode(): Graphic3d_ZLayerId;
  SetDisplayMode(theMode: Graphic3d_ZLayerId): void;
  BasicFillAreaAspect(): Handle_Graphic3d_AspectFillArea3d;
  SetBasicFillAreaAspect(theAspect: Handle_Graphic3d_AspectFillArea3d): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare class Graphic3d_Texture2Dplane extends Graphic3d_Texture2D {
  SetPlaneS(A: Standard_ShortReal, B: Standard_ShortReal, C: Standard_ShortReal, D: Standard_ShortReal): void;
  SetPlaneT(A: Standard_ShortReal, B: Standard_ShortReal, C: Standard_ShortReal, D: Standard_ShortReal): void;
  SetPlane(thePlane: Graphic3d_NameOfTexturePlane): void;
  SetScaleS(theVal: Standard_ShortReal): void;
  SetScaleT(theVal: Standard_ShortReal): void;
  SetTranslateS(theVal: Standard_ShortReal): void;
  SetTranslateT(theVal: Standard_ShortReal): void;
  SetRotation(theVal: Standard_ShortReal): void;
  Plane(): Graphic3d_NameOfTexturePlane;
  PlaneS(A: Standard_ShortReal, B: Standard_ShortReal, C: Standard_ShortReal, D: Standard_ShortReal): void;
  PlaneT(A: Standard_ShortReal, B: Standard_ShortReal, C: Standard_ShortReal, D: Standard_ShortReal): void;
  TranslateS(theVal: Standard_ShortReal): void;
  TranslateT(theVal: Standard_ShortReal): void;
  ScaleS(theVal: Standard_ShortReal): void;
  ScaleT(theVal: Standard_ShortReal): void;
  Rotation(theVal: Standard_ShortReal): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  delete(): void;
}

  export declare class Graphic3d_Texture2Dplane_1 extends Graphic3d_Texture2Dplane {
    constructor(theFileName: XCAFDoc_PartId);
  }

  export declare class Graphic3d_Texture2Dplane_2 extends Graphic3d_Texture2Dplane {
    constructor(theNOT: Graphic3d_NameOfTexture2D);
  }

  export declare class Graphic3d_Texture2Dplane_3 extends Graphic3d_Texture2Dplane {
    constructor(thePixMap: Handle_Image_PixMap);
  }

export declare class Graphic3d_ClipPlane extends Standard_Transient {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  SetEquation_1(thePlane: gp_Pln): void;
  SetEquation_2(theEquation: OpenGl_Vec4d): void;
  GetEquation(): OpenGl_Vec4d;
  ReversedEquation(): OpenGl_Vec4d;
  IsOn(): Standard_Boolean;
  SetOn(theIsOn: Standard_Boolean): void;
  SetCapping(theIsOn: Standard_Boolean): void;
  IsCapping(): Standard_Boolean;
  ToPlane(): gp_Pln;
  Clone(): Handle_Graphic3d_ClipPlane;
  IsChain(): Standard_Boolean;
  ChainPreviousPlane(): Handle_Graphic3d_ClipPlane;
  ChainNextPlane(): Handle_Graphic3d_ClipPlane;
  NbChainNextPlanes(): Graphic3d_ZLayerId;
  SetChainNextPlane(thePlane: Handle_Graphic3d_ClipPlane): void;
  CappingColor(): Quantity_Color;
  SetCappingColor(theColor: Quantity_Color): void;
  SetCappingMaterial(theMat: Graphic3d_MaterialAspect): void;
  CappingMaterial(): Graphic3d_MaterialAspect;
  SetCappingTexture(theTexture: Handle_Graphic3d_TextureMap): void;
  CappingTexture(): Handle_Graphic3d_TextureMap;
  SetCappingHatch(theStyle: Aspect_HatchStyle): void;
  CappingHatch(): Aspect_HatchStyle;
  SetCappingCustomHatch(theStyle: Handle_Graphic3d_HatchStyle): void;
  CappingCustomHatch(): Handle_Graphic3d_HatchStyle;
  SetCappingHatchOn(): void;
  SetCappingHatchOff(): void;
  IsHatchOn(): Standard_Boolean;
  GetId(): XCAFDoc_PartId;
  CappingAspect(): Handle_Graphic3d_AspectFillArea3d;
  SetCappingAspect(theAspect: Handle_Graphic3d_AspectFillArea3d): void;
  ToUseObjectMaterial(): Standard_Boolean;
  SetUseObjectMaterial(theToUse: Standard_Boolean): void;
  ToUseObjectTexture(): Standard_Boolean;
  SetUseObjectTexture(theToUse: Standard_Boolean): void;
  ToUseObjectShader(): Standard_Boolean;
  SetUseObjectShader(theToUse: Standard_Boolean): void;
  ToUseObjectProperties(): Standard_Boolean;
  ProbePoint(thePoint: OpenGl_Vec4d): Graphic3d_ClipState;
  ProbeBox(theBox: Graphic3d_BndBox3d): Graphic3d_ClipState;
  ProbeBoxTouch(theBox: Graphic3d_BndBox3d): Standard_Boolean;
  ProbePointHalfspace(thePoint: OpenGl_Vec4d): Graphic3d_ClipState;
  ProbeBoxHalfspace(theBox: Graphic3d_BndBox3d): Graphic3d_ClipState;
  IsPointOutHalfspace(thePoint: OpenGl_Vec4d): Standard_Boolean;
  IsBoxFullOutHalfspace(theBox: Graphic3d_BndBox3d): Standard_Boolean;
  ProbeBoxMaxPointHalfspace(theBox: Graphic3d_BndBox3d): Graphic3d_ClipState;
  IsBoxFullInHalfspace(theBox: Graphic3d_BndBox3d): Standard_Boolean;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  MCountEquation(): Aspect_VKeyFlags;
  MCountAspect(): Aspect_VKeyFlags;
  delete(): void;
}

  export declare class Graphic3d_ClipPlane_1 extends Graphic3d_ClipPlane {
    constructor();
  }

  export declare class Graphic3d_ClipPlane_2 extends Graphic3d_ClipPlane {
    constructor(theOther: Graphic3d_ClipPlane);
  }

  export declare class Graphic3d_ClipPlane_3 extends Graphic3d_ClipPlane {
    constructor(theEquation: OpenGl_Vec4d);
  }

  export declare class Graphic3d_ClipPlane_4 extends Graphic3d_ClipPlane {
    constructor(thePlane: gp_Pln);
  }

export declare class Handle_Graphic3d_ClipPlane {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: Graphic3d_ClipPlane): void;
  get(): Graphic3d_ClipPlane;
  delete(): void;
}

  export declare class Handle_Graphic3d_ClipPlane_1 extends Handle_Graphic3d_ClipPlane {
    constructor();
  }

  export declare class Handle_Graphic3d_ClipPlane_2 extends Handle_Graphic3d_ClipPlane {
    constructor(thePtr: Graphic3d_ClipPlane);
  }

  export declare class Handle_Graphic3d_ClipPlane_3 extends Handle_Graphic3d_ClipPlane {
    constructor(theHandle: Handle_Graphic3d_ClipPlane);
  }

  export declare class Handle_Graphic3d_ClipPlane_4 extends Handle_Graphic3d_ClipPlane {
    constructor(theHandle: Handle_Graphic3d_ClipPlane);
  }

export declare class Graphic3d_TextureRoot extends Standard_Transient {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  static TexturesFolder(): XCAFDoc_PartId;
  IsDone(): Standard_Boolean;
  Path(): OSD_Path;
  Type(): Graphic3d_TypeOfTexture;
  GetId(): XCAFDoc_PartId;
  Revision(): Standard_ThreadId;
  UpdateRevision(): void;
  GetCompressedImage(theSupported: any): any;
  GetImage_1(theSupported: any): Handle_Image_PixMap;
  GetParams(): Handle_Graphic3d_TextureParams;
  IsColorMap(): Standard_Boolean;
  SetColorMap(theIsColor: Standard_Boolean): void;
  IsTopDown(): Standard_Boolean;
  delete(): void;
}

export declare class Graphic3d_TextureMap extends Graphic3d_TextureRoot {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  EnableSmooth(): void;
  IsSmoothed(): Standard_Boolean;
  DisableSmooth(): void;
  EnableModulate(): void;
  DisableModulate(): void;
  IsModulate(): Standard_Boolean;
  EnableRepeat(): void;
  DisableRepeat(): void;
  IsRepeat(): Standard_Boolean;
  AnisoFilter(): Graphic3d_LevelOfTextureAnisotropy;
  SetAnisoFilter(theLevel: Graphic3d_LevelOfTextureAnisotropy): void;
  delete(): void;
}

export declare class Handle_Graphic3d_TextureMap {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: Graphic3d_TextureMap): void;
  get(): Graphic3d_TextureMap;
  delete(): void;
}

  export declare class Handle_Graphic3d_TextureMap_1 extends Handle_Graphic3d_TextureMap {
    constructor();
  }

  export declare class Handle_Graphic3d_TextureMap_2 extends Handle_Graphic3d_TextureMap {
    constructor(thePtr: Graphic3d_TextureMap);
  }

  export declare class Handle_Graphic3d_TextureMap_3 extends Handle_Graphic3d_TextureMap {
    constructor(theHandle: Handle_Graphic3d_TextureMap);
  }

  export declare class Handle_Graphic3d_TextureMap_4 extends Handle_Graphic3d_TextureMap {
    constructor(theHandle: Handle_Graphic3d_TextureMap);
  }

export declare class Graphic3d_GraphicDriver extends Standard_Transient {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  InquireLimit(theType: Graphic3d_TypeOfLimit): Graphic3d_ZLayerId;
  InquireLightLimit(): Graphic3d_ZLayerId;
  InquirePlaneLimit(): Graphic3d_ZLayerId;
  InquireViewLimit(): Graphic3d_ZLayerId;
  CreateStructure(theManager: Handle_Graphic3d_StructureManager): Handle_Graphic3d_CStructure;
  RemoveStructure(theCStructure: Handle_Graphic3d_CStructure): void;
  CreateView(theMgr: Handle_Graphic3d_StructureManager): Handle_Graphic3d_CView;
  RemoveView(theView: Handle_Graphic3d_CView): void;
  EnableVBO(status: Standard_Boolean): void;
  IsVerticalSync(): Standard_Boolean;
  SetVerticalSync(theToEnable: Standard_Boolean): void;
  MemoryInfo(theFreeBytes: Standard_ThreadId, theInfo: XCAFDoc_PartId): Standard_Boolean;
  DefaultTextHeight(): Standard_ShortReal;
  TextSize(theView: Handle_Graphic3d_CView, theText: Standard_CString, theHeight: Standard_ShortReal, theWidth: Standard_ShortReal, theAscent: Standard_ShortReal, theDescent: Standard_ShortReal): void;
  InsertLayerBefore(theNewLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings, theLayerAfter: Graphic3d_ZLayerId): void;
  InsertLayerAfter(theNewLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings, theLayerBefore: Graphic3d_ZLayerId): void;
  RemoveZLayer(theLayerId: Graphic3d_ZLayerId): void;
  ZLayers(theLayerSeq: TColStd_SequenceOfInteger): void;
  SetZLayerSettings(theLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings): void;
  ZLayerSettings(theLayerId: Graphic3d_ZLayerId): Graphic3d_ZLayerSettings;
  ViewExists(theWindow: Handle_Aspect_Window, theView: Handle_Graphic3d_CView): Standard_Boolean;
  GetDisplayConnection(): Handle_Aspect_DisplayConnection;
  NewIdentification(): Graphic3d_ZLayerId;
  RemoveIdentification(theId: Graphic3d_ZLayerId): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare class Handle_Graphic3d_GraphicDriver {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: Graphic3d_GraphicDriver): void;
  get(): Graphic3d_GraphicDriver;
  delete(): void;
}

  export declare class Handle_Graphic3d_GraphicDriver_1 extends Handle_Graphic3d_GraphicDriver {
    constructor();
  }

  export declare class Handle_Graphic3d_GraphicDriver_2 extends Handle_Graphic3d_GraphicDriver {
    constructor(thePtr: Graphic3d_GraphicDriver);
  }

  export declare class Handle_Graphic3d_GraphicDriver_3 extends Handle_Graphic3d_GraphicDriver {
    constructor(theHandle: Handle_Graphic3d_GraphicDriver);
  }

  export declare class Handle_Graphic3d_GraphicDriver_4 extends Handle_Graphic3d_GraphicDriver {
    constructor(theHandle: Handle_Graphic3d_GraphicDriver);
  }

export declare class RWMesh_CafReader extends Standard_Transient {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  Document(): Handle_TDocStd_Document;
  SetDocument(theDoc: Handle_TDocStd_Document): void;
  RootPrefix(): XCAFDoc_PartId;
  SetRootPrefix(theRootPrefix: XCAFDoc_PartId): void;
  ToFillIncompleteDocument(): Standard_Boolean;
  SetFillIncompleteDocument(theToFillIncomplete: Standard_Boolean): void;
  MemoryLimitMiB(): Graphic3d_ZLayerId;
  SetMemoryLimitMiB(theLimitMiB: Graphic3d_ZLayerId): void;
  CoordinateSystemConverter(): RWMesh_CoordinateSystemConverter;
  SetCoordinateSystemConverter(theConverter: RWMesh_CoordinateSystemConverter): void;
  SystemLengthUnit(): Standard_Real;
  SetSystemLengthUnit(theUnits: Standard_Real): void;
  HasSystemCoordinateSystem(): Standard_Boolean;
  SystemCoordinateSystem(): gp_Ax3;
  SetSystemCoordinateSystem_1(theCS: gp_Ax3): void;
  SetSystemCoordinateSystem_2(theCS: RWMesh_CoordinateSystem): void;
  FileLengthUnit(): Standard_Real;
  SetFileLengthUnit(theUnits: Standard_Real): void;
  HasFileCoordinateSystem(): Standard_Boolean;
  FileCoordinateSystem(): gp_Ax3;
  SetFileCoordinateSystem_1(theCS: gp_Ax3): void;
  SetFileCoordinateSystem_2(theCS: RWMesh_CoordinateSystem): void;
  Perform(theFile: XCAFDoc_PartId, theProgress: Message_ProgressRange): Standard_Boolean;
  ExtraStatus(): Graphic3d_ZLayerId;
  SingleShape(): TopoDS_Shape;
  ExternalFiles(): any;
  Metadata(): TColStd_IndexedDataMapOfStringString;
  ProbeHeader(theFile: XCAFDoc_PartId, theProgress: Message_ProgressRange): Standard_Boolean;
  delete(): void;
}

export declare class IGESCAFControl_Reader extends IGESControl_Reader {
  Transfer(theDoc: Handle_TDocStd_Document, theProgress: Message_ProgressRange): Standard_Boolean;
  Perform_1(theFileName: XCAFDoc_PartId, theDoc: Handle_TDocStd_Document, theProgress: Message_ProgressRange): Standard_Boolean;
  Perform_2(theFileName: Standard_CString, theDoc: Handle_TDocStd_Document, theProgress: Message_ProgressRange): Standard_Boolean;
  SetColorMode(theMode: Standard_Boolean): void;
  GetColorMode(): Standard_Boolean;
  SetNameMode(theMode: Standard_Boolean): void;
  GetNameMode(): Standard_Boolean;
  SetLayerMode(theMode: Standard_Boolean): void;
  GetLayerMode(): Standard_Boolean;
  delete(): void;
}

  export declare class IGESCAFControl_Reader_1 extends IGESCAFControl_Reader {
    constructor();
  }

  export declare class IGESCAFControl_Reader_2 extends IGESCAFControl_Reader {
    constructor(theWS: Handle_XSControl_WorkSession, FromScratch: Standard_Boolean);
  }

export declare class TDataStd_GenericEmpty extends TDF_Attribute {
  Restore(a0: Handle_TDF_Attribute): void;
  Paste(a0: Handle_TDF_Attribute, a1: Handle_TDF_RelocationTable): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  delete(): void;
}

export declare class TopoDS_Shape {
  constructor()
  IsNull(): Standard_Boolean;
  Nullify(): void;
  Location_1(): TopLoc_Location;
  Location_2(theLoc: TopLoc_Location, theRaiseExc: Standard_Boolean): void;
  Located(theLoc: TopLoc_Location, theRaiseExc: Standard_Boolean): TopoDS_Shape;
  Orientation_1(): TopAbs_Orientation;
  Orientation_2(theOrient: TopAbs_Orientation): void;
  Oriented(theOrient: TopAbs_Orientation): TopoDS_Shape;
  TShape_1(): Handle_TopoDS_TShape;
  ShapeType(): TopAbs_ShapeEnum;
  Free_1(): Standard_Boolean;
  Free_2(theIsFree: Standard_Boolean): void;
  Locked_1(): Standard_Boolean;
  Locked_2(theIsLocked: Standard_Boolean): void;
  Modified_1(): Standard_Boolean;
  Modified_2(theIsModified: Standard_Boolean): void;
  Checked_1(): Standard_Boolean;
  Checked_2(theIsChecked: Standard_Boolean): void;
  Orientable_1(): Standard_Boolean;
  Orientable_2(theIsOrientable: Standard_Boolean): void;
  Closed_1(): Standard_Boolean;
  Closed_2(theIsClosed: Standard_Boolean): void;
  Infinite_1(): Standard_Boolean;
  Infinite_2(theIsInfinite: Standard_Boolean): void;
  Convex_1(): Standard_Boolean;
  Convex_2(theIsConvex: Standard_Boolean): void;
  Move(thePosition: TopLoc_Location, theRaiseExc: Standard_Boolean): void;
  Moved(thePosition: TopLoc_Location, theRaiseExc: Standard_Boolean): TopoDS_Shape;
  Reverse(): void;
  Reversed(): TopoDS_Shape;
  Complement(): void;
  Complemented(): TopoDS_Shape;
  Compose(theOrient: TopAbs_Orientation): void;
  Composed(theOrient: TopAbs_Orientation): TopoDS_Shape;
  NbChildren(): Graphic3d_ZLayerId;
  IsPartner(theOther: TopoDS_Shape): Standard_Boolean;
  IsSame(theOther: TopoDS_Shape): Standard_Boolean;
  IsEqual(theOther: TopoDS_Shape): Standard_Boolean;
  IsNotEqual(theOther: TopoDS_Shape): Standard_Boolean;
  HashCode(theUpperBound: Graphic3d_ZLayerId): Graphic3d_ZLayerId;
  EmptyCopy(): void;
  EmptyCopied(): TopoDS_Shape;
  TShape_2(theTShape: Handle_TopoDS_TShape): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare class TopoDS_Compound extends TopoDS_Shape {
  constructor()
  delete(): void;
}

export declare class TopoDS_Builder {
  constructor();
  MakeWire(W: TopoDS_Wire): void;
  MakeShell(S: TopoDS_Shell): void;
  MakeSolid(S: TopoDS_Solid): void;
  MakeCompSolid(C: TopoDS_CompSolid): void;
  MakeCompound(C: TopoDS_Compound): void;
  Add(S: TopoDS_Shape, C: TopoDS_Shape): void;
  Remove(S: TopoDS_Shape, C: TopoDS_Shape): void;
  delete(): void;
}

export declare class AIS_ViewCube extends AIS_InteractiveObject {
  constructor()
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  static IsBoxSide(theOrient: V3d_TypeOfOrientation): Standard_Boolean;
  static IsBoxEdge(theOrient: V3d_TypeOfOrientation): Standard_Boolean;
  static IsBoxCorner(theOrient: V3d_TypeOfOrientation): Standard_Boolean;
  ViewAnimation(): Handle_AIS_AnimationCamera;
  SetViewAnimation(theAnimation: Handle_AIS_AnimationCamera): void;
  ToAutoStartAnimation(): Standard_Boolean;
  SetAutoStartAnimation(theToEnable: Standard_Boolean): void;
  IsFixedAnimationLoop(): Standard_Boolean;
  SetFixedAnimationLoop(theToEnable: Standard_Boolean): void;
  ResetStyles(): void;
  Size(): Standard_Real;
  SetSize(theValue: Standard_Real, theToAdaptAnother: Standard_Boolean): void;
  BoxFacetExtension(): Standard_Real;
  SetBoxFacetExtension(theValue: Standard_Real): void;
  AxesPadding(): Standard_Real;
  SetAxesPadding(theValue: Standard_Real): void;
  BoxEdgeGap(): Standard_Real;
  SetBoxEdgeGap(theValue: Standard_Real): void;
  BoxEdgeMinSize(): Standard_Real;
  SetBoxEdgeMinSize(theValue: Standard_Real): void;
  BoxCornerMinSize(): Standard_Real;
  SetBoxCornerMinSize(theValue: Standard_Real): void;
  RoundRadius(): Standard_Real;
  SetRoundRadius(theValue: Standard_Real): void;
  AxesRadius(): Standard_Real;
  SetAxesRadius(theRadius: Standard_Real): void;
  AxesConeRadius(): Standard_Real;
  SetAxesConeRadius(theRadius: Standard_Real): void;
  AxesSphereRadius(): Standard_Real;
  SetAxesSphereRadius(theRadius: Standard_Real): void;
  ToDrawAxes(): Standard_Boolean;
  SetDrawAxes(theValue: Standard_Boolean): void;
  ToDrawEdges(): Standard_Boolean;
  SetDrawEdges(theValue: Standard_Boolean): void;
  ToDrawVertices(): Standard_Boolean;
  SetDrawVertices(theValue: Standard_Boolean): void;
  IsYup(): Standard_Boolean;
  SetYup(theIsYup: Standard_Boolean, theToUpdateLabels: Standard_Boolean): void;
  BoxSideStyle(): Handle_Prs3d_ShadingAspect;
  BoxEdgeStyle(): Handle_Prs3d_ShadingAspect;
  BoxCornerStyle(): Handle_Prs3d_ShadingAspect;
  BoxColor(): Quantity_Color;
  SetBoxColor(theColor: Quantity_Color): void;
  BoxTransparency(): Standard_Real;
  SetBoxTransparency(theValue: Standard_Real): void;
  InnerColor(): Quantity_Color;
  SetInnerColor(theColor: Quantity_Color): void;
  BoxSideLabel(theSide: V3d_TypeOfOrientation): XCAFDoc_PartId;
  SetBoxSideLabel(theSide: V3d_TypeOfOrientation, theLabel: XCAFDoc_PartId): void;
  TextColor(): Quantity_Color;
  SetTextColor(theColor: Quantity_Color): void;
  Font(): XCAFDoc_PartId;
  SetFont(theFont: XCAFDoc_PartId): void;
  FontHeight(): Standard_Real;
  SetFontHeight(theValue: Standard_Real): void;
  AxisLabel(theAxis: Prs3d_DatumParts): XCAFDoc_PartId;
  SetAxesLabels(theX: XCAFDoc_PartId, theY: XCAFDoc_PartId, theZ: XCAFDoc_PartId): void;
  SetColor(theColor: Quantity_Color): void;
  UnsetColor(): void;
  SetTransparency(theValue: Standard_Real): void;
  UnsetTransparency(): void;
  SetMaterial(theMat: Graphic3d_MaterialAspect): void;
  UnsetMaterial(): void;
  Duration(): Standard_Real;
  SetDuration(theValue: Standard_Real): void;
  ToResetCameraUp(): Standard_Boolean;
  SetResetCamera(theToReset: Standard_Boolean): void;
  ToFitSelected(): Standard_Boolean;
  SetFitSelected(theToFitSelected: Standard_Boolean): void;
  HasAnimation(): Standard_Boolean;
  StartAnimation(theOwner: any): void;
  UpdateAnimation(theToUpdate: Standard_Boolean): Standard_Boolean;
  HandleClick(theOwner: any): void;
  AcceptDisplayMode(theMode: Graphic3d_ZLayerId): Standard_Boolean;
  GlobalSelOwner(): Handle_SelectMgr_EntityOwner;
  Compute(thePrsMgr: Handle_PrsMgr_PresentationManager, thePrs: any, theMode: Graphic3d_ZLayerId): void;
  ComputeSelection(theSelection: Handle_SelectMgr_Selection, theMode: Graphic3d_ZLayerId): void;
  IsAutoHilight(): Standard_Boolean;
  ClearSelected(): void;
  HilightOwnerWithColor(thePM: Handle_PrsMgr_PresentationManager, theStyle: Handle_Prs3d_Drawer, theOwner: Handle_SelectMgr_EntityOwner): void;
  HilightSelected(thePM: Handle_PrsMgr_PresentationManager, theSeq: SelectMgr_SequenceOfOwner): void;
  UnsetAttributes(): void;
  UnsetHilightAttributes(): void;
  delete(): void;
}

export declare class AIS_ConnectedInteractive extends AIS_InteractiveObject {
  constructor(aTypeOfPresentation3d: PrsMgr_TypeOfPresentation3d)
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  Type(): AIS_KindOfInteractive;
  Signature(): Graphic3d_ZLayerId;
  Connect_1(theAnotherObj: Handle_AIS_InteractiveObject): void;
  Connect_2(theAnotherObj: Handle_AIS_InteractiveObject, theLocation: gp_Trsf): void;
  Connect_3(theAnotherObj: Handle_AIS_InteractiveObject, theLocation: Handle_TopLoc_Datum3D): void;
  HasConnection(): Standard_Boolean;
  ConnectedTo(): Handle_AIS_InteractiveObject;
  Disconnect(): void;
  AcceptShapeDecomposition(): Standard_Boolean;
  AcceptDisplayMode(theMode: Graphic3d_ZLayerId): Standard_Boolean;
  delete(): void;
}

export declare class Handle_AIS_InteractiveObject {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: AIS_InteractiveObject): void;
  get(): AIS_InteractiveObject;
  delete(): void;
}

  export declare class Handle_AIS_InteractiveObject_1 extends Handle_AIS_InteractiveObject {
    constructor();
  }

  export declare class Handle_AIS_InteractiveObject_2 extends Handle_AIS_InteractiveObject {
    constructor(thePtr: AIS_InteractiveObject);
  }

  export declare class Handle_AIS_InteractiveObject_3 extends Handle_AIS_InteractiveObject {
    constructor(theHandle: Handle_AIS_InteractiveObject);
  }

  export declare class Handle_AIS_InteractiveObject_4 extends Handle_AIS_InteractiveObject {
    constructor(theHandle: Handle_AIS_InteractiveObject);
  }

export declare class AIS_InteractiveObject extends SelectMgr_SelectableObject {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  Type(): AIS_KindOfInteractive;
  Signature(): Graphic3d_ZLayerId;
  Redisplay(AllModes: Standard_Boolean): void;
  HasInteractiveContext(): Standard_Boolean;
  InteractiveContext(): AIS_InteractiveContext;
  SetContext(aCtx: Handle_AIS_InteractiveContext): void;
  HasOwner(): Standard_Boolean;
  GetOwner(): Handle_Standard_Transient;
  SetOwner(theApplicativeEntity: Handle_Standard_Transient): void;
  ClearOwner(): void;
  ProcessDragging(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View, theOwner: Handle_SelectMgr_EntityOwner, theDragFrom: OpenGl_Vec2i, theDragTo: OpenGl_Vec2i, theAction: AIS_DragAction): Standard_Boolean;
  GetContext(): Handle_AIS_InteractiveContext;
  HasPresentation(): Standard_Boolean;
  Presentation(): any;
  SetAspect(anAspect: Handle_Prs3d_BasicAspect): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare class AIS_Shape extends AIS_InteractiveObject {
  constructor(shap: TopoDS_Shape)
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  Signature(): Graphic3d_ZLayerId;
  Type(): AIS_KindOfInteractive;
  AcceptShapeDecomposition(): Standard_Boolean;
  AcceptDisplayMode(theMode: Graphic3d_ZLayerId): Standard_Boolean;
  Shape(): TopoDS_Shape;
  SetShape(theShape: TopoDS_Shape): void;
  Set(theShape: TopoDS_Shape): void;
  SetOwnDeviationCoefficient_1(): Standard_Boolean;
  SetOwnDeviationAngle_1(): Standard_Boolean;
  SetOwnDeviationCoefficient_2(aCoefficient: Standard_Real): void;
  SetAngleAndDeviation(anAngle: Standard_Real): void;
  UserAngle(): Standard_Real;
  SetOwnDeviationAngle_2(anAngle: Standard_Real): void;
  OwnDeviationCoefficient(aCoefficient: Standard_Real, aPreviousCoefficient: Standard_Real): Standard_Boolean;
  OwnDeviationAngle(anAngle: Standard_Real, aPreviousAngle: Standard_Real): Standard_Boolean;
  SetTypeOfHLR(theTypeOfHLR: Prs3d_TypeOfHLR): void;
  TypeOfHLR(): Prs3d_TypeOfHLR;
  SetColor(theColor: Quantity_Color): void;
  UnsetColor(): void;
  SetWidth(aValue: Standard_Real): void;
  UnsetWidth(): void;
  SetMaterial(aName: Graphic3d_MaterialAspect): void;
  UnsetMaterial(): void;
  SetTransparency(aValue: Standard_Real): void;
  UnsetTransparency(): void;
  BoundingBox_1(): Bnd_Box;
  BoundingBox_2(theBndBox: Bnd_Box): void;
  Color(aColor: Quantity_Color): void;
  Material(): Graphic3d_NameOfMaterial;
  Transparency(): Standard_Real;
  static SelectionType(theSelMode: Graphic3d_ZLayerId): TopAbs_ShapeEnum;
  static SelectionMode(theShapeType: TopAbs_ShapeEnum): Graphic3d_ZLayerId;
  TextureRepeatUV(): gp_Pnt2d;
  SetTextureRepeatUV(theRepeatUV: gp_Pnt2d): void;
  TextureOriginUV(): gp_Pnt2d;
  SetTextureOriginUV(theOriginUV: gp_Pnt2d): void;
  TextureScaleUV(): gp_Pnt2d;
  SetTextureScaleUV(theScaleUV: gp_Pnt2d): void;
  static computeHlrPresentation(theProjector: Handle_Graphic3d_Camera, thePrs: any, theShape: TopoDS_Shape, theDrawer: Handle_Prs3d_Drawer): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare type AIS_DisplayMode = {
  AIS_WireFrame: {};
  AIS_Shaded: {};
}

export declare class Handle_AIS_InteractiveContext {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: AIS_InteractiveContext): void;
  get(): AIS_InteractiveContext;
  delete(): void;
}

  export declare class Handle_AIS_InteractiveContext_1 extends Handle_AIS_InteractiveContext {
    constructor();
  }

  export declare class Handle_AIS_InteractiveContext_2 extends Handle_AIS_InteractiveContext {
    constructor(thePtr: AIS_InteractiveContext);
  }

  export declare class Handle_AIS_InteractiveContext_3 extends Handle_AIS_InteractiveContext {
    constructor(theHandle: Handle_AIS_InteractiveContext);
  }

  export declare class Handle_AIS_InteractiveContext_4 extends Handle_AIS_InteractiveContext {
    constructor(theHandle: Handle_AIS_InteractiveContext);
  }

export declare class AIS_InteractiveContext extends Standard_Transient {
  constructor(MainViewer: Handle_V3d_Viewer)
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  DisplayStatus(anIobj: Handle_AIS_InteractiveObject): AIS_DisplayStatus;
  Status(anObj: Handle_AIS_InteractiveObject, astatus: TCollection_ExtendedString): void;
  IsDisplayed_1(anIobj: Handle_AIS_InteractiveObject): Standard_Boolean;
  IsDisplayed_2(aniobj: Handle_AIS_InteractiveObject, aMode: Graphic3d_ZLayerId): Standard_Boolean;
  SetAutoActivateSelection(theIsAuto: Standard_Boolean): void;
  GetAutoActivateSelection(): Standard_Boolean;
  Display_1(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  Display_2(theIObj: Handle_AIS_InteractiveObject, theDispMode: Graphic3d_ZLayerId, theSelectionMode: Graphic3d_ZLayerId, theToUpdateViewer: Standard_Boolean, theDispStatus: AIS_DisplayStatus): void;
  Load_1(theObj: Handle_AIS_InteractiveObject, theSelectionMode: Graphic3d_ZLayerId): void;
  Erase(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  EraseAll(theToUpdateViewer: Standard_Boolean): void;
  DisplayAll(theToUpdateViewer: Standard_Boolean): void;
  EraseSelected(theToUpdateViewer: Standard_Boolean): void;
  DisplaySelected(theToUpdateViewer: Standard_Boolean): void;
  ClearPrs(theIObj: Handle_AIS_InteractiveObject, theMode: Graphic3d_ZLayerId, theToUpdateViewer: Standard_Boolean): void;
  Remove(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  RemoveAll(theToUpdateViewer: Standard_Boolean): void;
  Redisplay_1(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean, theAllModes: Standard_Boolean): void;
  Redisplay_2(theTypeOfObject: AIS_KindOfInteractive, theSignature: Graphic3d_ZLayerId, theToUpdateViewer: Standard_Boolean): void;
  RecomputePrsOnly(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean, theAllModes: Standard_Boolean): void;
  RecomputeSelectionOnly(anIObj: Handle_AIS_InteractiveObject): void;
  Update(theIObj: Handle_AIS_InteractiveObject, theUpdateViewer: Standard_Boolean): void;
  HighlightStyle_1(theStyleType: Prs3d_TypeOfHighlight): Handle_Prs3d_Drawer;
  SetHighlightStyle_1(theStyleType: Prs3d_TypeOfHighlight, theStyle: Handle_Prs3d_Drawer): void;
  HighlightStyle_2(): Handle_Prs3d_Drawer;
  SetHighlightStyle_2(theStyle: Handle_Prs3d_Drawer): void;
  SelectionStyle(): Handle_Prs3d_Drawer;
  SetSelectionStyle(theStyle: Handle_Prs3d_Drawer): void;
  HighlightStyle_3(theObj: Handle_AIS_InteractiveObject, theStyle: Handle_Prs3d_Drawer): Standard_Boolean;
  HighlightStyle_4(theOwner: Handle_SelectMgr_EntityOwner, theStyle: Handle_Prs3d_Drawer): Standard_Boolean;
  IsHilighted_1(theObj: Handle_AIS_InteractiveObject): Standard_Boolean;
  IsHilighted_2(theOwner: Handle_SelectMgr_EntityOwner): Standard_Boolean;
  HilightWithColor(theObj: Handle_AIS_InteractiveObject, theStyle: Handle_Prs3d_Drawer, theToUpdateViewer: Standard_Boolean): void;
  Unhilight(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  DisplayPriority(theIObj: Handle_AIS_InteractiveObject): Graphic3d_ZLayerId;
  SetDisplayPriority(theIObj: Handle_AIS_InteractiveObject, thePriority: Graphic3d_ZLayerId): void;
  GetZLayer(theIObj: Handle_AIS_InteractiveObject): Graphic3d_ZLayerId;
  SetZLayer(theIObj: Handle_AIS_InteractiveObject, theLayerId: Graphic3d_ZLayerId): void;
  SetViewAffinity(theIObj: Handle_AIS_InteractiveObject, theView: Handle_V3d_View, theIsVisible: Standard_Boolean): void;
  DisplayMode(): Graphic3d_ZLayerId;
  SetDisplayMode_1(theMode: Graphic3d_ZLayerId, theToUpdateViewer: Standard_Boolean): void;
  SetDisplayMode_2(theIObj: Handle_AIS_InteractiveObject, theMode: Graphic3d_ZLayerId, theToUpdateViewer: Standard_Boolean): void;
  UnsetDisplayMode(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  SetLocation(theObject: Handle_AIS_InteractiveObject, theLocation: TopLoc_Location): void;
  ResetLocation(theObject: Handle_AIS_InteractiveObject): void;
  HasLocation(theObject: Handle_AIS_InteractiveObject): Standard_Boolean;
  Location(theObject: Handle_AIS_InteractiveObject): TopLoc_Location;
  SetTransformPersistence(theObject: Handle_AIS_InteractiveObject, theTrsfPers: Handle_Graphic3d_TransformPers): void;
  SetPixelTolerance(thePrecision: Graphic3d_ZLayerId): void;
  PixelTolerance(): Graphic3d_ZLayerId;
  SetSelectionSensitivity(theObject: Handle_AIS_InteractiveObject, theMode: Graphic3d_ZLayerId, theNewSensitivity: Graphic3d_ZLayerId): void;
  LastActiveView(): Handle_V3d_View;
  MoveTo_1(theXPix: Graphic3d_ZLayerId, theYPix: Graphic3d_ZLayerId, theView: Handle_V3d_View, theToRedrawOnUpdate: Standard_Boolean): AIS_StatusOfDetection;
  MoveTo_2(theAxis: gp_Ax1, theView: Handle_V3d_View, theToRedrawOnUpdate: Standard_Boolean): AIS_StatusOfDetection;
  ClearDetected(theToRedrawImmediate: Standard_Boolean): Standard_Boolean;
  HasDetected(): Standard_Boolean;
  DetectedOwner(): Handle_SelectMgr_EntityOwner;
  DetectedInteractive(): Handle_AIS_InteractiveObject;
  HasDetectedShape(): Standard_Boolean;
  DetectedShape(): TopoDS_Shape;
  HasNextDetected(): Standard_Boolean;
  HilightNextDetected(theView: Handle_V3d_View, theToRedrawImmediate: Standard_Boolean): Graphic3d_ZLayerId;
  HilightPreviousDetected(theView: Handle_V3d_View, theToRedrawImmediate: Standard_Boolean): Graphic3d_ZLayerId;
  InitDetected(): void;
  MoreDetected(): Standard_Boolean;
  NextDetected(): void;
  DetectedCurrentOwner(): Handle_SelectMgr_EntityOwner;
  AddSelect_1(theObject: Handle_SelectMgr_EntityOwner): AIS_StatusOfPick;
  AddSelect_2(theObject: Handle_AIS_InteractiveObject): AIS_StatusOfPick;
  SelectRectangle(thePntMin: OpenGl_Vec2i, thePntMax: OpenGl_Vec2i, theView: Handle_V3d_View, theSelScheme: AIS_SelectionScheme): AIS_StatusOfPick;
  SelectPolygon(thePolyline: TColgp_Array1OfPnt2d, theView: Handle_V3d_View, theSelScheme: AIS_SelectionScheme): AIS_StatusOfPick;
  SelectPoint(thePnt: OpenGl_Vec2i, theView: Handle_V3d_View, theSelScheme: AIS_SelectionScheme): AIS_StatusOfPick;
  SelectDetected(theSelScheme: AIS_SelectionScheme): AIS_StatusOfPick;
  BoundingBoxOfSelection(): Bnd_Box;
  Select_1(theOwners: AIS_NArray1OfEntityOwner, theSelScheme: AIS_SelectionScheme): AIS_StatusOfPick;
  FitSelected_1(theView: Handle_V3d_View, theMargin: Standard_Real, theToUpdate: Standard_Boolean): void;
  FitSelected_2(theView: Handle_V3d_View): void;
  ToHilightSelected(): Standard_Boolean;
  SetToHilightSelected(toHilight: Standard_Boolean): void;
  AutomaticHilight(): Standard_Boolean;
  SetAutomaticHilight(theStatus: Standard_Boolean): void;
  SetSelected_1(theOwners: Handle_SelectMgr_EntityOwner, theToUpdateViewer: Standard_Boolean): void;
  SetSelected_2(theObject: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  AddOrRemoveSelected_1(theObject: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  SetSelectedState(theOwner: Handle_SelectMgr_EntityOwner, theIsSelected: Standard_Boolean): Standard_Boolean;
  HilightSelected(theToUpdateViewer: Standard_Boolean): void;
  UnhilightSelected(theToUpdateViewer: Standard_Boolean): void;
  UpdateSelected(theToUpdateViewer: Standard_Boolean): void;
  ClearSelected(theToUpdateViewer: Standard_Boolean): void;
  AddOrRemoveSelected_2(theOwner: Handle_SelectMgr_EntityOwner, theToUpdateViewer: Standard_Boolean): void;
  IsSelected_1(theOwner: Handle_SelectMgr_EntityOwner): Standard_Boolean;
  IsSelected_2(theObj: Handle_AIS_InteractiveObject): Standard_Boolean;
  FirstSelectedObject(): Handle_AIS_InteractiveObject;
  NbSelected(): Graphic3d_ZLayerId;
  InitSelected(): void;
  MoreSelected(): Standard_Boolean;
  NextSelected(): void;
  SelectedOwner(): Handle_SelectMgr_EntityOwner;
  SelectedInteractive(): Handle_AIS_InteractiveObject;
  HasSelectedShape(): Standard_Boolean;
  SelectedShape(): TopoDS_Shape;
  HasApplicative(): Standard_Boolean;
  Applicative(): Handle_Standard_Transient;
  BeginImmediateDraw(): Standard_Boolean;
  ImmediateAdd(theObj: Handle_AIS_InteractiveObject, theMode: Graphic3d_ZLayerId): Standard_Boolean;
  EndImmediateDraw_1(theView: Handle_V3d_View): Standard_Boolean;
  EndImmediateDraw_2(): Standard_Boolean;
  IsImmediateModeOn(): Standard_Boolean;
  RedrawImmediate(theViewer: Handle_V3d_Viewer): void;
  SetSelectionModeActive(theObj: Handle_AIS_InteractiveObject, theMode: Graphic3d_ZLayerId, theToActivate: Standard_Boolean, theConcurrency: AIS_SelectionModesConcurrency, theIsForce: Standard_Boolean): void;
  Activate_1(theObj: Handle_AIS_InteractiveObject, theMode: Graphic3d_ZLayerId, theIsForce: Standard_Boolean): void;
  Activate_2(theMode: Graphic3d_ZLayerId, theIsForce: Standard_Boolean): void;
  Deactivate_1(theObj: Handle_AIS_InteractiveObject): void;
  Deactivate_2(theObj: Handle_AIS_InteractiveObject, theMode: Graphic3d_ZLayerId): void;
  Deactivate_3(theMode: Graphic3d_ZLayerId): void;
  Deactivate_4(): void;
  ActivatedModes(anIobj: Handle_AIS_InteractiveObject, theList: TColStd_ListOfInteger): void;
  EntityOwners(theOwners: any, theIObj: Handle_AIS_InteractiveObject, theMode: Graphic3d_ZLayerId): void;
  FilterType(): SelectMgr_FilterType;
  SetFilterType(theFilterType: SelectMgr_FilterType): void;
  Filters(): SelectMgr_ListOfFilter;
  GlobalFilter(): Handle_SelectMgr_AndOrFilter;
  AddFilter(theFilter: Handle_SelectMgr_Filter): void;
  RemoveFilter(theFilter: Handle_SelectMgr_Filter): void;
  RemoveFilters(): void;
  PickingStrategy(): SelectMgr_PickingStrategy;
  SetPickingStrategy(theStrategy: SelectMgr_PickingStrategy): void;
  DefaultDrawer(): Handle_Prs3d_Drawer;
  SetDefaultDrawer(theDrawer: Handle_Prs3d_Drawer): void;
  CurrentViewer(): Handle_V3d_Viewer;
  SelectionManager(): Handle_SelectMgr_SelectionManager;
  MainPrsMgr(): Handle_PrsMgr_PresentationManager;
  MainSelector(): any;
  UpdateCurrentViewer(): void;
  DisplayedObjects_1(aListOfIO: AIS_ListOfInteractive): void;
  DisplayedObjects_2(theWhichKind: AIS_KindOfInteractive, theWhichSignature: Graphic3d_ZLayerId, theListOfIO: AIS_ListOfInteractive): void;
  ErasedObjects_1(theListOfIO: AIS_ListOfInteractive): void;
  ErasedObjects_2(theWhichKind: AIS_KindOfInteractive, theWhichSignature: Graphic3d_ZLayerId, theListOfIO: AIS_ListOfInteractive): void;
  ObjectsByDisplayStatus_1(theStatus: AIS_DisplayStatus, theListOfIO: AIS_ListOfInteractive): void;
  ObjectsByDisplayStatus_2(WhichKind: AIS_KindOfInteractive, WhichSignature: Graphic3d_ZLayerId, theStatus: AIS_DisplayStatus, theListOfIO: AIS_ListOfInteractive): void;
  ObjectsInside(aListOfIO: AIS_ListOfInteractive, WhichKind: AIS_KindOfInteractive, WhichSignature: Graphic3d_ZLayerId): void;
  ObjectIterator(): AIS_DataMapIteratorOfDataMapOfIOStatus;
  RebuildSelectionStructs(): void;
  Disconnect(theAssembly: Handle_AIS_InteractiveObject, theObjToDisconnect: Handle_AIS_InteractiveObject): void;
  ObjectsForView(theListOfIO: AIS_ListOfInteractive, theView: Handle_V3d_View, theIsVisibleInView: Standard_Boolean, theStatus: AIS_DisplayStatus): void;
  GravityPoint(theView: Handle_V3d_View): gp_Pnt;
  DisplayActiveSensitive_1(aView: Handle_V3d_View): void;
  ClearActiveSensitive(aView: Handle_V3d_View): void;
  DisplayActiveSensitive_2(anObject: Handle_AIS_InteractiveObject, aView: Handle_V3d_View): void;
  SetLocalAttributes(theIObj: Handle_AIS_InteractiveObject, theDrawer: Handle_Prs3d_Drawer, theToUpdateViewer: Standard_Boolean): void;
  UnsetLocalAttributes(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  SetCurrentFacingModel(aniobj: Handle_AIS_InteractiveObject, aModel: Aspect_TypeOfFacingModel): void;
  HasColor(aniobj: Handle_AIS_InteractiveObject): Standard_Boolean;
  Color(aniobj: Handle_AIS_InteractiveObject, acolor: Quantity_Color): void;
  SetColor(theIObj: Handle_AIS_InteractiveObject, theColor: Quantity_Color, theToUpdateViewer: Standard_Boolean): void;
  UnsetColor(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  Width(aniobj: Handle_AIS_InteractiveObject): Standard_Real;
  SetWidth(theIObj: Handle_AIS_InteractiveObject, theValue: Standard_Real, theToUpdateViewer: Standard_Boolean): void;
  UnsetWidth(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  SetMaterial(theIObj: Handle_AIS_InteractiveObject, theMaterial: Graphic3d_MaterialAspect, theToUpdateViewer: Standard_Boolean): void;
  UnsetMaterial(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  SetTransparency(theIObj: Handle_AIS_InteractiveObject, theValue: Standard_Real, theToUpdateViewer: Standard_Boolean): void;
  UnsetTransparency(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  SetPolygonOffsets(theIObj: Handle_AIS_InteractiveObject, theMode: Graphic3d_ZLayerId, theFactor: Standard_ShortReal, theUnits: Standard_ShortReal, theToUpdateViewer: Standard_Boolean): void;
  HasPolygonOffsets(anObj: Handle_AIS_InteractiveObject): Standard_Boolean;
  PolygonOffsets(anObj: Handle_AIS_InteractiveObject, aMode: Graphic3d_ZLayerId, aFactor: Standard_ShortReal, aUnits: Standard_ShortReal): void;
  SetTrihedronSize(theSize: Standard_Real, theToUpdateViewer: Standard_Boolean): void;
  TrihedronSize(): Standard_Real;
  SetPlaneSize_1(theSizeX: Standard_Real, theSizeY: Standard_Real, theToUpdateViewer: Standard_Boolean): void;
  SetPlaneSize_2(theSize: Standard_Real, theToUpdateViewer: Standard_Boolean): void;
  PlaneSize(XSize: Standard_Real, YSize: Standard_Real): Standard_Boolean;
  SetDeviationCoefficient_1(theIObj: Handle_AIS_InteractiveObject, theCoefficient: Standard_Real, theToUpdateViewer: Standard_Boolean): void;
  SetDeviationAngle_1(theIObj: Handle_AIS_InteractiveObject, theAngle: Standard_Real, theToUpdateViewer: Standard_Boolean): void;
  SetAngleAndDeviation(theIObj: Handle_AIS_InteractiveObject, theAngle: Standard_Real, theToUpdateViewer: Standard_Boolean): void;
  SetDeviationCoefficient_2(theCoefficient: Standard_Real): void;
  DeviationCoefficient(): Standard_Real;
  SetDeviationAngle_2(theAngle: Standard_Real): void;
  DeviationAngle(): Standard_Real;
  HiddenLineAspect(): Handle_Prs3d_LineAspect;
  SetHiddenLineAspect(theAspect: Handle_Prs3d_LineAspect): void;
  DrawHiddenLine(): Standard_Boolean;
  EnableDrawHiddenLine(): void;
  DisableDrawHiddenLine(): void;
  SetIsoNumber(NbIsos: Graphic3d_ZLayerId, WhichIsos: AIS_TypeOfIso): void;
  IsoNumber(WhichIsos: AIS_TypeOfIso): Graphic3d_ZLayerId;
  IsoOnPlane_1(theToSwitchOn: Standard_Boolean): void;
  IsoOnPlane_2(): Standard_Boolean;
  IsoOnTriangulation_1(theIsEnabled: Standard_Boolean, theObject: Handle_AIS_InteractiveObject): void;
  IsoOnTriangulation_2(theToSwitchOn: Standard_Boolean): void;
  IsoOnTriangulation_3(): Standard_Boolean;
  Display_3(theIObj: Handle_AIS_InteractiveObject, theDispMode: Graphic3d_ZLayerId, theSelectionMode: Graphic3d_ZLayerId, theToUpdateViewer: Standard_Boolean, theToAllowDecomposition: Standard_Boolean, theDispStatus: AIS_DisplayStatus): void;
  Load_2(theObj: Handle_AIS_InteractiveObject, theSelectionMode: Graphic3d_ZLayerId, a2: Standard_Boolean): void;
  Hilight(theObj: Handle_AIS_InteractiveObject, theIsToUpdateViewer: Standard_Boolean): void;
  SetSelectedAspect(theAspect: Handle_Prs3d_BasicAspect, theToUpdateViewer: Standard_Boolean): void;
  Select_2(theXPMin: Graphic3d_ZLayerId, theYPMin: Graphic3d_ZLayerId, theXPMax: Graphic3d_ZLayerId, theYPMax: Graphic3d_ZLayerId, theView: Handle_V3d_View, theToUpdateViewer: Standard_Boolean): AIS_StatusOfPick;
  Select_3(thePolyline: TColgp_Array1OfPnt2d, theView: Handle_V3d_View, theToUpdateViewer: Standard_Boolean): AIS_StatusOfPick;
  Select_4(theToUpdateViewer: Standard_Boolean): AIS_StatusOfPick;
  ShiftSelect_1(theToUpdateViewer: Standard_Boolean): AIS_StatusOfPick;
  ShiftSelect_2(thePolyline: TColgp_Array1OfPnt2d, theView: Handle_V3d_View, theToUpdateViewer: Standard_Boolean): AIS_StatusOfPick;
  ShiftSelect_3(theXPMin: Graphic3d_ZLayerId, theYPMin: Graphic3d_ZLayerId, theXPMax: Graphic3d_ZLayerId, theYPMax: Graphic3d_ZLayerId, theView: Handle_V3d_View, theToUpdateViewer: Standard_Boolean): AIS_StatusOfPick;
  SetCurrentObject(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  AddOrRemoveCurrentObject(theObj: Handle_AIS_InteractiveObject, theIsToUpdateViewer: Standard_Boolean): void;
  UpdateCurrent(): void;
  IsCurrent(theObject: Handle_AIS_InteractiveObject): Standard_Boolean;
  InitCurrent(): void;
  MoreCurrent(): Standard_Boolean;
  NextCurrent(): void;
  Current(): Handle_AIS_InteractiveObject;
  NbCurrents(): Graphic3d_ZLayerId;
  HilightCurrents(theToUpdateViewer: Standard_Boolean): void;
  UnhilightCurrents(theToUpdateViewer: Standard_Boolean): void;
  ClearCurrents(theToUpdateViewer: Standard_Boolean): void;
  DetectedCurrentShape(): TopoDS_Shape;
  DetectedCurrentObject(): Handle_AIS_InteractiveObject;
  SubIntensityColor(): Quantity_Color;
  SetSubIntensityColor(theColor: Quantity_Color): void;
  SubIntensityOn(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  SubIntensityOff(theIObj: Handle_AIS_InteractiveObject, theToUpdateViewer: Standard_Boolean): void;
  Selection(): Handle_AIS_Selection;
  SetSelection(theSelection: Handle_AIS_Selection): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare class AIS_ColoredShape extends AIS_Shape {
  CustomAspects(theShape: TopoDS_Shape): Handle_AIS_ColoredDrawer;
  ClearCustomAspects(): void;
  UnsetCustomAspects(theShape: TopoDS_Shape, theToUnregister: Standard_Boolean): void;
  SetCustomColor(theShape: TopoDS_Shape, theColor: Quantity_Color): void;
  SetCustomTransparency(theShape: TopoDS_Shape, theTransparency: Standard_Real): void;
  SetCustomWidth(theShape: TopoDS_Shape, theLineWidth: Standard_Real): void;
  CustomAspectsMap(): AIS_DataMapOfShapeDrawer;
  ChangeCustomAspectsMap(): AIS_DataMapOfShapeDrawer;
  SetColor(theColor: Quantity_Color): void;
  SetWidth(theLineWidth: Standard_Real): void;
  SetTransparency(theValue: Standard_Real): void;
  SetMaterial(theAspect: Graphic3d_MaterialAspect): void;
  UnsetTransparency(): void;
  UnsetWidth(): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  delete(): void;
}

  export declare class AIS_ColoredShape_1 extends AIS_ColoredShape {
    constructor(theShape: TopoDS_Shape);
  }

  export declare class AIS_ColoredShape_2 extends AIS_ColoredShape {
    constructor(theShape: Handle_AIS_Shape);
  }

export declare class AIS_ViewController extends Aspect_WindowInputListener {
  constructor()
  InputBuffer(theType: AIS_ViewInputBufferType): AIS_ViewInputBuffer;
  ChangeInputBuffer(theType: AIS_ViewInputBufferType): AIS_ViewInputBuffer;
  ViewAnimation(): Handle_AIS_AnimationCamera;
  SetViewAnimation(theAnimation: Handle_AIS_AnimationCamera): void;
  AbortViewAnimation(): void;
  ObjectsAnimation(): Handle_AIS_Animation;
  SetObjectsAnimation(theAnimation: Handle_AIS_Animation): void;
  ToPauseObjectsAnimation(): Standard_Boolean;
  SetPauseObjectsAnimation(theToPause: Standard_Boolean): void;
  IsContinuousRedraw(): Standard_Boolean;
  SetContinuousRedraw(theToEnable: Standard_Boolean): void;
  RotationMode(): AIS_RotationMode;
  SetRotationMode(theMode: AIS_RotationMode): void;
  NavigationMode(): AIS_NavigationMode;
  SetNavigationMode(theMode: AIS_NavigationMode): void;
  MouseAcceleration(): Standard_ShortReal;
  SetMouseAcceleration(theRatio: Standard_ShortReal): void;
  OrbitAcceleration(): Standard_ShortReal;
  SetOrbitAcceleration(theRatio: Standard_ShortReal): void;
  ToShowPanAnchorPoint(): Standard_Boolean;
  SetShowPanAnchorPoint(theToShow: Standard_Boolean): void;
  ToShowRotateCenter(): Standard_Boolean;
  SetShowRotateCenter(theToShow: Standard_Boolean): void;
  ToLockOrbitZUp(): Standard_Boolean;
  SetLockOrbitZUp(theToForceUp: Standard_Boolean): void;
  ToAllowTouchZRotation(): Standard_Boolean;
  SetAllowTouchZRotation(theToEnable: Standard_Boolean): void;
  ToAllowRotation(): Standard_Boolean;
  SetAllowRotation(theToEnable: Standard_Boolean): void;
  ToAllowPanning(): Standard_Boolean;
  SetAllowPanning(theToEnable: Standard_Boolean): void;
  ToAllowZooming(): Standard_Boolean;
  SetAllowZooming(theToEnable: Standard_Boolean): void;
  ToAllowZFocus(): Standard_Boolean;
  SetAllowZFocus(theToEnable: Standard_Boolean): void;
  ToAllowHighlight(): Standard_Boolean;
  SetAllowHighlight(theToEnable: Standard_Boolean): void;
  ToAllowDragging(): Standard_Boolean;
  SetAllowDragging(theToEnable: Standard_Boolean): void;
  ToStickToRayOnZoom(): Standard_Boolean;
  SetStickToRayOnZoom(theToEnable: Standard_Boolean): void;
  ToStickToRayOnRotation(): Standard_Boolean;
  SetStickToRayOnRotation(theToEnable: Standard_Boolean): void;
  ToInvertPitch(): Standard_Boolean;
  SetInvertPitch(theToInvert: Standard_Boolean): void;
  WalkSpeedAbsolute(): Standard_ShortReal;
  SetWalkSpeedAbsolute(theSpeed: Standard_ShortReal): void;
  WalkSpeedRelative(): Standard_ShortReal;
  SetWalkSpeedRelative(theFactor: Standard_ShortReal): void;
  ThrustSpeed(): Standard_ShortReal;
  SetThrustSpeed(theSpeed: Standard_ShortReal): void;
  HasPreviousMoveTo(): Standard_Boolean;
  PreviousMoveTo(): OpenGl_Vec2i;
  ResetPreviousMoveTo(): void;
  ToDisplayXRAuxDevices(): Standard_Boolean;
  SetDisplayXRAuxDevices(theToDisplay: Standard_Boolean): void;
  ToDisplayXRHands(): Standard_Boolean;
  SetDisplayXRHands(theToDisplay: Standard_Boolean): void;
  KeyDown(theKey: Aspect_VKey, theTime: Standard_Real, thePressure: Standard_Real): void;
  KeyUp(theKey: Aspect_VKey, theTime: Standard_Real): void;
  KeyFromAxis(theNegative: Aspect_VKey, thePositive: Aspect_VKey, theTime: Standard_Real, thePressure: Standard_Real): void;
  FetchNavigationKeys(theCrouchRatio: Standard_Real, theRunRatio: Standard_Real): AIS_WalkDelta;
  MouseGestureMap(): AIS_MouseGestureMap;
  ChangeMouseGestureMap(): AIS_MouseGestureMap;
  MouseSelectionSchemes(): AIS_MouseSelectionSchemeMap;
  ChangeMouseSelectionSchemes(): AIS_MouseSelectionSchemeMap;
  MouseDoubleClickInterval(): Standard_Real;
  SetMouseDoubleClickInterval(theSeconds: Standard_Real): void;
  SelectInViewer_1(thePnt: OpenGl_Vec2i, theScheme: AIS_SelectionScheme): void;
  SelectInViewer_2(thePnts: NCollection_Sequence<Graphic3d_Vec2i>, theScheme: AIS_SelectionScheme): void;
  UpdateRubberBand(thePntFrom: OpenGl_Vec2i, thePntTo: OpenGl_Vec2i): void;
  UpdatePolySelection(thePnt: OpenGl_Vec2i, theToAppend: Standard_Boolean): void;
  UpdateZoom(theDelta: Aspect_ScrollDelta): Standard_Boolean;
  UpdateZRotation(theAngle: Standard_Real): Standard_Boolean;
  UpdateMouseScroll(theDelta: Aspect_ScrollDelta): Standard_Boolean;
  UpdateMouseButtons(thePoint: OpenGl_Vec2i, theButtons: Aspect_VKeyMouse, theModifiers: Aspect_VKeyFlags, theIsEmulated: Standard_Boolean): Standard_Boolean;
  UpdateMousePosition(thePoint: OpenGl_Vec2i, theButtons: Aspect_VKeyMouse, theModifiers: Aspect_VKeyFlags, theIsEmulated: Standard_Boolean): Standard_Boolean;
  UpdateMouseClick(thePoint: OpenGl_Vec2i, theButton: Aspect_VKeyMouse, theModifiers: Aspect_VKeyFlags, theIsDoubleClick: Standard_Boolean): Standard_Boolean;
  TouchToleranceScale(): Standard_ShortReal;
  SetTouchToleranceScale(theTolerance: Standard_ShortReal): void;
  AddTouchPoint(theId: Standard_ThreadId, thePnt: OpenGl_Vec2d, theClearBefore: Standard_Boolean): void;
  RemoveTouchPoint(theId: Standard_ThreadId, theClearSelectPnts: Standard_Boolean): Standard_Boolean;
  UpdateTouchPoint(theId: Standard_ThreadId, thePnt: OpenGl_Vec2d): void;
  Update3dMouse(theEvent: WNT_HIDSpaceMouse): Standard_Boolean;
  ProcessExpose(): void;
  ProcessConfigure(theIsResized: Standard_Boolean): void;
  ProcessInput(): void;
  ProcessFocus(theIsActivated: Standard_Boolean): void;
  ProcessClose(): void;
  ResetViewInput(): void;
  UpdateViewOrientation(theOrientation: V3d_TypeOfOrientation, theToFitAll: Standard_Boolean): void;
  FlushViewEvents(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View, theToHandle: Standard_Boolean): void;
  HandleViewEvents(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): void;
  OnSelectionChanged(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): void;
  OnObjectDragged(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View, theAction: AIS_DragAction): void;
  PickPoint(thePnt: gp_Pnt, theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View, theCursor: OpenGl_Vec2i, theToStickToPickRay: Standard_Boolean): Standard_Boolean;
  PickAxis(theTopPnt: gp_Pnt, theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View, theAxis: gp_Ax1): Standard_Boolean;
  GravityPoint(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): gp_Pnt;
  FitAllAuto(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): void;
  handleViewOrientationKeys(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): void;
  handleNavigationKeys(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): AIS_WalkDelta;
  handleCameraActions(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View, theWalk: AIS_WalkDelta): void;
  handleMoveTo(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): void;
  toAskNextFrame(): Standard_Boolean;
  setAskNextFrame(theToDraw: Standard_Boolean): void;
  hasPanningAnchorPoint(): Standard_Boolean;
  panningAnchorPoint(): gp_Pnt;
  setPanningAnchorPoint(thePnt: gp_Pnt): void;
  handlePanning(theView: Handle_V3d_View): void;
  handleZRotate(theView: Handle_V3d_View): void;
  MinZoomDistance(): Standard_Real;
  SetMinZoomDistance(theDist: Standard_Real): void;
  handleZoom(theView: Handle_V3d_View, theParams: Aspect_ScrollDelta, thePnt: gp_Pnt): void;
  handleZFocusScroll(theView: Handle_V3d_View, theParams: Aspect_ScrollDelta): void;
  handleOrbitRotation(theView: Handle_V3d_View, thePnt: gp_Pnt, theToLockZUp: Standard_Boolean): void;
  handleViewRotation(theView: Handle_V3d_View, theYawExtra: Standard_Real, thePitchExtra: Standard_Real, theRoll: Standard_Real, theToRestartOnIncrement: Standard_Boolean): void;
  handleViewRedraw(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): void;
  handleXRInput(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View, theWalk: AIS_WalkDelta): void;
  handleXRTurnPad(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): void;
  handleXRTeleport(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): void;
  handleXRPicking(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): void;
  handleXRHighlight(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): void;
  handleXRPresentations(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View): void;
  handleXRMoveTo(theCtx: Handle_AIS_InteractiveContext, theView: Handle_V3d_View, thePose: gp_Trsf, theToHighlight: Standard_Boolean): Graphic3d_ZLayerId;
  delete(): void;
}

export declare class StdPrs_ToolTriangulatedShape {
  constructor();
  static IsTriangulated(theShape: TopoDS_Shape): Standard_Boolean;
  static IsClosed(theShape: TopoDS_Shape): Standard_Boolean;
  static ComputeNormals_1(theFace: TopoDS_Face, theTris: Handle_Poly_Triangulation): void;
  static ComputeNormals_2(theFace: TopoDS_Face, theTris: Handle_Poly_Triangulation, thePolyConnect: Poly_Connect): void;
  static Normal(theFace: TopoDS_Face, thePolyConnect: Poly_Connect, theNormals: TColgp_Array1OfDir): void;
  static GetDeflection(theShape: TopoDS_Shape, theDrawer: Handle_Prs3d_Drawer): Standard_Real;
  static IsTessellated(theShape: TopoDS_Shape, theDrawer: Handle_Prs3d_Drawer): Standard_Boolean;
  static Tessellate(theShape: TopoDS_Shape, theDrawer: Handle_Prs3d_Drawer): Standard_Boolean;
  static ClearOnOwnDeflectionChange(theShape: TopoDS_Shape, theDrawer: Handle_Prs3d_Drawer, theToResetCoeff: Standard_Boolean): void;
  delete(): void;
}

export declare class Bnd_Box {
  SetWhole(): void;
  SetVoid(): void;
  Set_1(P: gp_Pnt): void;
  Set_2(P: gp_Pnt, D: gp_Dir): void;
  Update_1(aXmin: Standard_Real, aYmin: Standard_Real, aZmin: Standard_Real, aXmax: Standard_Real, aYmax: Standard_Real, aZmax: Standard_Real): void;
  Update_2(X: Standard_Real, Y: Standard_Real, Z: Standard_Real): void;
  GetGap(): Standard_Real;
  SetGap(Tol: Standard_Real): void;
  Enlarge(Tol: Standard_Real): void;
  Get(theXmin: Standard_Real, theYmin: Standard_Real, theZmin: Standard_Real, theXmax: Standard_Real, theYmax: Standard_Real, theZmax: Standard_Real): void;
  CornerMin(): gp_Pnt;
  CornerMax(): gp_Pnt;
  OpenXmin(): void;
  OpenXmax(): void;
  OpenYmin(): void;
  OpenYmax(): void;
  OpenZmin(): void;
  OpenZmax(): void;
  IsOpen(): Standard_Boolean;
  IsOpenXmin(): Standard_Boolean;
  IsOpenXmax(): Standard_Boolean;
  IsOpenYmin(): Standard_Boolean;
  IsOpenYmax(): Standard_Boolean;
  IsOpenZmin(): Standard_Boolean;
  IsOpenZmax(): Standard_Boolean;
  IsWhole(): Standard_Boolean;
  IsVoid(): Standard_Boolean;
  IsXThin(tol: Standard_Real): Standard_Boolean;
  IsYThin(tol: Standard_Real): Standard_Boolean;
  IsZThin(tol: Standard_Real): Standard_Boolean;
  IsThin(tol: Standard_Real): Standard_Boolean;
  Transformed(T: gp_Trsf): Bnd_Box;
  Add_1(Other: Bnd_Box): void;
  Add_2(P: gp_Pnt): void;
  Add_3(P: gp_Pnt, D: gp_Dir): void;
  Add_4(D: gp_Dir): void;
  IsOut_1(P: gp_Pnt): Standard_Boolean;
  IsOut_2(L: gp_Lin): Standard_Boolean;
  IsOut_3(P: gp_Pln): Standard_Boolean;
  IsOut_4(Other: Bnd_Box): Standard_Boolean;
  IsOut_5(Other: Bnd_Box, T: gp_Trsf): Standard_Boolean;
  IsOut_6(T1: gp_Trsf, Other: Bnd_Box, T2: gp_Trsf): Standard_Boolean;
  IsOut_7(P1: gp_Pnt, P2: gp_Pnt, D: gp_Dir): Standard_Boolean;
  Distance(Other: Bnd_Box): Standard_Real;
  Dump(): void;
  SquareExtent(): Standard_Real;
  FinitePart(): Bnd_Box;
  HasFinitePart(): Standard_Boolean;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  InitFromJson(theSStream: Standard_SStream, theStreamPos: Graphic3d_ZLayerId): Standard_Boolean;
  delete(): void;
}

  export declare class Bnd_Box_1 extends Bnd_Box {
    constructor();
  }

  export declare class Bnd_Box_2 extends Bnd_Box {
    constructor(theMin: gp_Pnt, theMax: gp_Pnt);
  }

export declare class XCAFDoc_ShapeTool extends TDataStd_GenericEmpty {
  constructor()
  static GetID(): Standard_GUID;
  static Set(L: TDF_Label): Handle_XCAFDoc_ShapeTool;
  IsTopLevel(L: TDF_Label): Standard_Boolean;
  static IsFree(L: TDF_Label): Standard_Boolean;
  static IsShape(L: TDF_Label): Standard_Boolean;
  static IsSimpleShape(L: TDF_Label): Standard_Boolean;
  static IsReference(L: TDF_Label): Standard_Boolean;
  static IsAssembly(L: TDF_Label): Standard_Boolean;
  static IsComponent(L: TDF_Label): Standard_Boolean;
  static IsCompound(L: TDF_Label): Standard_Boolean;
  static IsSubShape_1(L: TDF_Label): Standard_Boolean;
  IsSubShape_2(shapeL: TDF_Label, sub: TopoDS_Shape): Standard_Boolean;
  SearchUsingMap(S: TopoDS_Shape, L: TDF_Label, findWithoutLoc: Standard_Boolean, findSubshape: Standard_Boolean): Standard_Boolean;
  Search(S: TopoDS_Shape, L: TDF_Label, findInstance: Standard_Boolean, findComponent: Standard_Boolean, findSubshape: Standard_Boolean): Standard_Boolean;
  FindShape_1(S: TopoDS_Shape, L: TDF_Label, findInstance: Standard_Boolean): Standard_Boolean;
  FindShape_2(S: TopoDS_Shape, findInstance: Standard_Boolean): TDF_Label;
  static GetShape_1(L: TDF_Label, S: TopoDS_Shape): Standard_Boolean;
  static GetShape_2(L: TDF_Label): TopoDS_Shape;
  NewShape(): TDF_Label;
  SetShape(L: TDF_Label, S: TopoDS_Shape): void;
  AddShape(S: TopoDS_Shape, makeAssembly: Standard_Boolean, makePrepare: Standard_Boolean): TDF_Label;
  RemoveShape(L: TDF_Label, removeCompletely: Standard_Boolean): Standard_Boolean;
  Init(): void;
  static SetAutoNaming(V: Standard_Boolean): void;
  static AutoNaming(): Standard_Boolean;
  ComputeShapes(L: TDF_Label): void;
  ComputeSimpleShapes(): void;
  GetShapes(Labels: TDF_LabelSequence): void;
  GetFreeShapes(FreeLabels: TDF_LabelSequence): void;
  static GetUsers(L: TDF_Label, Labels: TDF_LabelSequence, getsubchilds: Standard_Boolean): Graphic3d_ZLayerId;
  static GetLocation(L: TDF_Label): TopLoc_Location;
  static GetReferredShape(L: TDF_Label, Label: TDF_Label): Standard_Boolean;
  static NbComponents(L: TDF_Label, getsubchilds: Standard_Boolean): Graphic3d_ZLayerId;
  static GetComponents(L: TDF_Label, Labels: TDF_LabelSequence, getsubchilds: Standard_Boolean): Standard_Boolean;
  AddComponent_1(assembly: TDF_Label, comp: TDF_Label, Loc: TopLoc_Location): TDF_Label;
  AddComponent_2(assembly: TDF_Label, comp: TopoDS_Shape, expand: Standard_Boolean): TDF_Label;
  RemoveComponent(comp: TDF_Label): void;
  UpdateAssemblies(): void;
  FindSubShape(shapeL: TDF_Label, sub: TopoDS_Shape, L: TDF_Label): Standard_Boolean;
  AddSubShape_1(shapeL: TDF_Label, sub: TopoDS_Shape): TDF_Label;
  AddSubShape_2(shapeL: TDF_Label, sub: TopoDS_Shape, addedSubShapeL: TDF_Label): Standard_Boolean;
  FindMainShapeUsingMap(sub: TopoDS_Shape): TDF_Label;
  FindMainShape(sub: TopoDS_Shape): TDF_Label;
  static GetSubShapes(L: TDF_Label, Labels: TDF_LabelSequence): Standard_Boolean;
  BaseLabel(): TDF_Label;
  static DumpShape(theDumpLog: Standard_OStream, L: TDF_Label, level: Graphic3d_ZLayerId, deep: Standard_Boolean): void;
  ID(): Standard_GUID;
  static IsExternRef(L: TDF_Label): Standard_Boolean;
  SetExternRefs_1(SHAS: TColStd_SequenceOfHAsciiString): TDF_Label;
  SetExternRefs_2(L: TDF_Label, SHAS: TColStd_SequenceOfHAsciiString): void;
  static GetExternRefs(L: TDF_Label, SHAS: TColStd_SequenceOfHAsciiString): void;
  SetSHUO(Labels: TDF_LabelSequence, MainSHUOAttr: Handle_XCAFDoc_GraphNode): Standard_Boolean;
  static GetSHUO(SHUOLabel: TDF_Label, aSHUOAttr: Handle_XCAFDoc_GraphNode): Standard_Boolean;
  static GetAllComponentSHUO(CompLabel: TDF_Label, SHUOAttrs: TDF_AttributeSequence): Standard_Boolean;
  static GetSHUOUpperUsage(NextUsageL: TDF_Label, Labels: TDF_LabelSequence): Standard_Boolean;
  static GetSHUONextUsage(UpperUsageL: TDF_Label, Labels: TDF_LabelSequence): Standard_Boolean;
  RemoveSHUO(SHUOLabel: TDF_Label): Standard_Boolean;
  FindComponent(theShape: TopoDS_Shape, Labels: TDF_LabelSequence): Standard_Boolean;
  GetSHUOInstance(theSHUO: Handle_XCAFDoc_GraphNode): TopoDS_Shape;
  SetInstanceSHUO(theShape: TopoDS_Shape): Handle_XCAFDoc_GraphNode;
  GetAllSHUOInstances(theSHUO: Handle_XCAFDoc_GraphNode, theSHUOShapeSeq: TopTools_SequenceOfShape): Standard_Boolean;
  static FindSHUO(Labels: TDF_LabelSequence, theSHUOAttr: Handle_XCAFDoc_GraphNode): Standard_Boolean;
  Expand(Shape: TDF_Label): Standard_Boolean;
  GetNamedProperties_1(theLabel: TDF_Label, theToCreate: Standard_Boolean): Handle_TDataStd_NamedData;
  GetNamedProperties_2(theShape: TopoDS_Shape, theToCreate: Standard_Boolean): Handle_TDataStd_NamedData;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  NewEmpty(): Handle_TDF_Attribute;
  delete(): void;
}

export declare class Handle_XCAFDoc_ShapeTool {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: XCAFDoc_ShapeTool): void;
  get(): XCAFDoc_ShapeTool;
  delete(): void;
}

  export declare class Handle_XCAFDoc_ShapeTool_1 extends Handle_XCAFDoc_ShapeTool {
    constructor();
  }

  export declare class Handle_XCAFDoc_ShapeTool_2 extends Handle_XCAFDoc_ShapeTool {
    constructor(thePtr: XCAFDoc_ShapeTool);
  }

  export declare class Handle_XCAFDoc_ShapeTool_3 extends Handle_XCAFDoc_ShapeTool {
    constructor(theHandle: Handle_XCAFDoc_ShapeTool);
  }

  export declare class Handle_XCAFDoc_ShapeTool_4 extends Handle_XCAFDoc_ShapeTool {
    constructor(theHandle: Handle_XCAFDoc_ShapeTool);
  }

export declare class XCAFDoc_ColorTool extends TDataStd_GenericEmpty {
  constructor()
  static AutoNaming(): Standard_Boolean;
  static SetAutoNaming(theIsAutoNaming: Standard_Boolean): void;
  static Set(L: TDF_Label): Handle_XCAFDoc_ColorTool;
  static GetID(): Standard_GUID;
  BaseLabel(): TDF_Label;
  ShapeTool(): Handle_XCAFDoc_ShapeTool;
  IsColor(lab: TDF_Label): Standard_Boolean;
  GetColor_1(lab: TDF_Label, col: Quantity_Color): Standard_Boolean;
  GetColor_2(lab: TDF_Label, col: Quantity_ColorRGBA): Standard_Boolean;
  FindColor_1(col: Quantity_Color, lab: TDF_Label): Standard_Boolean;
  FindColor_2(col: Quantity_ColorRGBA, lab: TDF_Label): Standard_Boolean;
  FindColor_3(col: Quantity_Color): TDF_Label;
  FindColor_4(col: Quantity_ColorRGBA): TDF_Label;
  AddColor_1(col: Quantity_Color): TDF_Label;
  AddColor_2(col: Quantity_ColorRGBA): TDF_Label;
  RemoveColor(lab: TDF_Label): void;
  GetColors(Labels: TDF_LabelSequence): void;
  SetColor_1(L: TDF_Label, colorL: TDF_Label, type: XCAFDoc_ColorType): void;
  SetColor_2(L: TDF_Label, Color: Quantity_Color, type: XCAFDoc_ColorType): void;
  SetColor_3(L: TDF_Label, Color: Quantity_ColorRGBA, type: XCAFDoc_ColorType): void;
  UnSetColor_1(L: TDF_Label, type: XCAFDoc_ColorType): void;
  IsSet_1(L: TDF_Label, type: XCAFDoc_ColorType): Standard_Boolean;
  static GetColor_3(L: TDF_Label, type: XCAFDoc_ColorType, colorL: TDF_Label): Standard_Boolean;
  GetColor_4(L: TDF_Label, type: XCAFDoc_ColorType, color: Quantity_Color): Standard_Boolean;
  GetColor_5(L: TDF_Label, type: XCAFDoc_ColorType, color: Quantity_ColorRGBA): Standard_Boolean;
  SetColor_4(S: TopoDS_Shape, colorL: TDF_Label, type: XCAFDoc_ColorType): Standard_Boolean;
  SetColor_5(S: TopoDS_Shape, Color: Quantity_Color, type: XCAFDoc_ColorType): Standard_Boolean;
  SetColor_6(S: TopoDS_Shape, Color: Quantity_ColorRGBA, type: XCAFDoc_ColorType): Standard_Boolean;
  UnSetColor_2(S: TopoDS_Shape, type: XCAFDoc_ColorType): Standard_Boolean;
  IsSet_2(S: TopoDS_Shape, type: XCAFDoc_ColorType): Standard_Boolean;
  GetColor_6(S: TopoDS_Shape, type: XCAFDoc_ColorType, colorL: TDF_Label): Standard_Boolean;
  GetColor_7(S: TopoDS_Shape, type: XCAFDoc_ColorType, color: Quantity_Color): Standard_Boolean;
  GetColor_8(S: TopoDS_Shape, type: XCAFDoc_ColorType, color: Quantity_ColorRGBA): Standard_Boolean;
  IsVisible(L: TDF_Label): Standard_Boolean;
  SetVisibility(shapeLabel: TDF_Label, isvisible: Standard_Boolean): void;
  IsColorByLayer(L: TDF_Label): Standard_Boolean;
  SetColorByLayer(shapeLabel: TDF_Label, isColorByLayer: Standard_Boolean): void;
  SetInstanceColor_1(theShape: TopoDS_Shape, type: XCAFDoc_ColorType, color: Quantity_Color, isCreateSHUO: Standard_Boolean): Standard_Boolean;
  SetInstanceColor_2(theShape: TopoDS_Shape, type: XCAFDoc_ColorType, color: Quantity_ColorRGBA, isCreateSHUO: Standard_Boolean): Standard_Boolean;
  GetInstanceColor_1(theShape: TopoDS_Shape, type: XCAFDoc_ColorType, color: Quantity_Color): Standard_Boolean;
  GetInstanceColor_2(theShape: TopoDS_Shape, type: XCAFDoc_ColorType, color: Quantity_ColorRGBA): Standard_Boolean;
  IsInstanceVisible(theShape: TopoDS_Shape): Standard_Boolean;
  ReverseChainsOfTreeNodes(): Standard_Boolean;
  ID(): Standard_GUID;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  NewEmpty(): Handle_TDF_Attribute;
  delete(): void;
}

export declare class XCAFDoc_DimTolTool extends TDataStd_GenericEmpty {
  constructor()
  static Set(L: TDF_Label): Handle_XCAFDoc_DimTolTool;
  static GetID(): Standard_GUID;
  BaseLabel(): TDF_Label;
  ShapeTool(): Handle_XCAFDoc_ShapeTool;
  IsDimension(theLab: TDF_Label): Standard_Boolean;
  GetDimensionLabels(theLabels: TDF_LabelSequence): void;
  SetDimension_1(theFirstLS: TDF_LabelSequence, theSecondLS: TDF_LabelSequence, theDimL: TDF_Label): void;
  SetDimension_2(theFirstL: TDF_Label, theSecondL: TDF_Label, theDimL: TDF_Label): void;
  SetDimension_3(theL: TDF_Label, theDimL: TDF_Label): void;
  GetRefDimensionLabels(theShapeL: TDF_Label, theDimensions: TDF_LabelSequence): Standard_Boolean;
  AddDimension(): TDF_Label;
  IsGeomTolerance(theLab: TDF_Label): Standard_Boolean;
  GetGeomToleranceLabels(theLabels: TDF_LabelSequence): void;
  SetGeomTolerance_1(theL: TDF_Label, theGeomTolL: TDF_Label): void;
  SetGeomTolerance_2(theL: TDF_LabelSequence, theGeomTolL: TDF_Label): void;
  GetRefGeomToleranceLabels(theShapeL: TDF_Label, theDimTols: TDF_LabelSequence): Standard_Boolean;
  AddGeomTolerance(): TDF_Label;
  IsDimTol(theLab: TDF_Label): Standard_Boolean;
  GetDimTolLabels(Labels: TDF_LabelSequence): void;
  FindDimTol_1(theKind: Graphic3d_ZLayerId, theVal: Handle_TColStd_HArray1OfReal, theName: Handle_TCollection_HAsciiString, theDescription: Handle_TCollection_HAsciiString, lab: TDF_Label): Standard_Boolean;
  FindDimTol_2(theKind: Graphic3d_ZLayerId, theVal: Handle_TColStd_HArray1OfReal, theName: Handle_TCollection_HAsciiString, theDescription: Handle_TCollection_HAsciiString): TDF_Label;
  AddDimTol(theKind: Graphic3d_ZLayerId, theVal: Handle_TColStd_HArray1OfReal, theName: Handle_TCollection_HAsciiString, theDescription: Handle_TCollection_HAsciiString): TDF_Label;
  SetDimTol_1(theL: TDF_Label, theDimTolL: TDF_Label): void;
  SetDimTol_2(theL: TDF_Label, theKind: Graphic3d_ZLayerId, theVal: Handle_TColStd_HArray1OfReal, theName: Handle_TCollection_HAsciiString, theDescription: Handle_TCollection_HAsciiString): TDF_Label;
  GetRefShapeLabel(theL: TDF_Label, theShapeLFirst: TDF_LabelSequence, theShapeLSecond: TDF_LabelSequence): Standard_Boolean;
  GetDimTol(theDimTolL: TDF_Label, theKind: Graphic3d_ZLayerId, theVal: Handle_TColStd_HArray1OfReal, theName: Handle_TCollection_HAsciiString, theDescription: Handle_TCollection_HAsciiString): Standard_Boolean;
  IsDatum(lab: TDF_Label): Standard_Boolean;
  GetDatumLabels(Labels: TDF_LabelSequence): void;
  FindDatum(theName: Handle_TCollection_HAsciiString, theDescription: Handle_TCollection_HAsciiString, theIdentification: Handle_TCollection_HAsciiString, lab: TDF_Label): Standard_Boolean;
  AddDatum_1(theName: Handle_TCollection_HAsciiString, theDescription: Handle_TCollection_HAsciiString, theIdentification: Handle_TCollection_HAsciiString): TDF_Label;
  AddDatum_2(): TDF_Label;
  SetDatum_1(theShapeLabels: TDF_LabelSequence, theDatumL: TDF_Label): void;
  SetDatum_2(theL: TDF_Label, theTolerL: TDF_Label, theName: Handle_TCollection_HAsciiString, theDescription: Handle_TCollection_HAsciiString, theIdentification: Handle_TCollection_HAsciiString): void;
  SetDatumToGeomTol(theDatumL: TDF_Label, theTolerL: TDF_Label): void;
  GetDatum(theDatumL: TDF_Label, theName: Handle_TCollection_HAsciiString, theDescription: Handle_TCollection_HAsciiString, theIdentification: Handle_TCollection_HAsciiString): Standard_Boolean;
  GetDatumOfTolerLabels(theDimTolL: TDF_Label, theDatums: TDF_LabelSequence): Standard_Boolean;
  GetDatumWithObjectOfTolerLabels(theDimTolL: TDF_Label, theDatums: TDF_LabelSequence): Standard_Boolean;
  GetTolerOfDatumLabels(theDatumL: TDF_Label, theTols: TDF_LabelSequence): Standard_Boolean;
  GetRefDatumLabel(theShapeL: TDF_Label, theDatum: TDF_LabelSequence): Standard_Boolean;
  IsLocked(theViewL: TDF_Label): Standard_Boolean;
  Lock(theViewL: TDF_Label): void;
  GetGDTPresentations(theGDTLabelToShape: NCollection_IndexedDataMap<TDF_Label, TopoDS_Shape, TDF_LabelMapHasher>): void;
  SetGDTPresentations(theGDTLabelToPrs: NCollection_IndexedDataMap<TDF_Label, TopoDS_Shape, TDF_LabelMapHasher>): void;
  Unlock(theViewL: TDF_Label): void;
  ID(): Standard_GUID;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  NewEmpty(): Handle_TDF_Attribute;
  delete(): void;
}

export declare class Handle_XCAFDoc_DimTolTool {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: XCAFDoc_DimTolTool): void;
  get(): XCAFDoc_DimTolTool;
  delete(): void;
}

  export declare class Handle_XCAFDoc_DimTolTool_1 extends Handle_XCAFDoc_DimTolTool {
    constructor();
  }

  export declare class Handle_XCAFDoc_DimTolTool_2 extends Handle_XCAFDoc_DimTolTool {
    constructor(thePtr: XCAFDoc_DimTolTool);
  }

  export declare class Handle_XCAFDoc_DimTolTool_3 extends Handle_XCAFDoc_DimTolTool {
    constructor(theHandle: Handle_XCAFDoc_DimTolTool);
  }

  export declare class Handle_XCAFDoc_DimTolTool_4 extends Handle_XCAFDoc_DimTolTool {
    constructor(theHandle: Handle_XCAFDoc_DimTolTool);
  }

export declare class XCAFDoc_DocumentTool extends TDataStd_GenericEmpty {
  constructor()
  static GetID(): Standard_GUID;
  static Set(L: TDF_Label, IsAcces: Standard_Boolean): Handle_XCAFDoc_DocumentTool;
  static IsXCAFDocument(Doc: Handle_TDocStd_Document): Standard_Boolean;
  static DocLabel(acces: TDF_Label): TDF_Label;
  static ShapesLabel(acces: TDF_Label): TDF_Label;
  static ColorsLabel(acces: TDF_Label): TDF_Label;
  static LayersLabel(acces: TDF_Label): TDF_Label;
  static DGTsLabel(acces: TDF_Label): TDF_Label;
  static MaterialsLabel(acces: TDF_Label): TDF_Label;
  static ViewsLabel(acces: TDF_Label): TDF_Label;
  static ClippingPlanesLabel(acces: TDF_Label): TDF_Label;
  static NotesLabel(acces: TDF_Label): TDF_Label;
  static VisMaterialLabel(theLabel: TDF_Label): TDF_Label;
  static ShapeTool(acces: TDF_Label): Handle_XCAFDoc_ShapeTool;
  static CheckShapeTool(theAcces: TDF_Label): Standard_Boolean;
  static ColorTool(acces: TDF_Label): Handle_XCAFDoc_ColorTool;
  static CheckColorTool(theAcces: TDF_Label): Standard_Boolean;
  static VisMaterialTool(theLabel: TDF_Label): Handle_XCAFDoc_VisMaterialTool;
  static CheckVisMaterialTool(theAcces: TDF_Label): Standard_Boolean;
  static LayerTool(acces: TDF_Label): Handle_XCAFDoc_LayerTool;
  static CheckLayerTool(theAcces: TDF_Label): Standard_Boolean;
  static DimTolTool(acces: TDF_Label): Handle_XCAFDoc_DimTolTool;
  static CheckDimTolTool(theAcces: TDF_Label): Standard_Boolean;
  static MaterialTool(acces: TDF_Label): Handle_XCAFDoc_MaterialTool;
  static CheckMaterialTool(theAcces: TDF_Label): Standard_Boolean;
  static ViewTool(acces: TDF_Label): Handle_XCAFDoc_ViewTool;
  static CheckViewTool(theAcces: TDF_Label): Standard_Boolean;
  static ClippingPlaneTool(acces: TDF_Label): Handle_XCAFDoc_ClippingPlaneTool;
  static CheckClippingPlaneTool(theAcces: TDF_Label): Standard_Boolean;
  static NotesTool(acces: TDF_Label): Handle_XCAFDoc_NotesTool;
  static CheckNotesTool(theAcces: TDF_Label): Standard_Boolean;
  static GetLengthUnit_1(theDoc: Handle_TDocStd_Document, theResut: Standard_Real, theBaseUnit: UnitsMethods_LengthUnit): Standard_Boolean;
  static GetLengthUnit_2(theDoc: Handle_TDocStd_Document, theResut: Standard_Real): Standard_Boolean;
  static SetLengthUnit_1(theDoc: Handle_TDocStd_Document, theUnitValue: Standard_Real): void;
  static SetLengthUnit_2(theDoc: Handle_TDocStd_Document, theUnitValue: Standard_Real, theBaseUnit: UnitsMethods_LengthUnit): void;
  Init(): void;
  ID(): Standard_GUID;
  AfterRetrieval(forceIt: Standard_Boolean): Standard_Boolean;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  NewEmpty(): Handle_TDF_Attribute;
  delete(): void;
}

export declare type XCAFDoc_ColorType = {
  XCAFDoc_ColorGen: {};
  XCAFDoc_ColorSurf: {};
  XCAFDoc_ColorCurv: {};
}

export declare class TDocStd_Document extends CDM_Document {
  constructor(astorageformat: TCollection_ExtendedString)
  static Get(L: TDF_Label): Handle_TDocStd_Document;
  IsSaved(): Standard_Boolean;
  IsChanged(): Standard_Boolean;
  SetSaved(): void;
  SetSavedTime(theTime: Graphic3d_ZLayerId): void;
  GetSavedTime(): Graphic3d_ZLayerId;
  GetName(): TCollection_ExtendedString;
  GetPath(): TCollection_ExtendedString;
  SetData(data: Handle_TDF_Data): void;
  GetData(): Handle_TDF_Data;
  Main(): TDF_Label;
  IsEmpty(): Standard_Boolean;
  IsValid(): Standard_Boolean;
  SetModified(L: TDF_Label): void;
  PurgeModified(): void;
  GetModified(): TDF_LabelMap;
  NewCommand(): void;
  HasOpenCommand(): Standard_Boolean;
  OpenCommand(): void;
  CommitCommand(): Standard_Boolean;
  AbortCommand(): void;
  GetUndoLimit(): Graphic3d_ZLayerId;
  SetUndoLimit(L: Graphic3d_ZLayerId): void;
  ClearUndos(): void;
  ClearRedos(): void;
  GetAvailableUndos(): Graphic3d_ZLayerId;
  Undo(): Standard_Boolean;
  GetAvailableRedos(): Graphic3d_ZLayerId;
  Redo(): Standard_Boolean;
  GetUndos(): TDF_DeltaList;
  GetRedos(): TDF_DeltaList;
  RemoveFirstUndo(): void;
  InitDeltaCompaction(): Standard_Boolean;
  PerformDeltaCompaction(): Standard_Boolean;
  UpdateReferences(aDocEntry: XCAFDoc_PartId): void;
  Recompute(): void;
  Update(aToDocument: Handle_CDM_Document, aReferenceIdentifier: Graphic3d_ZLayerId, aModifContext: Standard_Address): void;
  StorageFormat(): TCollection_ExtendedString;
  SetEmptyLabelsSavingMode(isAllowed: Standard_Boolean): void;
  EmptyLabelsSavingMode(): Standard_Boolean;
  ChangeStorageFormat(newStorageFormat: TCollection_ExtendedString): void;
  SetNestedTransactionMode(isAllowed: Standard_Boolean): void;
  IsNestedTransactionMode(): Standard_Boolean;
  SetModificationMode(theTransactionOnly: Standard_Boolean): void;
  ModificationMode(): Standard_Boolean;
  BeforeClose(): void;
  StorageFormatVersion(): TDocStd_FormatVersion;
  ChangeStorageFormatVersion(theVersion: TDocStd_FormatVersion): void;
  static CurrentStorageFormatVersion(): TDocStd_FormatVersion;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  delete(): void;
}

export declare class Handle_TDocStd_Document {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: TDocStd_Document): void;
  get(): TDocStd_Document;
  delete(): void;
}

  export declare class Handle_TDocStd_Document_1 extends Handle_TDocStd_Document {
    constructor();
  }

  export declare class Handle_TDocStd_Document_2 extends Handle_TDocStd_Document {
    constructor(thePtr: TDocStd_Document);
  }

  export declare class Handle_TDocStd_Document_3 extends Handle_TDocStd_Document {
    constructor(theHandle: Handle_TDocStd_Document);
  }

  export declare class Handle_TDocStd_Document_4 extends Handle_TDocStd_Document {
    constructor(theHandle: Handle_TDocStd_Document);
  }

export declare class BRep_Builder extends TopoDS_Builder {
  constructor();
  MakeFace_1(F: TopoDS_Face): void;
  MakeFace_2(F: TopoDS_Face, S: Handle_Geom_Surface, Tol: Standard_Real): void;
  MakeFace_3(F: TopoDS_Face, S: Handle_Geom_Surface, L: TopLoc_Location, Tol: Standard_Real): void;
  MakeFace_4(theFace: TopoDS_Face, theTriangulation: Handle_Poly_Triangulation): void;
  MakeFace_5(theFace: TopoDS_Face, theTriangulations: Poly_ListOfTriangulation, theActiveTriangulation: Handle_Poly_Triangulation): void;
  UpdateFace_1(F: TopoDS_Face, S: Handle_Geom_Surface, L: TopLoc_Location, Tol: Standard_Real): void;
  UpdateFace_2(theFace: TopoDS_Face, theTriangulation: Handle_Poly_Triangulation, theToReset: Standard_Boolean): void;
  UpdateFace_3(F: TopoDS_Face, Tol: Standard_Real): void;
  NaturalRestriction(F: TopoDS_Face, N: Standard_Boolean): void;
  MakeEdge_1(E: TopoDS_Edge): void;
  MakeEdge_2(E: TopoDS_Edge, C: Handle_Geom_Curve, Tol: Standard_Real): void;
  MakeEdge_3(E: TopoDS_Edge, C: Handle_Geom_Curve, L: TopLoc_Location, Tol: Standard_Real): void;
  MakeEdge_4(E: TopoDS_Edge, P: Handle_Poly_Polygon3D): void;
  MakeEdge_5(E: TopoDS_Edge, N: Handle_Poly_PolygonOnTriangulation, T: Handle_Poly_Triangulation): void;
  MakeEdge_6(E: TopoDS_Edge, N: Handle_Poly_PolygonOnTriangulation, T: Handle_Poly_Triangulation, L: TopLoc_Location): void;
  UpdateEdge_1(E: TopoDS_Edge, C: Handle_Geom_Curve, Tol: Standard_Real): void;
  UpdateEdge_2(E: TopoDS_Edge, C: Handle_Geom_Curve, L: TopLoc_Location, Tol: Standard_Real): void;
  UpdateEdge_3(E: TopoDS_Edge, C: Handle_Geom2d_Curve, F: TopoDS_Face, Tol: Standard_Real): void;
  UpdateEdge_4(E: TopoDS_Edge, C1: Handle_Geom2d_Curve, C2: Handle_Geom2d_Curve, F: TopoDS_Face, Tol: Standard_Real): void;
  UpdateEdge_5(E: TopoDS_Edge, C: Handle_Geom2d_Curve, S: Handle_Geom_Surface, L: TopLoc_Location, Tol: Standard_Real): void;
  UpdateEdge_6(E: TopoDS_Edge, C: Handle_Geom2d_Curve, S: Handle_Geom_Surface, L: TopLoc_Location, Tol: Standard_Real, Pf: gp_Pnt2d, Pl: gp_Pnt2d): void;
  UpdateEdge_7(E: TopoDS_Edge, C1: Handle_Geom2d_Curve, C2: Handle_Geom2d_Curve, S: Handle_Geom_Surface, L: TopLoc_Location, Tol: Standard_Real): void;
  UpdateEdge_8(E: TopoDS_Edge, C1: Handle_Geom2d_Curve, C2: Handle_Geom2d_Curve, S: Handle_Geom_Surface, L: TopLoc_Location, Tol: Standard_Real, Pf: gp_Pnt2d, Pl: gp_Pnt2d): void;
  UpdateEdge_9(E: TopoDS_Edge, P: Handle_Poly_Polygon3D): void;
  UpdateEdge_10(E: TopoDS_Edge, P: Handle_Poly_Polygon3D, L: TopLoc_Location): void;
  UpdateEdge_11(E: TopoDS_Edge, N: Handle_Poly_PolygonOnTriangulation, T: Handle_Poly_Triangulation): void;
  UpdateEdge_12(E: TopoDS_Edge, N: Handle_Poly_PolygonOnTriangulation, T: Handle_Poly_Triangulation, L: TopLoc_Location): void;
  UpdateEdge_13(E: TopoDS_Edge, N1: Handle_Poly_PolygonOnTriangulation, N2: Handle_Poly_PolygonOnTriangulation, T: Handle_Poly_Triangulation): void;
  UpdateEdge_14(E: TopoDS_Edge, N1: Handle_Poly_PolygonOnTriangulation, N2: Handle_Poly_PolygonOnTriangulation, T: Handle_Poly_Triangulation, L: TopLoc_Location): void;
  UpdateEdge_15(E: TopoDS_Edge, P: Handle_Poly_Polygon2D, S: TopoDS_Face): void;
  UpdateEdge_16(E: TopoDS_Edge, P: Handle_Poly_Polygon2D, S: Handle_Geom_Surface, T: TopLoc_Location): void;
  UpdateEdge_17(E: TopoDS_Edge, P1: Handle_Poly_Polygon2D, P2: Handle_Poly_Polygon2D, S: TopoDS_Face): void;
  UpdateEdge_18(E: TopoDS_Edge, P1: Handle_Poly_Polygon2D, P2: Handle_Poly_Polygon2D, S: Handle_Geom_Surface, L: TopLoc_Location): void;
  UpdateEdge_19(E: TopoDS_Edge, Tol: Standard_Real): void;
  Continuity_1(E: TopoDS_Edge, F1: TopoDS_Face, F2: TopoDS_Face, C: GeomAbs_Shape): void;
  Continuity_2(E: TopoDS_Edge, S1: Handle_Geom_Surface, S2: Handle_Geom_Surface, L1: TopLoc_Location, L2: TopLoc_Location, C: GeomAbs_Shape): void;
  SameParameter(E: TopoDS_Edge, S: Standard_Boolean): void;
  SameRange(E: TopoDS_Edge, S: Standard_Boolean): void;
  Degenerated(E: TopoDS_Edge, D: Standard_Boolean): void;
  Range_1(E: TopoDS_Edge, First: Standard_Real, Last: Standard_Real, Only3d: Standard_Boolean): void;
  Range_2(E: TopoDS_Edge, S: Handle_Geom_Surface, L: TopLoc_Location, First: Standard_Real, Last: Standard_Real): void;
  Range_3(E: TopoDS_Edge, F: TopoDS_Face, First: Standard_Real, Last: Standard_Real): void;
  Transfert_1(Ein: TopoDS_Edge, Eout: TopoDS_Edge): void;
  MakeVertex_1(V: TopoDS_Vertex): void;
  MakeVertex_2(V: TopoDS_Vertex, P: gp_Pnt, Tol: Standard_Real): void;
  UpdateVertex_1(V: TopoDS_Vertex, P: gp_Pnt, Tol: Standard_Real): void;
  UpdateVertex_2(V: TopoDS_Vertex, P: Standard_Real, E: TopoDS_Edge, Tol: Standard_Real): void;
  UpdateVertex_3(V: TopoDS_Vertex, P: Standard_Real, E: TopoDS_Edge, F: TopoDS_Face, Tol: Standard_Real): void;
  UpdateVertex_4(V: TopoDS_Vertex, P: Standard_Real, E: TopoDS_Edge, S: Handle_Geom_Surface, L: TopLoc_Location, Tol: Standard_Real): void;
  UpdateVertex_5(Ve: TopoDS_Vertex, U: Standard_Real, V: Standard_Real, F: TopoDS_Face, Tol: Standard_Real): void;
  UpdateVertex_6(V: TopoDS_Vertex, Tol: Standard_Real): void;
  Transfert_2(Ein: TopoDS_Edge, Eout: TopoDS_Edge, Vin: TopoDS_Vertex, Vout: TopoDS_Vertex): void;
  delete(): void;
}

export declare class Prs3d_Drawer extends Graphic3d_PresentationAttributes {
  constructor()
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  SetTypeOfDeflection(theTypeOfDeflection: Aspect_TypeOfDeflection): void;
  TypeOfDeflection(): Aspect_TypeOfDeflection;
  HasOwnTypeOfDeflection(): Standard_Boolean;
  UnsetOwnTypeOfDeflection(): void;
  SetMaximalChordialDeviation(theChordialDeviation: Standard_Real): void;
  MaximalChordialDeviation(): Standard_Real;
  HasOwnMaximalChordialDeviation(): Standard_Boolean;
  UnsetOwnMaximalChordialDeviation(): void;
  SetTypeOfHLR(theTypeOfHLR: Prs3d_TypeOfHLR): void;
  TypeOfHLR(): Prs3d_TypeOfHLR;
  HasOwnTypeOfHLR(): Standard_Boolean;
  SetMaximalParameterValue(theValue: Standard_Real): void;
  MaximalParameterValue(): Standard_Real;
  HasOwnMaximalParameterValue(): Standard_Boolean;
  UnsetOwnMaximalParameterValue(): void;
  SetIsoOnPlane(theIsEnabled: Standard_Boolean): void;
  IsoOnPlane(): Standard_Boolean;
  HasOwnIsoOnPlane(): Standard_Boolean;
  UnsetOwnIsoOnPlane(): void;
  IsoOnTriangulation(): Standard_Boolean;
  HasOwnIsoOnTriangulation(): Standard_Boolean;
  UnsetOwnIsoOnTriangulation(): void;
  SetIsoOnTriangulation(theToEnable: Standard_Boolean): void;
  SetDiscretisation(theValue: Graphic3d_ZLayerId): void;
  Discretisation(): Graphic3d_ZLayerId;
  HasOwnDiscretisation(): Standard_Boolean;
  UnsetOwnDiscretisation(): void;
  SetDeviationCoefficient_1(theCoefficient: Standard_Real): void;
  DeviationCoefficient(): Standard_Real;
  SetDeviationCoefficient_2(): void;
  HasOwnDeviationCoefficient(): Standard_Boolean;
  PreviousDeviationCoefficient(): Standard_Real;
  UpdatePreviousDeviationCoefficient(): void;
  SetDeviationAngle_1(theAngle: Standard_Real): void;
  DeviationAngle(): Standard_Real;
  SetDeviationAngle_2(): void;
  HasOwnDeviationAngle(): Standard_Boolean;
  PreviousDeviationAngle(): Standard_Real;
  UpdatePreviousDeviationAngle(): void;
  SetAutoTriangulation(theIsEnabled: Standard_Boolean): void;
  IsAutoTriangulation(): Standard_Boolean;
  HasOwnIsAutoTriangulation(): Standard_Boolean;
  UnsetOwnIsAutoTriangulation(): void;
  UIsoAspect(): Handle_Prs3d_IsoAspect;
  SetUIsoAspect(theAspect: Handle_Prs3d_IsoAspect): void;
  HasOwnUIsoAspect(): Standard_Boolean;
  VIsoAspect(): Handle_Prs3d_IsoAspect;
  SetVIsoAspect(theAspect: Handle_Prs3d_IsoAspect): void;
  HasOwnVIsoAspect(): Standard_Boolean;
  WireAspect(): Handle_Prs3d_LineAspect;
  SetWireAspect(theAspect: Handle_Prs3d_LineAspect): void;
  HasOwnWireAspect(): Standard_Boolean;
  SetWireDraw(theIsEnabled: Standard_Boolean): void;
  WireDraw(): Standard_Boolean;
  HasOwnWireDraw(): Standard_Boolean;
  UnsetOwnWireDraw(): void;
  PointAspect(): Handle_Prs3d_PointAspect;
  SetPointAspect(theAspect: Handle_Prs3d_PointAspect): void;
  HasOwnPointAspect(): Standard_Boolean;
  SetupOwnPointAspect(theDefaults: Handle_Prs3d_Drawer): Standard_Boolean;
  LineAspect(): Handle_Prs3d_LineAspect;
  SetLineAspect(theAspect: Handle_Prs3d_LineAspect): void;
  HasOwnLineAspect(): Standard_Boolean;
  SetOwnLineAspects(theDefaults: Handle_Prs3d_Drawer): Standard_Boolean;
  SetOwnDatumAspects(theDefaults: Handle_Prs3d_Drawer): Standard_Boolean;
  TextAspect(): Handle_Prs3d_TextAspect;
  SetTextAspect(theAspect: Handle_Prs3d_TextAspect): void;
  HasOwnTextAspect(): Standard_Boolean;
  ShadingAspect(): Handle_Prs3d_ShadingAspect;
  SetShadingAspect(theAspect: Handle_Prs3d_ShadingAspect): void;
  HasOwnShadingAspect(): Standard_Boolean;
  SetupOwnShadingAspect(theDefaults: Handle_Prs3d_Drawer): Standard_Boolean;
  SeenLineAspect(): Handle_Prs3d_LineAspect;
  SetSeenLineAspect(theAspect: Handle_Prs3d_LineAspect): void;
  HasOwnSeenLineAspect(): Standard_Boolean;
  PlaneAspect(): Handle_Prs3d_PlaneAspect;
  SetPlaneAspect(theAspect: Handle_Prs3d_PlaneAspect): void;
  HasOwnPlaneAspect(): Standard_Boolean;
  ArrowAspect(): Handle_Prs3d_ArrowAspect;
  SetArrowAspect(theAspect: Handle_Prs3d_ArrowAspect): void;
  HasOwnArrowAspect(): Standard_Boolean;
  SetLineArrowDraw(theIsEnabled: Standard_Boolean): void;
  LineArrowDraw(): Standard_Boolean;
  HasOwnLineArrowDraw(): Standard_Boolean;
  UnsetOwnLineArrowDraw(): void;
  HiddenLineAspect(): Handle_Prs3d_LineAspect;
  SetHiddenLineAspect(theAspect: Handle_Prs3d_LineAspect): void;
  HasOwnHiddenLineAspect(): Standard_Boolean;
  DrawHiddenLine(): Standard_Boolean;
  EnableDrawHiddenLine(): void;
  DisableDrawHiddenLine(): void;
  HasOwnDrawHiddenLine(): Standard_Boolean;
  UnsetOwnDrawHiddenLine(): void;
  VectorAspect(): Handle_Prs3d_LineAspect;
  SetVectorAspect(theAspect: Handle_Prs3d_LineAspect): void;
  HasOwnVectorAspect(): Standard_Boolean;
  SetVertexDrawMode(theMode: Prs3d_VertexDrawMode): void;
  VertexDrawMode(): Prs3d_VertexDrawMode;
  HasOwnVertexDrawMode(): Standard_Boolean;
  DatumAspect(): Handle_Prs3d_DatumAspect;
  SetDatumAspect(theAspect: Handle_Prs3d_DatumAspect): void;
  HasOwnDatumAspect(): Standard_Boolean;
  SectionAspect(): Handle_Prs3d_LineAspect;
  SetSectionAspect(theAspect: Handle_Prs3d_LineAspect): void;
  HasOwnSectionAspect(): Standard_Boolean;
  SetFreeBoundaryAspect(theAspect: Handle_Prs3d_LineAspect): void;
  FreeBoundaryAspect(): Handle_Prs3d_LineAspect;
  HasOwnFreeBoundaryAspect(): Standard_Boolean;
  SetFreeBoundaryDraw(theIsEnabled: Standard_Boolean): void;
  FreeBoundaryDraw(): Standard_Boolean;
  HasOwnFreeBoundaryDraw(): Standard_Boolean;
  UnsetOwnFreeBoundaryDraw(): void;
  SetUnFreeBoundaryAspect(theAspect: Handle_Prs3d_LineAspect): void;
  UnFreeBoundaryAspect(): Handle_Prs3d_LineAspect;
  HasOwnUnFreeBoundaryAspect(): Standard_Boolean;
  SetUnFreeBoundaryDraw(theIsEnabled: Standard_Boolean): void;
  UnFreeBoundaryDraw(): Standard_Boolean;
  HasOwnUnFreeBoundaryDraw(): Standard_Boolean;
  UnsetOwnUnFreeBoundaryDraw(): void;
  SetFaceBoundaryAspect(theAspect: Handle_Prs3d_LineAspect): void;
  FaceBoundaryAspect(): Handle_Prs3d_LineAspect;
  HasOwnFaceBoundaryAspect(): Standard_Boolean;
  SetupOwnFaceBoundaryAspect(theDefaults: Handle_Prs3d_Drawer): Standard_Boolean;
  SetFaceBoundaryDraw(theIsEnabled: Standard_Boolean): void;
  FaceBoundaryDraw(): Standard_Boolean;
  HasOwnFaceBoundaryDraw(): Standard_Boolean;
  UnsetOwnFaceBoundaryDraw(): void;
  HasOwnFaceBoundaryUpperContinuity(): Standard_Boolean;
  FaceBoundaryUpperContinuity(): GeomAbs_Shape;
  SetFaceBoundaryUpperContinuity(theMostAllowedEdgeClass: GeomAbs_Shape): void;
  UnsetFaceBoundaryUpperContinuity(): void;
  DimensionAspect(): Handle_Prs3d_DimensionAspect;
  SetDimensionAspect(theAspect: Handle_Prs3d_DimensionAspect): void;
  HasOwnDimensionAspect(): Standard_Boolean;
  SetDimLengthModelUnits(theUnits: XCAFDoc_PartId): void;
  SetDimAngleModelUnits(theUnits: XCAFDoc_PartId): void;
  DimLengthModelUnits(): XCAFDoc_PartId;
  DimAngleModelUnits(): XCAFDoc_PartId;
  HasOwnDimLengthModelUnits(): Standard_Boolean;
  UnsetOwnDimLengthModelUnits(): void;
  HasOwnDimAngleModelUnits(): Standard_Boolean;
  UnsetOwnDimAngleModelUnits(): void;
  SetDimLengthDisplayUnits(theUnits: XCAFDoc_PartId): void;
  SetDimAngleDisplayUnits(theUnits: XCAFDoc_PartId): void;
  DimLengthDisplayUnits(): XCAFDoc_PartId;
  DimAngleDisplayUnits(): XCAFDoc_PartId;
  HasOwnDimLengthDisplayUnits(): Standard_Boolean;
  UnsetOwnDimLengthDisplayUnits(): void;
  HasOwnDimAngleDisplayUnits(): Standard_Boolean;
  UnsetOwnDimAngleDisplayUnits(): void;
  Link_1(): Handle_Prs3d_Drawer;
  HasLink(): Standard_Boolean;
  Link_2(theDrawer: Handle_Prs3d_Drawer): void;
  SetLink(theDrawer: Handle_Prs3d_Drawer): void;
  ClearLocalAttributes(): void;
  SetShaderProgram(theProgram: Handle_Graphic3d_ShaderProgram, theAspect: Graphic3d_GroupAspect, theToOverrideDefaults: Standard_Boolean): Standard_Boolean;
  SetShadingModel(theModel: V3d_TypeOfShadingModel, theToOverrideDefaults: Standard_Boolean): Standard_Boolean;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  SetHLRAngle_1(theAngle: Standard_Real): void;
  HLRAngle(): Standard_Real;
  SetHLRAngle_2(): void;
  HasOwnHLRDeviationAngle(): Standard_Boolean;
  PreviousHLRDeviationAngle(): Standard_Real;
  delete(): void;
}

export declare class Handle_Prs3d_Drawer {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: Prs3d_Drawer): void;
  get(): Prs3d_Drawer;
  delete(): void;
}

  export declare class Handle_Prs3d_Drawer_1 extends Handle_Prs3d_Drawer {
    constructor();
  }

  export declare class Handle_Prs3d_Drawer_2 extends Handle_Prs3d_Drawer {
    constructor(thePtr: Prs3d_Drawer);
  }

  export declare class Handle_Prs3d_Drawer_3 extends Handle_Prs3d_Drawer {
    constructor(theHandle: Handle_Prs3d_Drawer);
  }

  export declare class Handle_Prs3d_Drawer_4 extends Handle_Prs3d_Drawer {
    constructor(theHandle: Handle_Prs3d_Drawer);
  }

export declare class RWGltf_CafReader extends RWMesh_CafReader {
  constructor()
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  ToParallel(): Standard_Boolean;
  SetParallel(theToParallel: Standard_Boolean): void;
  ToSkipEmptyNodes(): Standard_Boolean;
  SetSkipEmptyNodes(theToSkip: Standard_Boolean): void;
  ToLoadAllScenes(): Standard_Boolean;
  SetLoadAllScenes(theToLoadAll: Standard_Boolean): void;
  ToUseMeshNameAsFallback(): Standard_Boolean;
  SetMeshNameAsFallback(theToFallback: Standard_Boolean): void;
  IsDoublePrecision(): Standard_Boolean;
  SetDoublePrecision(theIsDouble: Standard_Boolean): void;
  ToSkipLateDataLoading(): Standard_Boolean;
  SetToSkipLateDataLoading(theToSkip: Standard_Boolean): void;
  ToKeepLateData(): Standard_Boolean;
  SetToKeepLateData(theToKeep: Standard_Boolean): void;
  ToPrintDebugMessages(): Standard_Boolean;
  SetToPrintDebugMessages(theToPrint: Standard_Boolean): void;
  delete(): void;
}

export declare class BRepTools {
  constructor();
  static UVBounds_1(F: TopoDS_Face, UMin: Standard_Real, UMax: Standard_Real, VMin: Standard_Real, VMax: Standard_Real): void;
  static UVBounds_2(F: TopoDS_Face, W: TopoDS_Wire, UMin: Standard_Real, UMax: Standard_Real, VMin: Standard_Real, VMax: Standard_Real): void;
  static UVBounds_3(F: TopoDS_Face, E: TopoDS_Edge, UMin: Standard_Real, UMax: Standard_Real, VMin: Standard_Real, VMax: Standard_Real): void;
  static AddUVBounds_1(F: TopoDS_Face, B: Bnd_Box2d): void;
  static AddUVBounds_2(F: TopoDS_Face, W: TopoDS_Wire, B: Bnd_Box2d): void;
  static AddUVBounds_3(F: TopoDS_Face, E: TopoDS_Edge, B: Bnd_Box2d): void;
  static Update_1(V: TopoDS_Vertex): void;
  static Update_2(E: TopoDS_Edge): void;
  static Update_3(W: TopoDS_Wire): void;
  static Update_4(F: TopoDS_Face): void;
  static Update_5(S: TopoDS_Shell): void;
  static Update_6(S: TopoDS_Solid): void;
  static Update_7(C: TopoDS_CompSolid): void;
  static Update_8(C: TopoDS_Compound): void;
  static Update_9(S: TopoDS_Shape): void;
  static UpdateFaceUVPoints(theF: TopoDS_Face): void;
  static Clean(theShape: TopoDS_Shape, theForce: Standard_Boolean): void;
  static CleanGeometry(theShape: TopoDS_Shape): void;
  static RemoveUnusedPCurves(S: TopoDS_Shape): void;
  static Triangulation(theShape: TopoDS_Shape, theLinDefl: Standard_Real, theToCheckFreeEdges: Standard_Boolean): Standard_Boolean;
  static LoadTriangulation(theShape: TopoDS_Shape, theTriangulationIdx: Graphic3d_ZLayerId, theToSetAsActive: Standard_Boolean, theFileSystem: any): Standard_Boolean;
  static UnloadTriangulation(theShape: TopoDS_Shape, theTriangulationIdx: Graphic3d_ZLayerId): Standard_Boolean;
  static ActivateTriangulation(theShape: TopoDS_Shape, theTriangulationIdx: Graphic3d_ZLayerId, theToActivateStrictly: Standard_Boolean): Standard_Boolean;
  static LoadAllTriangulations(theShape: TopoDS_Shape, theFileSystem: any): Standard_Boolean;
  static UnloadAllTriangulations(theShape: TopoDS_Shape): Standard_Boolean;
  static Compare_1(V1: TopoDS_Vertex, V2: TopoDS_Vertex): Standard_Boolean;
  static Compare_2(E1: TopoDS_Edge, E2: TopoDS_Edge): Standard_Boolean;
  static OuterWire(F: TopoDS_Face): TopoDS_Wire;
  static Map3DEdges(S: TopoDS_Shape, M: TopTools_IndexedMapOfShape): void;
  static IsReallyClosed(E: TopoDS_Edge, F: TopoDS_Face): Standard_Boolean;
  static DetectClosedness(theFace: TopoDS_Face, theUclosed: Standard_Boolean, theVclosed: Standard_Boolean): void;
  static Dump(Sh: TopoDS_Shape, S: Standard_OStream): void;
  static Write_1(theShape: TopoDS_Shape, theStream: Standard_OStream, theProgress: Message_ProgressRange): void;
  static Write_2(theShape: TopoDS_Shape, theStream: Standard_OStream, theWithTriangles: Standard_Boolean, theWithNormals: Standard_Boolean, theVersion: TopTools_FormatVersion, theProgress: Message_ProgressRange): void;
  static Read_1(Sh: TopoDS_Shape, S: Standard_IStream, B: BRep_Builder, theProgress: Message_ProgressRange): void;
  static Write_3(theShape: TopoDS_Shape, theFile: Standard_CString, theProgress: Message_ProgressRange): Standard_Boolean;
  static Write_4(theShape: TopoDS_Shape, theFile: Standard_CString, theWithTriangles: Standard_Boolean, theWithNormals: Standard_Boolean, theVersion: TopTools_FormatVersion, theProgress: Message_ProgressRange): Standard_Boolean;
  static Read_2(Sh: TopoDS_Shape, File: Standard_CString, B: BRep_Builder, theProgress: Message_ProgressRange): Standard_Boolean;
  static EvalAndUpdateTol(theE: TopoDS_Edge, theC3d: Handle_Geom_Curve, theC2d: Handle_Geom2d_Curve, theS: Handle_Geom_Surface, theF: Standard_Real, theL: Standard_Real): Standard_Real;
  static OriEdgeInFace(theEdge: TopoDS_Edge, theFace: TopoDS_Face): TopAbs_Orientation;
  static RemoveInternals(theS: TopoDS_Shape, theForce: Standard_Boolean): void;
  static CheckLocations(theS: TopoDS_Shape, theProblemShapes: TopTools_ListOfShape): void;
  delete(): void;
}

export declare class TopLoc_Location {
  IsIdentity(): Standard_Boolean;
  Identity(): void;
  FirstDatum(): Handle_TopLoc_Datum3D;
  FirstPower(): Graphic3d_ZLayerId;
  NextLocation(): TopLoc_Location;
  Transformation(): gp_Trsf;
  Inverted(): TopLoc_Location;
  Multiplied(Other: TopLoc_Location): TopLoc_Location;
  Divided(Other: TopLoc_Location): TopLoc_Location;
  Predivided(Other: TopLoc_Location): TopLoc_Location;
  Powered(pwr: Graphic3d_ZLayerId): TopLoc_Location;
  HashCode(theUpperBound: Graphic3d_ZLayerId): Graphic3d_ZLayerId;
  IsEqual(Other: TopLoc_Location): Standard_Boolean;
  IsDifferent(Other: TopLoc_Location): Standard_Boolean;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  ShallowDump(S: Standard_OStream): void;
  Clear(): void;
  static ScalePrec(): Standard_Real;
  delete(): void;
}

  export declare class TopLoc_Location_1 extends TopLoc_Location {
    constructor();
  }

  export declare class TopLoc_Location_2 extends TopLoc_Location {
    constructor(T: gp_Trsf);
  }

  export declare class TopLoc_Location_3 extends TopLoc_Location {
    constructor(D: Handle_TopLoc_Datum3D);
  }

export declare class SelectMgr_SelectableObject extends PrsMgr_PresentableObject {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  ComputeSelection(theSelection: Handle_SelectMgr_Selection, theMode: Graphic3d_ZLayerId): void;
  AcceptShapeDecomposition(): Standard_Boolean;
  RecomputePrimitives_1(): void;
  RecomputePrimitives_2(theMode: Graphic3d_ZLayerId): void;
  AddSelection(aSelection: Handle_SelectMgr_Selection, aMode: Graphic3d_ZLayerId): void;
  ClearSelections(update: Standard_Boolean): void;
  Selection(theMode: Graphic3d_ZLayerId): Handle_SelectMgr_Selection;
  HasSelection(theMode: Graphic3d_ZLayerId): Standard_Boolean;
  Selections(): SelectMgr_SequenceOfSelection;
  ResetTransformation(): void;
  UpdateTransformation(): void;
  UpdateTransformations(aSelection: Handle_SelectMgr_Selection): void;
  HilightSelected(thePrsMgr: Handle_PrsMgr_PresentationManager, theSeq: SelectMgr_SequenceOfOwner): void;
  ClearSelected(): void;
  ClearDynamicHighlight(theMgr: Handle_PrsMgr_PresentationManager): void;
  HilightOwnerWithColor(thePM: Handle_PrsMgr_PresentationManager, theStyle: Handle_Prs3d_Drawer, theOwner: Handle_SelectMgr_EntityOwner): void;
  IsAutoHilight(): Standard_Boolean;
  SetAutoHilight(theAutoHilight: Standard_Boolean): void;
  GetHilightPresentation(thePrsMgr: Handle_PrsMgr_PresentationManager): any;
  GetSelectPresentation(thePrsMgr: Handle_PrsMgr_PresentationManager): any;
  ErasePresentations(theToRemove: Standard_Boolean): void;
  SetZLayer(theLayerId: Graphic3d_ZLayerId): void;
  UpdateSelection(theMode: Graphic3d_ZLayerId): void;
  SetAssemblyOwner(theOwner: Handle_SelectMgr_EntityOwner, theMode: Graphic3d_ZLayerId): void;
  BndBoxOfSelected(theOwners: any): Bnd_Box;
  GlobalSelectionMode(): Graphic3d_ZLayerId;
  GlobalSelOwner(): Handle_SelectMgr_EntityOwner;
  GetAssemblyOwner(): Handle_SelectMgr_EntityOwner;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare class TDF_Attribute extends Standard_Transient {
  ID(): Standard_GUID;
  SetID_1(a0: Standard_GUID): void;
  SetID_2(): void;
  Label(): TDF_Label;
  Transaction(): Graphic3d_ZLayerId;
  UntilTransaction(): Graphic3d_ZLayerId;
  IsValid(): Standard_Boolean;
  IsNew(): Standard_Boolean;
  IsForgotten(): Standard_Boolean;
  IsAttribute(anID: Standard_GUID): Standard_Boolean;
  FindAttribute_1(anID: Standard_GUID, anAttribute: Handle_TDF_Attribute): Standard_Boolean;
  AddAttribute(other: Handle_TDF_Attribute): void;
  ForgetAttribute(aguid: Standard_GUID): Standard_Boolean;
  ForgetAllAttributes(clearChildren: Standard_Boolean): void;
  AfterAddition(): void;
  BeforeRemoval(): void;
  BeforeForget(): void;
  AfterResume(): void;
  AfterRetrieval(forceIt: Standard_Boolean): Standard_Boolean;
  BeforeUndo(anAttDelta: Handle_TDF_AttributeDelta, forceIt: Standard_Boolean): Standard_Boolean;
  AfterUndo(anAttDelta: Handle_TDF_AttributeDelta, forceIt: Standard_Boolean): Standard_Boolean;
  BeforeCommitTransaction(): void;
  Backup_1(): void;
  IsBackuped(): Standard_Boolean;
  BackupCopy(): Handle_TDF_Attribute;
  Restore(anAttribute: Handle_TDF_Attribute): void;
  DeltaOnAddition(): Handle_TDF_DeltaOnAddition;
  DeltaOnForget(): Handle_TDF_DeltaOnForget;
  DeltaOnResume(): Handle_TDF_DeltaOnResume;
  DeltaOnModification_1(anOldAttribute: Handle_TDF_Attribute): Handle_TDF_DeltaOnModification;
  DeltaOnModification_2(aDelta: Handle_TDF_DeltaOnModification): void;
  DeltaOnRemoval(): Handle_TDF_DeltaOnRemoval;
  NewEmpty(): Handle_TDF_Attribute;
  Paste(intoAttribute: Handle_TDF_Attribute, aRelocationTable: Handle_TDF_RelocationTable): void;
  References(aDataSet: Handle_TDF_DataSet): void;
  ExtendedDump(anOS: Standard_OStream, aFilter: TDF_IDFilter, aMap: TDF_AttributeIndexedMap): void;
  Forget(aTransaction: Graphic3d_ZLayerId): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  delete(): void;
}

export declare class TDF_Label {
  constructor()
  Nullify(): void;
  Data(): Handle_TDF_Data;
  Tag(): Graphic3d_ZLayerId;
  Father(): TDF_Label;
  IsNull(): Standard_Boolean;
  Imported(aStatus: Standard_Boolean): void;
  IsImported(): Standard_Boolean;
  IsEqual(aLabel: TDF_Label): Standard_Boolean;
  IsDifferent(aLabel: TDF_Label): Standard_Boolean;
  IsRoot(): Standard_Boolean;
  IsAttribute(anID: Standard_GUID): Standard_Boolean;
  AddAttribute(anAttribute: Handle_TDF_Attribute, append: Standard_Boolean): void;
  ForgetAttribute_1(anAttribute: Handle_TDF_Attribute): void;
  ForgetAttribute_2(aguid: Standard_GUID): Standard_Boolean;
  ForgetAllAttributes(clearChildren: Standard_Boolean): void;
  ResumeAttribute(anAttribute: Handle_TDF_Attribute): void;
  FindAttribute_1(anID: Standard_GUID, anAttribute: Handle_TDF_Attribute): Standard_Boolean;
  FindAttribute_3(anID: Standard_GUID, aTransaction: Graphic3d_ZLayerId, anAttribute: Handle_TDF_Attribute): Standard_Boolean;
  MayBeModified(): Standard_Boolean;
  AttributesModified(): Standard_Boolean;
  HasAttribute(): Standard_Boolean;
  NbAttributes(): Graphic3d_ZLayerId;
  Depth(): Graphic3d_ZLayerId;
  IsDescendant(aLabel: TDF_Label): Standard_Boolean;
  Root(): TDF_Label;
  HasChild(): Standard_Boolean;
  NbChildren(): Graphic3d_ZLayerId;
  FindChild(aTag: Graphic3d_ZLayerId, create: Standard_Boolean): TDF_Label;
  NewChild(): TDF_Label;
  Transaction(): Graphic3d_ZLayerId;
  HasLowerNode(otherLabel: TDF_Label): Standard_Boolean;
  HasGreaterNode(otherLabel: TDF_Label): Standard_Boolean;
  ExtendedDump(anOS: Standard_OStream, aFilter: TDF_IDFilter, aMap: TDF_AttributeIndexedMap): void;
  EntryDump(anOS: Standard_OStream): void;
  delete(): void;
}

export declare class TDF_ChildIterator {
  Initialize(aLabel: TDF_Label, allLevels: Standard_Boolean): void;
  More(): Standard_Boolean;
  Next(): void;
  NextBrother(): void;
  Value(): TDF_Label;
  delete(): void;
}

  export declare class TDF_ChildIterator_1 extends TDF_ChildIterator {
    constructor();
  }

  export declare class TDF_ChildIterator_2 extends TDF_ChildIterator {
    constructor(aLabel: TDF_Label, allLevels: Standard_Boolean);
  }

export declare class TDF_Tool {
  constructor();
  static NbLabels(aLabel: TDF_Label): Graphic3d_ZLayerId;
  static NbAttributes_1(aLabel: TDF_Label): Graphic3d_ZLayerId;
  static NbAttributes_2(aLabel: TDF_Label, aFilter: TDF_IDFilter): Graphic3d_ZLayerId;
  static IsSelfContained_1(aLabel: TDF_Label): Standard_Boolean;
  static IsSelfContained_2(aLabel: TDF_Label, aFilter: TDF_IDFilter): Standard_Boolean;
  static OutReferers_1(theLabel: TDF_Label, theAtts: TDF_AttributeMap): void;
  static OutReferers_2(aLabel: TDF_Label, aFilterForReferers: TDF_IDFilter, aFilterForReferences: TDF_IDFilter, atts: TDF_AttributeMap): void;
  static OutReferences_1(aLabel: TDF_Label, atts: TDF_AttributeMap): void;
  static OutReferences_2(aLabel: TDF_Label, aFilterForReferers: TDF_IDFilter, aFilterForReferences: TDF_IDFilter, atts: TDF_AttributeMap): void;
  static RelocateLabel(aSourceLabel: TDF_Label, fromRoot: TDF_Label, toRoot: TDF_Label, aTargetLabel: TDF_Label, create: Standard_Boolean): void;
  static Entry(aLabel: TDF_Label, anEntry: XCAFDoc_PartId): void;
  static TagList_1(aLabel: TDF_Label, aTagList: TColStd_ListOfInteger): void;
  static TagList_2(anEntry: XCAFDoc_PartId, aTagList: TColStd_ListOfInteger): void;
  static Label_1(aDF: Handle_TDF_Data, anEntry: XCAFDoc_PartId, aLabel: TDF_Label, create: Standard_Boolean): void;
  static Label_2(aDF: Handle_TDF_Data, anEntry: Standard_CString, aLabel: TDF_Label, create: Standard_Boolean): void;
  static Label_3(aDF: Handle_TDF_Data, aTagList: TColStd_ListOfInteger, aLabel: TDF_Label, create: Standard_Boolean): void;
  static CountLabels(aLabelList: TDF_LabelList, aLabelMap: TDF_LabelIntegerMap): void;
  static DeductLabels(aLabelList: TDF_LabelList, aLabelMap: TDF_LabelIntegerMap): void;
  static DeepDump_1(anOS: Standard_OStream, aDF: Handle_TDF_Data): void;
  static ExtendedDeepDump_1(anOS: Standard_OStream, aDF: Handle_TDF_Data, aFilter: TDF_IDFilter): void;
  static DeepDump_2(anOS: Standard_OStream, aLabel: TDF_Label): void;
  static ExtendedDeepDump_2(anOS: Standard_OStream, aLabel: TDF_Label, aFilter: TDF_IDFilter): void;
  delete(): void;
}

export declare class TDF_LabelSequence extends NCollection_BaseSequence {
  begin(): any;
  end(): any;
  cbegin(): any;
  cend(): any;
  Size(): Standard_Integer;
  Length(): Standard_Integer;
  Lower(): Standard_Integer;
  Upper(): Standard_Integer;
  IsEmpty(): Standard_Boolean;
  Reverse(): void;
  Exchange(I: Standard_Integer, J: Standard_Integer): void;
  static delNode(theNode: NCollection_SeqNode, theAl: Handle_NCollection_BaseAllocator): void;
  Clear(theAllocator: Handle_NCollection_BaseAllocator): void;
  Assign(theOther: TDF_LabelSequence): TDF_LabelSequence;
  Remove_2(theIndex: Standard_Integer): void;
  Remove_3(theFromIndex: Standard_Integer, theToIndex: Standard_Integer): void;
  Append_1(theItem: TDF_Label): void;
  Append_2(theSeq: TDF_LabelSequence): void;
  Prepend_1(theItem: TDF_Label): void;
  Prepend_2(theSeq: TDF_LabelSequence): void;
  InsertBefore_1(theIndex: Standard_Integer, theItem: TDF_Label): void;
  InsertBefore_2(theIndex: Standard_Integer, theSeq: TDF_LabelSequence): void;
  InsertAfter_2(theIndex: Standard_Integer, theSeq: TDF_LabelSequence): void;
  InsertAfter_3(theIndex: Standard_Integer, theItem: TDF_Label): void;
  Split(theIndex: Standard_Integer, theSeq: TDF_LabelSequence): void;
  First(): TDF_Label;
  ChangeFirst(): TDF_Label;
  Last(): TDF_Label;
  ChangeLast(): TDF_Label;
  Value(theIndex: Standard_Integer): TDF_Label;
  ChangeValue(theIndex: Standard_Integer): TDF_Label;
  SetValue(theIndex: Standard_Integer, theItem: TDF_Label): void;
  delete(): void;
}

  export declare class TDF_LabelSequence_1 extends TDF_LabelSequence {
    constructor();
  }

  export declare class TDF_LabelSequence_2 extends TDF_LabelSequence {
    constructor(theAllocator: Handle_NCollection_BaseAllocator);
  }

  export declare class TDF_LabelSequence_3 extends TDF_LabelSequence {
    constructor(theOther: TDF_LabelSequence);
  }

export declare class gp_Trsf {
  SetMirror_1(theP: gp_Pnt): void;
  SetMirror_2(theA1: gp_Ax1): void;
  SetMirror_3(theA2: gp_Ax2): void;
  SetRotation_1(theA1: gp_Ax1, theAng: Standard_Real): void;
  SetRotation_2(theR: gp_Quaternion): void;
  SetRotationPart(theR: gp_Quaternion): void;
  SetScale(theP: gp_Pnt, theS: Standard_Real): void;
  SetDisplacement(theFromSystem1: gp_Ax3, theToSystem2: gp_Ax3): void;
  SetTransformation_1(theFromSystem1: gp_Ax3, theToSystem2: gp_Ax3): void;
  SetTransformation_2(theToSystem: gp_Ax3): void;
  SetTransformation_3(R: gp_Quaternion, theT: gp_Vec): void;
  SetTranslation_1(theV: gp_Vec): void;
  SetTranslation_2(theP1: gp_Pnt, theP2: gp_Pnt): void;
  SetTranslationPart(theV: gp_Vec): void;
  SetScaleFactor(theS: Standard_Real): void;
  SetForm(theP: gp_TrsfForm): void;
  SetValues(a11: Standard_Real, a12: Standard_Real, a13: Standard_Real, a14: Standard_Real, a21: Standard_Real, a22: Standard_Real, a23: Standard_Real, a24: Standard_Real, a31: Standard_Real, a32: Standard_Real, a33: Standard_Real, a34: Standard_Real): void;
  IsNegative(): Standard_Boolean;
  Form(): gp_TrsfForm;
  ScaleFactor(): Standard_Real;
  TranslationPart(): gp_XYZ;
  GetRotation_1(theAxis: gp_XYZ, theAngle: Standard_Real): Standard_Boolean;
  GetRotation_2(): gp_Quaternion;
  VectorialPart(): gp_Mat;
  HVectorialPart(): gp_Mat;
  Value(theRow: Graphic3d_ZLayerId, theCol: Graphic3d_ZLayerId): Standard_Real;
  Invert(): void;
  Inverted(): gp_Trsf;
  Multiplied(theT: gp_Trsf): gp_Trsf;
  Multiply(theT: gp_Trsf): void;
  PreMultiply(theT: gp_Trsf): void;
  Power(theN: Graphic3d_ZLayerId): void;
  Powered(theN: Graphic3d_ZLayerId): gp_Trsf;
  Transforms_1(theX: Standard_Real, theY: Standard_Real, theZ: Standard_Real): void;
  Transforms_2(theCoord: gp_XYZ): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  InitFromJson(theSStream: Standard_SStream, theStreamPos: Graphic3d_ZLayerId): Standard_Boolean;
  delete(): void;
}

  export declare class gp_Trsf_1 extends gp_Trsf {
    constructor();
  }

  export declare class gp_Trsf_2 extends gp_Trsf {
    constructor(theT: gp_Trsf2d);
  }

export declare class gp_Pnt {
  SetCoord_1(theIndex: Graphic3d_ZLayerId, theXi: Standard_Real): void;
  SetCoord_2(theXp: Standard_Real, theYp: Standard_Real, theZp: Standard_Real): void;
  SetX(theX: Standard_Real): void;
  SetY(theY: Standard_Real): void;
  SetZ(theZ: Standard_Real): void;
  SetXYZ(theCoord: gp_XYZ): void;
  Coord_1(theIndex: Graphic3d_ZLayerId): Standard_Real;
  Coord_2(theXp: Standard_Real, theYp: Standard_Real, theZp: Standard_Real): void;
  X(): Standard_Real;
  Y(): Standard_Real;
  Z(): Standard_Real;
  XYZ(): gp_XYZ;
  Coord_3(): gp_XYZ;
  ChangeCoord(): gp_XYZ;
  BaryCenter(theAlpha: Standard_Real, theP: gp_Pnt, theBeta: Standard_Real): void;
  IsEqual(theOther: gp_Pnt, theLinearTolerance: Standard_Real): Standard_Boolean;
  Distance(theOther: gp_Pnt): Standard_Real;
  SquareDistance(theOther: gp_Pnt): Standard_Real;
  Mirror_1(theP: gp_Pnt): void;
  Mirrored_1(theP: gp_Pnt): gp_Pnt;
  Mirror_2(theA1: gp_Ax1): void;
  Mirrored_2(theA1: gp_Ax1): gp_Pnt;
  Mirror_3(theA2: gp_Ax2): void;
  Mirrored_3(theA2: gp_Ax2): gp_Pnt;
  Rotate(theA1: gp_Ax1, theAng: Standard_Real): void;
  Rotated(theA1: gp_Ax1, theAng: Standard_Real): gp_Pnt;
  Scale(theP: gp_Pnt, theS: Standard_Real): void;
  Scaled(theP: gp_Pnt, theS: Standard_Real): gp_Pnt;
  Transform(theT: gp_Trsf): void;
  Transformed(theT: gp_Trsf): gp_Pnt;
  Translate_1(theV: gp_Vec): void;
  Translated_1(theV: gp_Vec): gp_Pnt;
  Translate_2(theP1: gp_Pnt, theP2: gp_Pnt): void;
  Translated_2(theP1: gp_Pnt, theP2: gp_Pnt): gp_Pnt;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  InitFromJson(theSStream: Standard_SStream, theStreamPos: Graphic3d_ZLayerId): Standard_Boolean;
  delete(): void;
}

  export declare class gp_Pnt_1 extends gp_Pnt {
    constructor();
  }

  export declare class gp_Pnt_2 extends gp_Pnt {
    constructor(theCoord: gp_XYZ);
  }

  export declare class gp_Pnt_3 extends gp_Pnt {
    constructor(theXp: Standard_Real, theYp: Standard_Real, theZp: Standard_Real);
  }

export declare class gp_Dir {
  SetCoord_1(theIndex: Graphic3d_ZLayerId, theXi: Standard_Real): void;
  SetCoord_2(theXv: Standard_Real, theYv: Standard_Real, theZv: Standard_Real): void;
  SetX(theX: Standard_Real): void;
  SetY(theY: Standard_Real): void;
  SetZ(theZ: Standard_Real): void;
  SetXYZ(theCoord: gp_XYZ): void;
  Coord_1(theIndex: Graphic3d_ZLayerId): Standard_Real;
  Coord_2(theXv: Standard_Real, theYv: Standard_Real, theZv: Standard_Real): void;
  X(): Standard_Real;
  Y(): Standard_Real;
  Z(): Standard_Real;
  XYZ(): gp_XYZ;
  IsEqual(theOther: gp_Dir, theAngularTolerance: Standard_Real): Standard_Boolean;
  IsNormal(theOther: gp_Dir, theAngularTolerance: Standard_Real): Standard_Boolean;
  IsOpposite(theOther: gp_Dir, theAngularTolerance: Standard_Real): Standard_Boolean;
  IsParallel(theOther: gp_Dir, theAngularTolerance: Standard_Real): Standard_Boolean;
  Angle(theOther: gp_Dir): Standard_Real;
  AngleWithRef(theOther: gp_Dir, theVRef: gp_Dir): Standard_Real;
  Cross(theRight: gp_Dir): void;
  Crossed(theRight: gp_Dir): gp_Dir;
  CrossCross(theV1: gp_Dir, theV2: gp_Dir): void;
  CrossCrossed(theV1: gp_Dir, theV2: gp_Dir): gp_Dir;
  Dot(theOther: gp_Dir): Standard_Real;
  DotCross(theV1: gp_Dir, theV2: gp_Dir): Standard_Real;
  Reverse(): void;
  Reversed(): gp_Dir;
  Mirror_1(theV: gp_Dir): void;
  Mirrored_1(theV: gp_Dir): gp_Dir;
  Mirror_2(theA1: gp_Ax1): void;
  Mirrored_2(theA1: gp_Ax1): gp_Dir;
  Mirror_3(theA2: gp_Ax2): void;
  Mirrored_3(theA2: gp_Ax2): gp_Dir;
  Rotate(theA1: gp_Ax1, theAng: Standard_Real): void;
  Rotated(theA1: gp_Ax1, theAng: Standard_Real): gp_Dir;
  Transform(theT: gp_Trsf): void;
  Transformed(theT: gp_Trsf): gp_Dir;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  InitFromJson(theSStream: Standard_SStream, theStreamPos: Graphic3d_ZLayerId): Standard_Boolean;
  delete(): void;
}

  export declare class gp_Dir_1 extends gp_Dir {
    constructor();
  }

  export declare class gp_Dir_2 extends gp_Dir {
    constructor(theV: gp_Vec);
  }

  export declare class gp_Dir_3 extends gp_Dir {
    constructor(theCoord: gp_XYZ);
  }

  export declare class gp_Dir_4 extends gp_Dir {
    constructor(theXv: Standard_Real, theYv: Standard_Real, theZv: Standard_Real);
  }

export declare class gp_Pln {
  Coefficients(theA: Standard_Real, theB: Standard_Real, theC: Standard_Real, theD: Standard_Real): void;
  SetAxis(theA1: gp_Ax1): void;
  SetLocation(theLoc: gp_Pnt): void;
  SetPosition(theA3: gp_Ax3): void;
  UReverse(): void;
  VReverse(): void;
  Direct(): Standard_Boolean;
  Axis(): gp_Ax1;
  Location(): gp_Pnt;
  Position(): gp_Ax3;
  Distance_1(theP: gp_Pnt): Standard_Real;
  Distance_2(theL: gp_Lin): Standard_Real;
  Distance_3(theOther: gp_Pln): Standard_Real;
  SquareDistance_1(theP: gp_Pnt): Standard_Real;
  SquareDistance_2(theL: gp_Lin): Standard_Real;
  SquareDistance_3(theOther: gp_Pln): Standard_Real;
  XAxis(): gp_Ax1;
  YAxis(): gp_Ax1;
  Contains_1(theP: gp_Pnt, theLinearTolerance: Standard_Real): Standard_Boolean;
  Contains_2(theL: gp_Lin, theLinearTolerance: Standard_Real, theAngularTolerance: Standard_Real): Standard_Boolean;
  Mirror_1(theP: gp_Pnt): void;
  Mirrored_1(theP: gp_Pnt): gp_Pln;
  Mirror_2(theA1: gp_Ax1): void;
  Mirrored_2(theA1: gp_Ax1): gp_Pln;
  Mirror_3(theA2: gp_Ax2): void;
  Mirrored_3(theA2: gp_Ax2): gp_Pln;
  Rotate(theA1: gp_Ax1, theAng: Standard_Real): void;
  Rotated(theA1: gp_Ax1, theAng: Standard_Real): gp_Pln;
  Scale(theP: gp_Pnt, theS: Standard_Real): void;
  Scaled(theP: gp_Pnt, theS: Standard_Real): gp_Pln;
  Transform(theT: gp_Trsf): void;
  Transformed(theT: gp_Trsf): gp_Pln;
  Translate_1(theV: gp_Vec): void;
  Translated_1(theV: gp_Vec): gp_Pln;
  Translate_2(theP1: gp_Pnt, theP2: gp_Pnt): void;
  Translated_2(theP1: gp_Pnt, theP2: gp_Pnt): gp_Pln;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

  export declare class gp_Pln_1 extends gp_Pln {
    constructor();
  }

  export declare class gp_Pln_2 extends gp_Pln {
    constructor(theA3: gp_Ax3);
  }

  export declare class gp_Pln_3 extends gp_Pln {
    constructor(theP: gp_Pnt, theV: gp_Dir);
  }

  export declare class gp_Pln_4 extends gp_Pln {
    constructor(theA: Standard_Real, theB: Standard_Real, theC: Standard_Real, theD: Standard_Real);
  }

export declare class PrsMgr_PresentableObject extends Standard_Transient {
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  Presentations(): PrsMgr_Presentations;
  ZLayer(): Graphic3d_ZLayerId;
  SetZLayer(theLayerId: Graphic3d_ZLayerId): void;
  IsMutable(): Standard_Boolean;
  SetMutable(theIsMutable: Standard_Boolean): void;
  HasDisplayMode(): Standard_Boolean;
  DisplayMode(): Graphic3d_ZLayerId;
  SetDisplayMode(theMode: Graphic3d_ZLayerId): void;
  UnsetDisplayMode(): void;
  HasHilightMode(): Standard_Boolean;
  HilightMode(): Graphic3d_ZLayerId;
  SetHilightMode(theMode: Graphic3d_ZLayerId): void;
  UnsetHilightMode(): void;
  AcceptDisplayMode(theMode: Graphic3d_ZLayerId): Standard_Boolean;
  DefaultDisplayMode(): Graphic3d_ZLayerId;
  ToBeUpdated_1(theToIncludeHidden: Standard_Boolean): Standard_Boolean;
  SetToUpdate_1(theMode: Graphic3d_ZLayerId): void;
  SetToUpdate_2(): void;
  IsInfinite(): Standard_Boolean;
  SetInfiniteState(theFlag: Standard_Boolean): void;
  TypeOfPresentation3d(): PrsMgr_TypeOfPresentation3d;
  SetTypeOfPresentation(theType: PrsMgr_TypeOfPresentation3d): void;
  DisplayStatus(): AIS_DisplayStatus;
  Attributes(): Handle_Prs3d_Drawer;
  SetAttributes(theDrawer: Handle_Prs3d_Drawer): void;
  HilightAttributes(): Handle_Prs3d_Drawer;
  SetHilightAttributes(theDrawer: Handle_Prs3d_Drawer): void;
  DynamicHilightAttributes(): Handle_Prs3d_Drawer;
  SetDynamicHilightAttributes(theDrawer: Handle_Prs3d_Drawer): void;
  UnsetHilightAttributes(): void;
  SynchronizeAspects(): void;
  TransformPersistence(): Handle_Graphic3d_TransformPers;
  SetTransformPersistence(theTrsfPers: Handle_Graphic3d_TransformPers): void;
  LocalTransformationGeom(): Handle_TopLoc_Datum3D;
  SetLocalTransformation_1(theTrsf: gp_Trsf): void;
  SetLocalTransformation_2(theTrsf: Handle_TopLoc_Datum3D): void;
  HasTransformation(): Standard_Boolean;
  TransformationGeom(): Handle_TopLoc_Datum3D;
  LocalTransformation(): gp_Trsf;
  Transformation(): gp_Trsf;
  InversedTransformation(): gp_GTrsf;
  CombinedParentTransformation(): Handle_TopLoc_Datum3D;
  ResetTransformation(): void;
  UpdateTransformation(): void;
  ClipPlanes(): Handle_Graphic3d_SequenceOfHClipPlane;
  SetClipPlanes(thePlanes: Handle_Graphic3d_SequenceOfHClipPlane): void;
  AddClipPlane(thePlane: Handle_Graphic3d_ClipPlane): void;
  RemoveClipPlane(thePlane: Handle_Graphic3d_ClipPlane): void;
  Parent(): PrsMgr_PresentableObject;
  Children(): PrsMgr_ListOfPresentableObjects;
  AddChild(theObject: Handle_PrsMgr_PresentableObject): void;
  AddChildWithCurrentTransformation(theObject: Handle_PrsMgr_PresentableObject): void;
  RemoveChild(theObject: Handle_PrsMgr_PresentableObject): void;
  RemoveChildWithRestoreTransformation(theObject: Handle_PrsMgr_PresentableObject): void;
  HasOwnPresentations(): Standard_Boolean;
  BoundingBox(theBndBox: Bnd_Box): void;
  SetIsoOnTriangulation(theIsEnabled: Standard_Boolean): void;
  CurrentFacingModel(): Aspect_TypeOfFacingModel;
  SetCurrentFacingModel(theModel: Aspect_TypeOfFacingModel): void;
  HasColor(): Standard_Boolean;
  Color(theColor: Quantity_Color): void;
  SetColor(theColor: Quantity_Color): void;
  UnsetColor(): void;
  HasWidth(): Standard_Boolean;
  Width(): Standard_Real;
  SetWidth(theWidth: Standard_Real): void;
  UnsetWidth(): void;
  HasMaterial(): Standard_Boolean;
  Material(): Graphic3d_NameOfMaterial;
  SetMaterial(aName: Graphic3d_MaterialAspect): void;
  UnsetMaterial(): void;
  IsTransparent(): Standard_Boolean;
  Transparency(): Standard_Real;
  SetTransparency(aValue: Standard_Real): void;
  UnsetTransparency(): void;
  HasPolygonOffsets(): Standard_Boolean;
  PolygonOffsets(aMode: Graphic3d_ZLayerId, aFactor: Standard_ShortReal, aUnits: Standard_ShortReal): void;
  SetPolygonOffsets(aMode: Graphic3d_ZLayerId, aFactor: Standard_ShortReal, aUnits: Standard_ShortReal): void;
  UnsetAttributes(): void;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  ToBeUpdated_2(ListOfMode: TColStd_ListOfInteger): void;
  ToPropagateVisualState(): Standard_Boolean;
  SetPropagateVisualState(theFlag: Standard_Boolean): void;
  delete(): void;
}

export declare type PrsMgr_TypeOfPresentation3d = {
  PrsMgr_TOP_AllView: {};
  PrsMgr_TOP_ProjectorDependent: {};
}

export declare class NCollection_BaseSequence {
  IsEmpty(): Standard_Boolean;
  Length(): Graphic3d_ZLayerId;
  Allocator(): Handle_NCollection_BaseAllocator;
  delete(): void;
}

export declare class V3d_Viewer extends Standard_Transient {
  constructor(theDriver: Handle_Graphic3d_GraphicDriver)
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  IfMoreViews(): Standard_Boolean;
  CreateView(): Handle_V3d_View;
  SetViewOn_1(): void;
  SetViewOn_2(theView: Handle_V3d_View): void;
  SetViewOff_1(): void;
  SetViewOff_2(theView: Handle_V3d_View): void;
  Update(): void;
  Redraw(): void;
  RedrawImmediate(): void;
  Invalidate(): void;
  Remove(): void;
  Driver(): Handle_Graphic3d_GraphicDriver;
  StructureManager(): Handle_Graphic3d_StructureManager;
  DefaultRenderingParams(): Graphic3d_RenderingParams;
  SetDefaultRenderingParams(theParams: Graphic3d_RenderingParams): void;
  SetDefaultBackgroundColor(theColor: Quantity_Color): void;
  GetGradientBackground(): Aspect_GradientBackground;
  SetDefaultBgGradientColors(theColor1: Quantity_Color, theColor2: Quantity_Color, theFillStyle: Aspect_GradientFillMethod): void;
  DefaultViewSize(): Standard_Real;
  SetDefaultViewSize(theSize: Standard_Real): void;
  DefaultViewProj(): V3d_TypeOfOrientation;
  SetDefaultViewProj(theOrientation: V3d_TypeOfOrientation): void;
  DefaultVisualization(): V3d_TypeOfVisualization;
  SetDefaultVisualization(theType: V3d_TypeOfVisualization): void;
  DefaultShadingModel(): V3d_TypeOfShadingModel;
  SetDefaultShadingModel(theType: V3d_TypeOfShadingModel): void;
  DefaultTypeOfView(): V3d_TypeOfView;
  SetDefaultTypeOfView(theType: V3d_TypeOfView): void;
  DefaultBackgroundColor(): Quantity_Color;
  DefaultBgGradientColors(theColor1: Quantity_Color, theColor2: Quantity_Color): void;
  GetAllZLayers(theLayerSeq: TColStd_SequenceOfInteger): void;
  AddZLayer(theLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings): Standard_Boolean;
  InsertLayerBefore(theNewLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings, theLayerAfter: Graphic3d_ZLayerId): Standard_Boolean;
  InsertLayerAfter(theNewLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings, theLayerBefore: Graphic3d_ZLayerId): Standard_Boolean;
  RemoveZLayer(theLayerId: Graphic3d_ZLayerId): Standard_Boolean;
  ZLayerSettings(theLayerId: Graphic3d_ZLayerId): Graphic3d_ZLayerSettings;
  SetZLayerSettings(theLayerId: Graphic3d_ZLayerId, theSettings: Graphic3d_ZLayerSettings): void;
  ActiveViews(): V3d_ListOfView;
  ActiveViewIterator(): V3d_ListOfViewIterator;
  LastActiveView(): Standard_Boolean;
  DefinedViews(): V3d_ListOfView;
  DefinedViewIterator(): V3d_ListOfViewIterator;
  SetDefaultLights(): void;
  SetLightOn_1(theLight: any): void;
  SetLightOn_2(): void;
  SetLightOff_1(theLight: any): void;
  SetLightOff_2(): void;
  AddLight(theLight: any): void;
  DelLight(theLight: any): void;
  UpdateLights(): void;
  IsGlobalLight(TheLight: any): Standard_Boolean;
  ActiveLights(): V3d_ListOfLight;
  ActiveLightIterator(): V3d_ListOfLightIterator;
  DefinedLights(): V3d_ListOfLight;
  DefinedLightIterator(): V3d_ListOfLightIterator;
  Erase(): void;
  UnHighlight(): void;
  ComputedMode(): Standard_Boolean;
  SetComputedMode(theMode: Standard_Boolean): void;
  DefaultComputedMode(): Standard_Boolean;
  SetDefaultComputedMode(theMode: Standard_Boolean): void;
  PrivilegedPlane(): gp_Ax3;
  SetPrivilegedPlane(thePlane: gp_Ax3): void;
  DisplayPrivilegedPlane(theOnOff: Standard_Boolean, theSize: Standard_Real): void;
  ActivateGrid(aGridType: Aspect_GridType, aGridDrawMode: Aspect_GridDrawMode): void;
  DeactivateGrid(): void;
  SetGridEcho_1(showGrid: Standard_Boolean): void;
  SetGridEcho_2(aMarker: Handle_Graphic3d_AspectMarker3d): void;
  GridEcho(): Standard_Boolean;
  IsGridActive(): Standard_Boolean;
  Grid_1(theToCreate: Standard_Boolean): Handle_Aspect_Grid;
  Grid_2(theGridType: Aspect_GridType, theToCreate: Standard_Boolean): Handle_Aspect_Grid;
  GridType(): Aspect_GridType;
  GridDrawMode(): Aspect_GridDrawMode;
  RectangularGridValues(theXOrigin: Standard_Real, theYOrigin: Standard_Real, theXStep: Standard_Real, theYStep: Standard_Real, theRotationAngle: Standard_Real): void;
  SetRectangularGridValues(XOrigin: Standard_Real, YOrigin: Standard_Real, XStep: Standard_Real, YStep: Standard_Real, RotationAngle: Standard_Real): void;
  CircularGridValues(theXOrigin: Standard_Real, theYOrigin: Standard_Real, theRadiusStep: Standard_Real, theDivisionNumber: Graphic3d_ZLayerId, theRotationAngle: Standard_Real): void;
  SetCircularGridValues(XOrigin: Standard_Real, YOrigin: Standard_Real, RadiusStep: Standard_Real, DivisionNumber: Graphic3d_ZLayerId, RotationAngle: Standard_Real): void;
  CircularGridGraphicValues(theRadius: Standard_Real, theOffSet: Standard_Real): void;
  SetCircularGridGraphicValues(Radius: Standard_Real, OffSet: Standard_Real): void;
  RectangularGridGraphicValues(theXSize: Standard_Real, theYSize: Standard_Real, theOffSet: Standard_Real): void;
  SetRectangularGridGraphicValues(XSize: Standard_Real, YSize: Standard_Real, OffSet: Standard_Real): void;
  ShowGridEcho(theView: Handle_V3d_View, thePoint: Graphic3d_Vertex): void;
  HideGridEcho(theView: Handle_V3d_View): void;
  IsActive(): Standard_Boolean;
  InitActiveViews(): void;
  MoreActiveViews(): Standard_Boolean;
  NextActiveViews(): void;
  ActiveView(): Handle_V3d_View;
  InitDefinedViews(): void;
  MoreDefinedViews(): Standard_Boolean;
  NextDefinedViews(): void;
  DefinedView(): Handle_V3d_View;
  InitActiveLights(): void;
  MoreActiveLights(): Standard_Boolean;
  NextActiveLights(): void;
  ActiveLight(): any;
  InitDefinedLights(): void;
  MoreDefinedLights(): Standard_Boolean;
  NextDefinedLights(): void;
  DefinedLight(): any;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  delete(): void;
}

export declare class Handle_V3d_Viewer {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: V3d_Viewer): void;
  get(): V3d_Viewer;
  delete(): void;
}

  export declare class Handle_V3d_Viewer_1 extends Handle_V3d_Viewer {
    constructor();
  }

  export declare class Handle_V3d_Viewer_2 extends Handle_V3d_Viewer {
    constructor(thePtr: V3d_Viewer);
  }

  export declare class Handle_V3d_Viewer_3 extends Handle_V3d_Viewer {
    constructor(theHandle: Handle_V3d_Viewer);
  }

  export declare class Handle_V3d_Viewer_4 extends Handle_V3d_Viewer {
    constructor(theHandle: Handle_V3d_Viewer);
  }

export declare type V3d_TypeOfView = {
  V3d_ORTHOGRAPHIC: {};
  V3d_PERSPECTIVE: {};
}

export declare class Handle_V3d_View {
  Nullify(): void;
  IsNull(): boolean;
  reset(thePtr: V3d_View): void;
  get(): V3d_View;
  delete(): void;
}

  export declare class Handle_V3d_View_1 extends Handle_V3d_View {
    constructor();
  }

  export declare class Handle_V3d_View_2 extends Handle_V3d_View {
    constructor(thePtr: V3d_View);
  }

  export declare class Handle_V3d_View_3 extends Handle_V3d_View {
    constructor(theHandle: Handle_V3d_View);
  }

  export declare class Handle_V3d_View_4 extends Handle_V3d_View {
    constructor(theHandle: Handle_V3d_View);
  }

export declare class V3d_View extends Standard_Transient {
  SetWindow(theWindow: Handle_Aspect_Window, theContext: Aspect_RenderingContext): void;
  SetMagnify(theWindow: Handle_Aspect_Window, thePreviousView: Handle_V3d_View, theX1: Graphic3d_ZLayerId, theY1: Graphic3d_ZLayerId, theX2: Graphic3d_ZLayerId, theY2: Graphic3d_ZLayerId): void;
  Remove(): void;
  Update(): void;
  Redraw(): void;
  RedrawImmediate(): void;
  Invalidate(): void;
  IsInvalidated(): Standard_Boolean;
  IsInvalidatedImmediate(): Standard_Boolean;
  InvalidateImmediate(): void;
  MustBeResized(): void;
  DoMapping(): void;
  IsEmpty(): Standard_Boolean;
  UpdateLights(): void;
  SetAutoZFitMode(theIsOn: Standard_Boolean, theScaleFactor: Standard_Real): void;
  AutoZFitMode(): Standard_Boolean;
  AutoZFitScaleFactor(): Standard_Real;
  AutoZFit(): void;
  ZFitAll(theScaleFactor: Standard_Real): void;
  SetBackgroundColor_1(theType: Quantity_TypeOfColor, theV1: Standard_Real, theV2: Standard_Real, theV3: Standard_Real): void;
  SetBackgroundColor_2(theColor: Quantity_Color): void;
  SetBgGradientColors(theColor1: Quantity_Color, theColor2: Quantity_Color, theFillStyle: Aspect_GradientFillMethod, theToUpdate: Standard_Boolean): void;
  SetBgGradientStyle(theMethod: Aspect_GradientFillMethod, theToUpdate: Standard_Boolean): void;
  SetBackgroundImage_1(theFileName: Standard_CString, theFillStyle: Aspect_FillMethod, theToUpdate: Standard_Boolean): void;
  SetBackgroundImage_2(theTexture: Handle_Graphic3d_Texture2D, theFillStyle: Aspect_FillMethod, theToUpdate: Standard_Boolean): void;
  SetBgImageStyle(theFillStyle: Aspect_FillMethod, theToUpdate: Standard_Boolean): void;
  SetBackgroundCubeMap(theCubeMap: Handle_Graphic3d_CubeMap, theToUpdatePBREnv: Standard_Boolean, theToUpdate: Standard_Boolean): void;
  IsImageBasedLighting(): Standard_Boolean;
  SetImageBasedLighting(theToEnableIBL: Standard_Boolean, theToUpdate: Standard_Boolean): void;
  GeneratePBREnvironment(theToUpdate: Standard_Boolean): void;
  ClearPBREnvironment(theToUpdate: Standard_Boolean): void;
  SetTextureEnv(theTexture: Handle_Graphic3d_TextureEnv): void;
  SetAxis(X: Standard_Real, Y: Standard_Real, Z: Standard_Real, Vx: Standard_Real, Vy: Standard_Real, Vz: Standard_Real): void;
  SetVisualization(theType: V3d_TypeOfVisualization): void;
  SetLightOn_1(theLight: any): void;
  SetLightOn_2(): void;
  SetLightOff_1(theLight: any): void;
  SetLightOff_2(): void;
  IsActiveLight(theLight: any): Standard_Boolean;
  SetImmediateUpdate(theImmediateUpdate: Standard_Boolean): Standard_Boolean;
  Trihedron(theToCreate: Standard_Boolean): Handle_V3d_Trihedron;
  ZBufferTriedronSetup(theXColor: Quantity_Color, theYColor: Quantity_Color, theZColor: Quantity_Color, theSizeRatio: Standard_Real, theAxisDiametr: Standard_Real, theNbFacettes: Graphic3d_ZLayerId): void;
  TriedronDisplay(thePosition: Aspect_TypeOfTriedronPosition, theColor: Quantity_Color, theScale: Standard_Real, theMode: V3d_TypeOfVisualization): void;
  TriedronErase(): void;
  GetGraduatedTrihedron(): Graphic3d_GraduatedTrihedron;
  GraduatedTrihedronDisplay(theTrihedronData: Graphic3d_GraduatedTrihedron): void;
  GraduatedTrihedronErase(): void;
  SetFront(): void;
  Rotate_1(Ax: Standard_Real, Ay: Standard_Real, Az: Standard_Real, Start: Standard_Boolean): void;
  Rotate_2(Ax: Standard_Real, Ay: Standard_Real, Az: Standard_Real, X: Standard_Real, Y: Standard_Real, Z: Standard_Real, Start: Standard_Boolean): void;
  Rotate_3(Axe: V3d_TypeOfAxe, Angle: Standard_Real, X: Standard_Real, Y: Standard_Real, Z: Standard_Real, Start: Standard_Boolean): void;
  Rotate_4(Axe: V3d_TypeOfAxe, Angle: Standard_Real, Start: Standard_Boolean): void;
  Rotate_5(Angle: Standard_Real, Start: Standard_Boolean): void;
  Move_1(Dx: Standard_Real, Dy: Standard_Real, Dz: Standard_Real, Start: Standard_Boolean): void;
  Move_2(Axe: V3d_TypeOfAxe, Length: Standard_Real, Start: Standard_Boolean): void;
  Move_3(Length: Standard_Real, Start: Standard_Boolean): void;
  Translate_1(Dx: Standard_Real, Dy: Standard_Real, Dz: Standard_Real, Start: Standard_Boolean): void;
  Translate_2(Axe: V3d_TypeOfAxe, Length: Standard_Real, Start: Standard_Boolean): void;
  Translate_3(Length: Standard_Real, Start: Standard_Boolean): void;
  Place(theXp: Graphic3d_ZLayerId, theYp: Graphic3d_ZLayerId, theZoomFactor: Standard_Real): void;
  Turn_1(Ax: Standard_Real, Ay: Standard_Real, Az: Standard_Real, Start: Standard_Boolean): void;
  Turn_2(Axe: V3d_TypeOfAxe, Angle: Standard_Real, Start: Standard_Boolean): void;
  Turn_3(Angle: Standard_Real, Start: Standard_Boolean): void;
  SetTwist(Angle: Standard_Real): void;
  SetEye(X: Standard_Real, Y: Standard_Real, Z: Standard_Real): void;
  SetDepth(Depth: Standard_Real): void;
  SetProj_1(Vx: Standard_Real, Vy: Standard_Real, Vz: Standard_Real): void;
  SetProj_2(theOrientation: V3d_TypeOfOrientation, theIsYup: Standard_Boolean): void;
  SetAt(X: Standard_Real, Y: Standard_Real, Z: Standard_Real): void;
  SetUp_1(Vx: Standard_Real, Vy: Standard_Real, Vz: Standard_Real): void;
  SetUp_2(Orientation: V3d_TypeOfOrientation): void;
  SetViewOrientationDefault(): void;
  ResetViewOrientation(): void;
  Panning(theDXv: Standard_Real, theDYv: Standard_Real, theZoomFactor: Standard_Real, theToStart: Standard_Boolean): void;
  SetCenter(theXp: Graphic3d_ZLayerId, theYp: Graphic3d_ZLayerId): void;
  SetSize(theSize: Standard_Real): void;
  SetZSize(SetZSize: Standard_Real): void;
  SetZoom(Coef: Standard_Real, Start: Standard_Boolean): void;
  SetScale(Coef: Standard_Real): void;
  SetAxialScale(Sx: Standard_Real, Sy: Standard_Real, Sz: Standard_Real): void;
  FitAll_1(theMargin: Standard_Real, theToUpdate: Standard_Boolean): void;
  FitAll_2(theBox: Bnd_Box, theMargin: Standard_Real, theToUpdate: Standard_Boolean): void;
  DepthFitAll(Aspect: Standard_Real, Margin: Standard_Real): void;
  FitAll_3(theMinXv: Standard_Real, theMinYv: Standard_Real, theMaxXv: Standard_Real, theMaxYv: Standard_Real): void;
  WindowFit(theMinXp: Graphic3d_ZLayerId, theMinYp: Graphic3d_ZLayerId, theMaxXp: Graphic3d_ZLayerId, theMaxYp: Graphic3d_ZLayerId): void;
  SetViewMappingDefault(): void;
  ResetViewMapping(): void;
  Reset(theToUpdate: Standard_Boolean): void;
  Convert_1(Vp: Graphic3d_ZLayerId): Standard_Real;
  Convert_2(Xp: Graphic3d_ZLayerId, Yp: Graphic3d_ZLayerId, Xv: Standard_Real, Yv: Standard_Real): void;
  Convert_3(Vv: Standard_Real): Graphic3d_ZLayerId;
  Convert_4(Xv: Standard_Real, Yv: Standard_Real, Xp: Graphic3d_ZLayerId, Yp: Graphic3d_ZLayerId): void;
  Convert_5(Xp: Graphic3d_ZLayerId, Yp: Graphic3d_ZLayerId, X: Standard_Real, Y: Standard_Real, Z: Standard_Real): void;
  ConvertWithProj(Xp: Graphic3d_ZLayerId, Yp: Graphic3d_ZLayerId, X: Standard_Real, Y: Standard_Real, Z: Standard_Real, Vx: Standard_Real, Vy: Standard_Real, Vz: Standard_Real): void;
  ConvertToGrid_1(Xp: Graphic3d_ZLayerId, Yp: Graphic3d_ZLayerId, Xg: Standard_Real, Yg: Standard_Real, Zg: Standard_Real): void;
  ConvertToGrid_2(X: Standard_Real, Y: Standard_Real, Z: Standard_Real, Xg: Standard_Real, Yg: Standard_Real, Zg: Standard_Real): void;
  Convert_6(X: Standard_Real, Y: Standard_Real, Z: Standard_Real, Xp: Graphic3d_ZLayerId, Yp: Graphic3d_ZLayerId): void;
  Project_1(theX: Standard_Real, theY: Standard_Real, theZ: Standard_Real, theXp: Standard_Real, theYp: Standard_Real): void;
  Project_2(theX: Standard_Real, theY: Standard_Real, theZ: Standard_Real, theXp: Standard_Real, theYp: Standard_Real, theZp: Standard_Real): void;
  BackgroundColor_1(Type: Quantity_TypeOfColor, V1: Standard_Real, V2: Standard_Real, V3: Standard_Real): void;
  BackgroundColor_2(): Quantity_Color;
  GradientBackgroundColors(theColor1: Quantity_Color, theColor2: Quantity_Color): void;
  GradientBackground(): Aspect_GradientBackground;
  Scale_1(): Standard_Real;
  AxialScale_1(Sx: Standard_Real, Sy: Standard_Real, Sz: Standard_Real): void;
  Size(Width: Standard_Real, Height: Standard_Real): void;
  ZSize(): Standard_Real;
  Eye(X: Standard_Real, Y: Standard_Real, Z: Standard_Real): void;
  FocalReferencePoint(X: Standard_Real, Y: Standard_Real, Z: Standard_Real): void;
  ProjReferenceAxe(Xpix: Graphic3d_ZLayerId, Ypix: Graphic3d_ZLayerId, XP: Standard_Real, YP: Standard_Real, ZP: Standard_Real, VX: Standard_Real, VY: Standard_Real, VZ: Standard_Real): void;
  Depth(): Standard_Real;
  Proj(Vx: Standard_Real, Vy: Standard_Real, Vz: Standard_Real): void;
  At(X: Standard_Real, Y: Standard_Real, Z: Standard_Real): void;
  Up(Vx: Standard_Real, Vy: Standard_Real, Vz: Standard_Real): void;
  Twist(): Standard_Real;
  ShadingModel(): V3d_TypeOfShadingModel;
  SetShadingModel(theShadingModel: V3d_TypeOfShadingModel): void;
  TextureEnv(): Handle_Graphic3d_TextureEnv;
  Visualization(): V3d_TypeOfVisualization;
  ActiveLights(): V3d_ListOfLight;
  ActiveLightIterator(): V3d_ListOfLightIterator;
  LightLimit(): Graphic3d_ZLayerId;
  Viewer(): Handle_V3d_Viewer;
  IfWindow(): Standard_Boolean;
  Window(): Handle_Aspect_Window;
  Type(): V3d_TypeOfView;
  Pan(theDXp: Graphic3d_ZLayerId, theDYp: Graphic3d_ZLayerId, theZoomFactor: Standard_Real, theToStart: Standard_Boolean): void;
  Zoom(theXp1: Graphic3d_ZLayerId, theYp1: Graphic3d_ZLayerId, theXp2: Graphic3d_ZLayerId, theYp2: Graphic3d_ZLayerId): void;
  StartZoomAtPoint(theXp: Graphic3d_ZLayerId, theYp: Graphic3d_ZLayerId): void;
  ZoomAtPoint(theMouseStartX: Graphic3d_ZLayerId, theMouseStartY: Graphic3d_ZLayerId, theMouseEndX: Graphic3d_ZLayerId, theMouseEndY: Graphic3d_ZLayerId): void;
  AxialScale_2(Dx: Graphic3d_ZLayerId, Dy: Graphic3d_ZLayerId, Axis: V3d_TypeOfAxe): void;
  StartRotation(X: Graphic3d_ZLayerId, Y: Graphic3d_ZLayerId, zRotationThreshold: Standard_Real): void;
  Rotation(X: Graphic3d_ZLayerId, Y: Graphic3d_ZLayerId): void;
  SetFocale(Focale: Standard_Real): void;
  Focale(): Standard_Real;
  View(): Handle_Graphic3d_CView;
  SetComputedMode(theMode: Standard_Boolean): void;
  ComputedMode(): Standard_Boolean;
  WindowFitAll(Xmin: Graphic3d_ZLayerId, Ymin: Graphic3d_ZLayerId, Xmax: Graphic3d_ZLayerId, Ymax: Graphic3d_ZLayerId): void;
  FitMinMax(theCamera: Handle_Graphic3d_Camera, theBox: Bnd_Box, theMargin: Standard_Real, theResolution: Standard_Real, theToEnlargeIfLine: Standard_Boolean): Standard_Boolean;
  SetGrid(aPlane: gp_Ax3, aGrid: Handle_Aspect_Grid): void;
  SetGridActivity(aFlag: Standard_Boolean): void;
  Dump(theFile: Standard_CString, theBufferType: Graphic3d_BufferType): Standard_Boolean;
  ToPixMap_1(theImage: Image_PixMap, theParams: V3d_ImageDumpOptions): Standard_Boolean;
  ToPixMap_2(theImage: Image_PixMap, theWidth: Graphic3d_ZLayerId, theHeight: Graphic3d_ZLayerId, theBufferType: Graphic3d_BufferType, theToAdjustAspect: Standard_Boolean, theStereoOptions: V3d_StereoDumpOptions): Standard_Boolean;
  SetBackFacingModel(theModel: V3d_TypeOfBackfacingModel): void;
  BackFacingModel(): V3d_TypeOfBackfacingModel;
  AddClipPlane(thePlane: Handle_Graphic3d_ClipPlane): void;
  RemoveClipPlane(thePlane: Handle_Graphic3d_ClipPlane): void;
  ClipPlanes(): Handle_Graphic3d_SequenceOfHClipPlane;
  SetClipPlanes(thePlanes: Handle_Graphic3d_SequenceOfHClipPlane): void;
  PlaneLimit(): Graphic3d_ZLayerId;
  SetCamera(theCamera: Handle_Graphic3d_Camera): void;
  Camera(): Handle_Graphic3d_Camera;
  DefaultCamera(): Handle_Graphic3d_Camera;
  RenderingParams(): Graphic3d_RenderingParams;
  ChangeRenderingParams(): Graphic3d_RenderingParams;
  IsCullingEnabled(): Standard_Boolean;
  SetFrustumCulling(theMode: Standard_Boolean): void;
  DiagnosticInformation(theDict: TColStd_IndexedDataMapOfStringString, theFlags: Graphic3d_DiagnosticInfo): void;
  StatisticInformation_1(): XCAFDoc_PartId;
  StatisticInformation_2(theDict: TColStd_IndexedDataMapOfStringString): void;
  GravityPoint(): gp_Pnt;
  DumpJson(theOStream: Standard_OStream, theDepth: Graphic3d_ZLayerId): void;
  static get_type_name(): Standard_Character;
  static get_type_descriptor(): Handle_Standard_Type;
  DynamicType(): Handle_Standard_Type;
  IfMoreLights(): Standard_Boolean;
  InitActiveLights(): void;
  MoreActiveLights(): Standard_Boolean;
  NextActiveLights(): void;
  ActiveLight(): any;
  delete(): void;
}

  export declare class V3d_View_1 extends V3d_View {
    constructor(theViewer: Handle_V3d_Viewer, theType: V3d_TypeOfView);
  }

  export declare class V3d_View_2 extends V3d_View {
    constructor(theViewer: Handle_V3d_Viewer, theView: Handle_V3d_View);
  }

export declare class OCJS {
  constructor();
  static getStandard_FailureData(exceptionPtr: intptr_t): Standard_Failure;
  delete(): void;
}

export declare class Test {
  constructor();
  static SetWindow(v: V3d_View, w: Handle_Aspect_Window): void;
  static castAIS_InteractiveContext(ptr: intptr_t): AIS_InteractiveContext;
  static castV3d_View(ptr: intptr_t): V3d_View;
  static castAIS_ViewController(ptr: intptr_t): AIS_ViewController;
  static castHandle_AIS_InteractiveObject(ptr: intptr_t): Handle_AIS_InteractiveObject;
  static castGraphic3d_ClipPlane(ptr: intptr_t): Graphic3d_ClipPlane;
  static ProcessWheelEvent(w: Wasm_Window, theListener: Aspect_WindowInputListener, event: any): Standard_Boolean;
  static ProcessMouseEvent(w: Wasm_Window, theListener: Aspect_WindowInputListener, event: any, eventType: Standard_Integer): Standard_Boolean;
  static ProcesUiEvent(w: Wasm_Window, theListener: Aspect_WindowInputListener, event: any, eventType: Standard_Integer): Standard_Boolean;
  static ProcessTouchEvent(w: Wasm_Window, theListener: Aspect_WindowInputListener, event: any, eventType: Standard_Integer): Standard_Boolean;
  static GetListOfGDTShapes(dimTolTool: XCAFDoc_DimTolTool): any;
  delete(): void;
}

type Standard_Boolean = boolean;
type Standard_Byte = number;
type Standard_Character = number;
type Standard_CString = string;
type Standard_Integer = number;
type Standard_Real = number;
type Standard_ShortReal = number;
type Standard_Size = number;

declare namespace FS {
  interface Lookup {
      path: string;
      node: FSNode;
  }

  interface FSStream {}
  interface FSNode {}
  interface ErrnoError {}

  let ignorePermissions: boolean;
  let trackingDelegate: any;
  let tracking: any;
  let genericErrors: any;

  //
  // paths
  //
  function lookupPath(path: string, opts: any): Lookup;
  function getPath(node: FSNode): string;

  //
  // nodes
  //
  function isFile(mode: number): boolean;
  function isDir(mode: number): boolean;
  function isLink(mode: number): boolean;
  function isChrdev(mode: number): boolean;
  function isBlkdev(mode: number): boolean;
  function isFIFO(mode: number): boolean;
  function isSocket(mode: number): boolean;

  //
  // devices
  //
  function major(dev: number): number;
  function minor(dev: number): number;
  function makedev(ma: number, mi: number): number;
  function registerDevice(dev: number, ops: any): void;

  //
  // core
  //
  function syncfs(populate: boolean, callback: (e: any) => any): void;
  function syncfs(callback: (e: any) => any, populate?: boolean): void;
  function mount(type: any, opts: any, mountpoint: string): any;
  function unmount(mountpoint: string): void;

  function mkdir(path: string, mode?: number): any;
  function mkdev(path: string, mode?: number, dev?: number): any;
  function symlink(oldpath: string, newpath: string): any;
  function rename(old_path: string, new_path: string): void;
  function rmdir(path: string): void;
  function readdir(path: string): any;
  function unlink(path: string): void;
  function readlink(path: string): string;
  function stat(path: string, dontFollow?: boolean): any;
  function lstat(path: string): any;
  function chmod(path: string, mode: number, dontFollow?: boolean): void;
  function lchmod(path: string, mode: number): void;
  function fchmod(fd: number, mode: number): void;
  function chown(path: string, uid: number, gid: number, dontFollow?: boolean): void;
  function lchown(path: string, uid: number, gid: number): void;
  function fchown(fd: number, uid: number, gid: number): void;
  function truncate(path: string, len: number): void;
  function ftruncate(fd: number, len: number): void;
  function utime(path: string, atime: number, mtime: number): void;
  function open(path: string, flags: string, mode?: number, fd_start?: number, fd_end?: number): FSStream;
  function close(stream: FSStream): void;
  function llseek(stream: FSStream, offset: number, whence: number): any;
  function read(stream: FSStream, buffer: ArrayBufferView, offset: number, length: number, position?: number): number;
  function write(
      stream: FSStream,
      buffer: ArrayBufferView,
      offset: number,
      length: number,
      position?: number,
      canOwn?: boolean,
  ): number;
  function allocate(stream: FSStream, offset: number, length: number): void;
  function mmap(
      stream: FSStream,
      buffer: ArrayBufferView,
      offset: number,
      length: number,
      position: number,
      prot: number,
      flags: number,
  ): any;
  function ioctl(stream: FSStream, cmd: any, arg: any): any;
  function readFile(path: string, opts: { encoding: 'binary'; flags?: string }): Uint8Array;
  function readFile(path: string, opts: { encoding: 'utf8'; flags?: string }): string;
  function readFile(path: string, opts?: { flags?: string }): Uint8Array;
  function writeFile(path: string, data: string | ArrayBufferView, opts?: { flags?: string }): void;

  //
  // module-level FS code
  //
  function cwd(): string;
  function chdir(path: string): void;
  function init(
      input: null | (() => number | null),
      output: null | ((c: number) => any),
      error: null | ((c: number) => any),
  ): void;

  function createLazyFile(
      parent: string | FSNode,
      name: string,
      url: string,
      canRead: boolean,
      canWrite: boolean,
  ): FSNode;
  function createPreloadedFile(
      parent: string | FSNode,
      name: string,
      url: string,
      canRead: boolean,
      canWrite: boolean,
      onload?: () => void,
      onerror?: () => void,
      dontCreateFile?: boolean,
      canOwn?: boolean,
  ): void;
  function createDataFile(
      parent: string | FSNode,
      name: string,
      data: ArrayBufferView | string,
      canRead: boolean,
      canWrite: boolean,
      canOwn: boolean,
  ): FSNode;
  interface AnalysisResults {
    isRoot: boolean,
    exists: boolean,
    error: Error,
    name: string,
    path: any,
    object: any,
    parentExists: boolean,
    parentPath: any,
    parentObject: any
  }
  function analyzePath(path: string): AnalysisResults;
}


export type OpenCascadeInstance = {FS: typeof FS} & {
  STEPCAFControl_Reader: typeof STEPCAFControl_Reader;
  STEPCAFControl_Reader_1: typeof STEPCAFControl_Reader_1;
  STEPCAFControl_Reader_2: typeof STEPCAFControl_Reader_2;
  Image_PixMap: typeof Image_PixMap;
  Handle_Image_PixMap: typeof Handle_Image_PixMap;
  Handle_Image_PixMap_1: typeof Handle_Image_PixMap_1;
  Handle_Image_PixMap_2: typeof Handle_Image_PixMap_2;
  Handle_Image_PixMap_3: typeof Handle_Image_PixMap_3;
  Handle_Image_PixMap_4: typeof Handle_Image_PixMap_4;
  Image_Format: Image_Format;
  CDM_Document: typeof CDM_Document;
  Message_ProgressRange: typeof Message_ProgressRange;
  Message_ProgressRange_1: typeof Message_ProgressRange_1;
  Message_ProgressRange_2: typeof Message_ProgressRange_2;
  IGESControl_Reader: typeof IGESControl_Reader;
  IGESControl_Reader_1: typeof IGESControl_Reader_1;
  IGESControl_Reader_2: typeof IGESControl_Reader_2;
  TCollection_AsciiString: typeof TCollection_AsciiString;
  TCollection_AsciiString_1: typeof TCollection_AsciiString_1;
  TCollection_AsciiString_2: typeof TCollection_AsciiString_2;
  TCollection_AsciiString_3: typeof TCollection_AsciiString_3;
  TCollection_AsciiString_4: typeof TCollection_AsciiString_4;
  TCollection_AsciiString_5: typeof TCollection_AsciiString_5;
  TCollection_AsciiString_6: typeof TCollection_AsciiString_6;
  TCollection_AsciiString_7: typeof TCollection_AsciiString_7;
  TCollection_AsciiString_8: typeof TCollection_AsciiString_8;
  TCollection_AsciiString_9: typeof TCollection_AsciiString_9;
  TCollection_AsciiString_10: typeof TCollection_AsciiString_10;
  TCollection_AsciiString_11: typeof TCollection_AsciiString_11;
  TCollection_AsciiString_12: typeof TCollection_AsciiString_12;
  TCollection_AsciiString_13: typeof TCollection_AsciiString_13;
  TCollection_AsciiString_14: typeof TCollection_AsciiString_14;
  TCollection_ExtendedString: typeof TCollection_ExtendedString;
  TCollection_ExtendedString_1: typeof TCollection_ExtendedString_1;
  TCollection_ExtendedString_2: typeof TCollection_ExtendedString_2;
  TCollection_ExtendedString_3: typeof TCollection_ExtendedString_3;
  TCollection_ExtendedString_4: typeof TCollection_ExtendedString_4;
  TCollection_ExtendedString_5: typeof TCollection_ExtendedString_5;
  TCollection_ExtendedString_6: typeof TCollection_ExtendedString_6;
  TCollection_ExtendedString_7: typeof TCollection_ExtendedString_7;
  TCollection_ExtendedString_8: typeof TCollection_ExtendedString_8;
  TCollection_ExtendedString_9: typeof TCollection_ExtendedString_9;
  TCollection_ExtendedString_10: typeof TCollection_ExtendedString_10;
  TCollection_ExtendedString_11: typeof TCollection_ExtendedString_11;
  TCollection_ExtendedString_12: typeof TCollection_ExtendedString_12;
  BRepMesh_IncrementalMesh: typeof BRepMesh_IncrementalMesh;
  BRepMesh_IncrementalMesh_1: typeof BRepMesh_IncrementalMesh_1;
  BRepMesh_IncrementalMesh_2: typeof BRepMesh_IncrementalMesh_2;
  BRepMesh_IncrementalMesh_3: typeof BRepMesh_IncrementalMesh_3;
  BRepMesh_DiscretRoot: typeof BRepMesh_DiscretRoot;
  XSControl_Reader: typeof XSControl_Reader;
  XSControl_Reader_1: typeof XSControl_Reader_1;
  XSControl_Reader_2: typeof XSControl_Reader_2;
  XSControl_Reader_3: typeof XSControl_Reader_3;
  OpenGl_GraphicDriver: typeof OpenGl_GraphicDriver;
  Standard_Failure: typeof Standard_Failure;
  Standard_Failure_1: typeof Standard_Failure_1;
  Standard_Failure_2: typeof Standard_Failure_2;
  Standard_Failure_3: typeof Standard_Failure_3;
  Standard_Failure_4: typeof Standard_Failure_4;
  Standard_Transient: typeof Standard_Transient;
  Standard_Transient_1: typeof Standard_Transient_1;
  Standard_Transient_2: typeof Standard_Transient_2;
  XCAFPrs_Style: typeof XCAFPrs_Style;
  XCAFPrs_AISObject: typeof XCAFPrs_AISObject;
  Wasm_Window: typeof Wasm_Window;
  IFSelect_ReturnStatus: IFSelect_ReturnStatus;
  Aspect_Window: typeof Aspect_Window;
  Handle_Aspect_Window: typeof Handle_Aspect_Window;
  Handle_Aspect_Window_1: typeof Handle_Aspect_Window_1;
  Handle_Aspect_Window_2: typeof Handle_Aspect_Window_2;
  Handle_Aspect_Window_3: typeof Handle_Aspect_Window_3;
  Handle_Aspect_Window_4: typeof Handle_Aspect_Window_4;
  Aspect_TypeOfResize: Aspect_TypeOfResize;
  Aspect_GradientFillMethod: Aspect_GradientFillMethod;
  Handle_Aspect_DisplayConnection: typeof Handle_Aspect_DisplayConnection;
  Handle_Aspect_DisplayConnection_1: typeof Handle_Aspect_DisplayConnection_1;
  Handle_Aspect_DisplayConnection_2: typeof Handle_Aspect_DisplayConnection_2;
  Handle_Aspect_DisplayConnection_3: typeof Handle_Aspect_DisplayConnection_3;
  Handle_Aspect_DisplayConnection_4: typeof Handle_Aspect_DisplayConnection_4;
  Aspect_WindowInputListener: typeof Aspect_WindowInputListener;
  Quantity_Color: typeof Quantity_Color;
  Quantity_Color_1: typeof Quantity_Color_1;
  Quantity_Color_2: typeof Quantity_Color_2;
  Quantity_Color_3: typeof Quantity_Color_3;
  Quantity_Color_4: typeof Quantity_Color_4;
  Quantity_ColorRGBA: typeof Quantity_ColorRGBA;
  Quantity_ColorRGBA_1: typeof Quantity_ColorRGBA_1;
  Quantity_ColorRGBA_2: typeof Quantity_ColorRGBA_2;
  Quantity_ColorRGBA_3: typeof Quantity_ColorRGBA_3;
  Quantity_ColorRGBA_4: typeof Quantity_ColorRGBA_4;
  Quantity_ColorRGBA_5: typeof Quantity_ColorRGBA_5;
  Quantity_TypeOfColor: Quantity_TypeOfColor;
  Graphic3d_DataStructureManager: typeof Graphic3d_DataStructureManager;
  Handle_Graphic3d_SequenceOfHClipPlane: typeof Handle_Graphic3d_SequenceOfHClipPlane;
  Handle_Graphic3d_SequenceOfHClipPlane_1: typeof Handle_Graphic3d_SequenceOfHClipPlane_1;
  Handle_Graphic3d_SequenceOfHClipPlane_2: typeof Handle_Graphic3d_SequenceOfHClipPlane_2;
  Handle_Graphic3d_SequenceOfHClipPlane_3: typeof Handle_Graphic3d_SequenceOfHClipPlane_3;
  Handle_Graphic3d_SequenceOfHClipPlane_4: typeof Handle_Graphic3d_SequenceOfHClipPlane_4;
  Graphic3d_SequenceOfHClipPlane: typeof Graphic3d_SequenceOfHClipPlane;
  Handle_Graphic3d_CView: typeof Handle_Graphic3d_CView;
  Handle_Graphic3d_CView_1: typeof Handle_Graphic3d_CView_1;
  Handle_Graphic3d_CView_2: typeof Handle_Graphic3d_CView_2;
  Handle_Graphic3d_CView_3: typeof Handle_Graphic3d_CView_3;
  Handle_Graphic3d_CView_4: typeof Handle_Graphic3d_CView_4;
  Graphic3d_CView: typeof Graphic3d_CView;
  Graphic3d_Texture2D: typeof Graphic3d_Texture2D;
  Graphic3d_TransformPers: typeof Graphic3d_TransformPers;
  Graphic3d_TransformPers_1: typeof Graphic3d_TransformPers_1;
  Graphic3d_TransformPers_2: typeof Graphic3d_TransformPers_2;
  Graphic3d_TransformPers_3: typeof Graphic3d_TransformPers_3;
  Handle_Graphic3d_TransformPers: typeof Handle_Graphic3d_TransformPers;
  Handle_Graphic3d_TransformPers_1: typeof Handle_Graphic3d_TransformPers_1;
  Handle_Graphic3d_TransformPers_2: typeof Handle_Graphic3d_TransformPers_2;
  Handle_Graphic3d_TransformPers_3: typeof Handle_Graphic3d_TransformPers_3;
  Handle_Graphic3d_TransformPers_4: typeof Handle_Graphic3d_TransformPers_4;
  Graphic3d_Vec2i: typeof Graphic3d_Vec2i;
  Graphic3d_Vec2i_1: typeof Graphic3d_Vec2i_1;
  Graphic3d_Vec2i_2: typeof Graphic3d_Vec2i_2;
  Graphic3d_Vec2i_3: typeof Graphic3d_Vec2i_3;
  Graphic3d_PresentationAttributes: typeof Graphic3d_PresentationAttributes;
  Graphic3d_Texture2Dplane: typeof Graphic3d_Texture2Dplane;
  Graphic3d_Texture2Dplane_1: typeof Graphic3d_Texture2Dplane_1;
  Graphic3d_Texture2Dplane_2: typeof Graphic3d_Texture2Dplane_2;
  Graphic3d_Texture2Dplane_3: typeof Graphic3d_Texture2Dplane_3;
  Graphic3d_ClipPlane: typeof Graphic3d_ClipPlane;
  Graphic3d_ClipPlane_1: typeof Graphic3d_ClipPlane_1;
  Graphic3d_ClipPlane_2: typeof Graphic3d_ClipPlane_2;
  Graphic3d_ClipPlane_3: typeof Graphic3d_ClipPlane_3;
  Graphic3d_ClipPlane_4: typeof Graphic3d_ClipPlane_4;
  Handle_Graphic3d_ClipPlane: typeof Handle_Graphic3d_ClipPlane;
  Handle_Graphic3d_ClipPlane_1: typeof Handle_Graphic3d_ClipPlane_1;
  Handle_Graphic3d_ClipPlane_2: typeof Handle_Graphic3d_ClipPlane_2;
  Handle_Graphic3d_ClipPlane_3: typeof Handle_Graphic3d_ClipPlane_3;
  Handle_Graphic3d_ClipPlane_4: typeof Handle_Graphic3d_ClipPlane_4;
  Graphic3d_TextureRoot: typeof Graphic3d_TextureRoot;
  Graphic3d_TextureMap: typeof Graphic3d_TextureMap;
  Handle_Graphic3d_TextureMap: typeof Handle_Graphic3d_TextureMap;
  Handle_Graphic3d_TextureMap_1: typeof Handle_Graphic3d_TextureMap_1;
  Handle_Graphic3d_TextureMap_2: typeof Handle_Graphic3d_TextureMap_2;
  Handle_Graphic3d_TextureMap_3: typeof Handle_Graphic3d_TextureMap_3;
  Handle_Graphic3d_TextureMap_4: typeof Handle_Graphic3d_TextureMap_4;
  Graphic3d_GraphicDriver: typeof Graphic3d_GraphicDriver;
  Handle_Graphic3d_GraphicDriver: typeof Handle_Graphic3d_GraphicDriver;
  Handle_Graphic3d_GraphicDriver_1: typeof Handle_Graphic3d_GraphicDriver_1;
  Handle_Graphic3d_GraphicDriver_2: typeof Handle_Graphic3d_GraphicDriver_2;
  Handle_Graphic3d_GraphicDriver_3: typeof Handle_Graphic3d_GraphicDriver_3;
  Handle_Graphic3d_GraphicDriver_4: typeof Handle_Graphic3d_GraphicDriver_4;
  RWMesh_CafReader: typeof RWMesh_CafReader;
  IGESCAFControl_Reader: typeof IGESCAFControl_Reader;
  IGESCAFControl_Reader_1: typeof IGESCAFControl_Reader_1;
  IGESCAFControl_Reader_2: typeof IGESCAFControl_Reader_2;
  TDataStd_GenericEmpty: typeof TDataStd_GenericEmpty;
  TopoDS_Shape: typeof TopoDS_Shape;
  TopoDS_Compound: typeof TopoDS_Compound;
  TopoDS_Builder: typeof TopoDS_Builder;
  AIS_ViewCube: typeof AIS_ViewCube;
  AIS_ConnectedInteractive: typeof AIS_ConnectedInteractive;
  Handle_AIS_InteractiveObject: typeof Handle_AIS_InteractiveObject;
  Handle_AIS_InteractiveObject_1: typeof Handle_AIS_InteractiveObject_1;
  Handle_AIS_InteractiveObject_2: typeof Handle_AIS_InteractiveObject_2;
  Handle_AIS_InteractiveObject_3: typeof Handle_AIS_InteractiveObject_3;
  Handle_AIS_InteractiveObject_4: typeof Handle_AIS_InteractiveObject_4;
  AIS_InteractiveObject: typeof AIS_InteractiveObject;
  AIS_Shape: typeof AIS_Shape;
  AIS_DisplayMode: AIS_DisplayMode;
  Handle_AIS_InteractiveContext: typeof Handle_AIS_InteractiveContext;
  Handle_AIS_InteractiveContext_1: typeof Handle_AIS_InteractiveContext_1;
  Handle_AIS_InteractiveContext_2: typeof Handle_AIS_InteractiveContext_2;
  Handle_AIS_InteractiveContext_3: typeof Handle_AIS_InteractiveContext_3;
  Handle_AIS_InteractiveContext_4: typeof Handle_AIS_InteractiveContext_4;
  AIS_InteractiveContext: typeof AIS_InteractiveContext;
  AIS_ColoredShape: typeof AIS_ColoredShape;
  AIS_ColoredShape_1: typeof AIS_ColoredShape_1;
  AIS_ColoredShape_2: typeof AIS_ColoredShape_2;
  AIS_ViewController: typeof AIS_ViewController;
  StdPrs_ToolTriangulatedShape: typeof StdPrs_ToolTriangulatedShape;
  Bnd_Box: typeof Bnd_Box;
  Bnd_Box_1: typeof Bnd_Box_1;
  Bnd_Box_2: typeof Bnd_Box_2;
  XCAFDoc_ShapeTool: typeof XCAFDoc_ShapeTool;
  Handle_XCAFDoc_ShapeTool: typeof Handle_XCAFDoc_ShapeTool;
  Handle_XCAFDoc_ShapeTool_1: typeof Handle_XCAFDoc_ShapeTool_1;
  Handle_XCAFDoc_ShapeTool_2: typeof Handle_XCAFDoc_ShapeTool_2;
  Handle_XCAFDoc_ShapeTool_3: typeof Handle_XCAFDoc_ShapeTool_3;
  Handle_XCAFDoc_ShapeTool_4: typeof Handle_XCAFDoc_ShapeTool_4;
  XCAFDoc_ColorTool: typeof XCAFDoc_ColorTool;
  XCAFDoc_DimTolTool: typeof XCAFDoc_DimTolTool;
  Handle_XCAFDoc_DimTolTool: typeof Handle_XCAFDoc_DimTolTool;
  Handle_XCAFDoc_DimTolTool_1: typeof Handle_XCAFDoc_DimTolTool_1;
  Handle_XCAFDoc_DimTolTool_2: typeof Handle_XCAFDoc_DimTolTool_2;
  Handle_XCAFDoc_DimTolTool_3: typeof Handle_XCAFDoc_DimTolTool_3;
  Handle_XCAFDoc_DimTolTool_4: typeof Handle_XCAFDoc_DimTolTool_4;
  XCAFDoc_DocumentTool: typeof XCAFDoc_DocumentTool;
  XCAFDoc_ColorType: XCAFDoc_ColorType;
  TDocStd_Document: typeof TDocStd_Document;
  Handle_TDocStd_Document: typeof Handle_TDocStd_Document;
  Handle_TDocStd_Document_1: typeof Handle_TDocStd_Document_1;
  Handle_TDocStd_Document_2: typeof Handle_TDocStd_Document_2;
  Handle_TDocStd_Document_3: typeof Handle_TDocStd_Document_3;
  Handle_TDocStd_Document_4: typeof Handle_TDocStd_Document_4;
  BRep_Builder: typeof BRep_Builder;
  Prs3d_Drawer: typeof Prs3d_Drawer;
  Handle_Prs3d_Drawer: typeof Handle_Prs3d_Drawer;
  Handle_Prs3d_Drawer_1: typeof Handle_Prs3d_Drawer_1;
  Handle_Prs3d_Drawer_2: typeof Handle_Prs3d_Drawer_2;
  Handle_Prs3d_Drawer_3: typeof Handle_Prs3d_Drawer_3;
  Handle_Prs3d_Drawer_4: typeof Handle_Prs3d_Drawer_4;
  RWGltf_CafReader: typeof RWGltf_CafReader;
  BRepTools: typeof BRepTools;
  TopLoc_Location: typeof TopLoc_Location;
  TopLoc_Location_1: typeof TopLoc_Location_1;
  TopLoc_Location_2: typeof TopLoc_Location_2;
  TopLoc_Location_3: typeof TopLoc_Location_3;
  SelectMgr_SelectableObject: typeof SelectMgr_SelectableObject;
  TDF_Attribute: typeof TDF_Attribute;
  TDF_Label: typeof TDF_Label;
  TDF_ChildIterator: typeof TDF_ChildIterator;
  TDF_ChildIterator_1: typeof TDF_ChildIterator_1;
  TDF_ChildIterator_2: typeof TDF_ChildIterator_2;
  TDF_Tool: typeof TDF_Tool;
  TDF_LabelSequence: typeof TDF_LabelSequence;
  TDF_LabelSequence_1: typeof TDF_LabelSequence_1;
  TDF_LabelSequence_2: typeof TDF_LabelSequence_2;
  TDF_LabelSequence_3: typeof TDF_LabelSequence_3;
  gp_Trsf: typeof gp_Trsf;
  gp_Trsf_1: typeof gp_Trsf_1;
  gp_Trsf_2: typeof gp_Trsf_2;
  gp_Pnt: typeof gp_Pnt;
  gp_Pnt_1: typeof gp_Pnt_1;
  gp_Pnt_2: typeof gp_Pnt_2;
  gp_Pnt_3: typeof gp_Pnt_3;
  gp_Dir: typeof gp_Dir;
  gp_Dir_1: typeof gp_Dir_1;
  gp_Dir_2: typeof gp_Dir_2;
  gp_Dir_3: typeof gp_Dir_3;
  gp_Dir_4: typeof gp_Dir_4;
  gp_Pln: typeof gp_Pln;
  gp_Pln_1: typeof gp_Pln_1;
  gp_Pln_2: typeof gp_Pln_2;
  gp_Pln_3: typeof gp_Pln_3;
  gp_Pln_4: typeof gp_Pln_4;
  PrsMgr_PresentableObject: typeof PrsMgr_PresentableObject;
  PrsMgr_TypeOfPresentation3d: PrsMgr_TypeOfPresentation3d;
  NCollection_BaseSequence: typeof NCollection_BaseSequence;
  V3d_Viewer: typeof V3d_Viewer;
  Handle_V3d_Viewer: typeof Handle_V3d_Viewer;
  Handle_V3d_Viewer_1: typeof Handle_V3d_Viewer_1;
  Handle_V3d_Viewer_2: typeof Handle_V3d_Viewer_2;
  Handle_V3d_Viewer_3: typeof Handle_V3d_Viewer_3;
  Handle_V3d_Viewer_4: typeof Handle_V3d_Viewer_4;
  V3d_TypeOfView: V3d_TypeOfView;
  Handle_V3d_View: typeof Handle_V3d_View;
  Handle_V3d_View_1: typeof Handle_V3d_View_1;
  Handle_V3d_View_2: typeof Handle_V3d_View_2;
  Handle_V3d_View_3: typeof Handle_V3d_View_3;
  Handle_V3d_View_4: typeof Handle_V3d_View_4;
  V3d_View: typeof V3d_View;
  V3d_View_1: typeof V3d_View_1;
  V3d_View_2: typeof V3d_View_2;
  OCJS: typeof OCJS;
  Test: typeof Test;
};

declare function init(): Promise<OpenCascadeInstance>;

export default init;