libbse-dev 0.7.8-1 / usr / include / bse / bsehack.idl

/* this file was generated from make bsecore.idl */
// bseprocidl: type BseREADWRITE excluded from generation
// bseprocidl: type BseSTORAGE excluded from generation
// bseprocidl: type BseSTANDARD excluded from generation
// bseprocidl: type BseStandardRdonly excluded from generation
// bseprocidl: type BseGUI excluded from generation
// bseprocidl: type BseGuiRdonly excluded from generation
// bseprocidl: type BseGuiReadable excluded from generation
// bseprocidl: type BseSkipDefault excluded from generation
// bseprocidl: type BseSkipUndo excluded from generation
// bseprocidl: type BseDEFAULT excluded from generation
// bseprocidl: type BseMAXINT excluded from generation
// bseprocidl: type BseMININT excluded from generation
// bseprocidl: type BseMAXNUM excluded from generation
// bseprocidl: type BseMINNUM excluded from generation
// bseprocidl: type BseMINDB excluded from generation
// bseprocidl: type BseIntSeq excluded from generation
// bseprocidl: type BseTypeSeq excluded from generation
// bseprocidl: type BseStringSeq excluded from generation
// bseprocidl: type BseFloatSeq excluded from generation
// bseprocidl: type BseMusicalTuningType excluded from generation
// bseprocidl: type BseMidiSignalType excluded from generation
// bseprocidl: type BseMidiControlType excluded from generation
// bseprocidl: type BseMidiChannelEventType excluded from generation
// bseprocidl: type BseMidiChannelEvent excluded from generation
// bseprocidl: type BseNoteSeq excluded from generation
// bseprocidl: type BseItemSeq excluded from generation
// bseprocidl: type BsePropertyCandidates excluded from generation
// bseprocidl: type BsePartNote excluded from generation
// bseprocidl: type BsePartNoteSeq excluded from generation
// bseprocidl: type BsePartControl excluded from generation
// bseprocidl: type BsePartControlSeq excluded from generation
// bseprocidl: type BseNoteDescription excluded from generation
// bseprocidl: type BseNoteSequence excluded from generation
// bseprocidl: type BsePixelSeq excluded from generation
// bseprocidl: type BseIcon excluded from generation
// bseprocidl: type BseCategory excluded from generation
// bseprocidl: type BseCategorySeq excluded from generation
// bseprocidl: type BseDot excluded from generation
// bseprocidl: type BseDotSeq excluded from generation
// bseprocidl: type BsePartLink excluded from generation
// bseprocidl: type BsePartLinkSeq excluded from generation
// bseprocidl: type BseTrackPart excluded from generation
// bseprocidl: type BseTrackPartSeq excluded from generation
// bseprocidl: type BseSongTiming excluded from generation
// bseprocidl: type BseSampleFileInfo excluded from generation
// bseprocidl: type BseMsgType excluded from generation
// bseprocidl: type BseMessage excluded from generation
// bseprocidl: type BseThreadState excluded from generation
// bseprocidl: type BseThreadInfo excluded from generation
// bseprocidl: type BseThreadInfoSeq excluded from generation
// bseprocidl: type BseThreadTotals excluded from generation
// bseprocidl: type BseDefaultAuthor excluded from generation
// bseprocidl: type BseDefaultLicense excluded from generation
// bseprocidl: type BseUserDataPath excluded from generation
// bseprocidl: type BseDefaultSamplePath excluded from generation
// bseprocidl: type BseDefaultEffectsPath excluded from generation
// bseprocidl: type BseDefaultInstrumentsPath excluded from generation
// bseprocidl: type BseDefaultScriptsPath excluded from generation
// bseprocidl: type BseDefaultPluginsPath excluded from generation
// bseprocidl: type BseGConfig excluded from generation
// bseprocidl: type BseCxxBase excluded from generation
// bseprocidl: type BseEffect excluded from generation
// bseprocidl: type BseProbeFeatures excluded from generation
// bseprocidl: type BseProbe excluded from generation
// bseprocidl: type BseProbeSeq excluded from generation
// bseprocidl: type BseProbeRequest excluded from generation
// bseprocidl: type BseProbeRequestSeq excluded from generation
// bseprocidl: type BseSourceRequestProbes excluded from generation
// bseprocidl: type BseSourceMassRequest excluded from generation
// bseprocidl: type BseSourceGetTickStamp excluded from generation
// bseprocidl: type BseSourceGetMixFreq excluded from generation
// bseprocidl: type BseCollectThreadTotals excluded from generation
namespace Bse {
  enum BiquadFilterType {
    BIQUAD_FILTER_RESONANT_LOWPASS = Enum (1, "lowpass"),
    BIQUAD_FILTER_RESONANT_HIGHPASS = Enum (2, "highpass"),
  };

  enum RegistrationType {
    REGISTER_PLUGIN = Enum (1, "plugin"),
    REGISTER_SCRIPT = Enum (2, "script"),
    REGISTER_DONE = Enum (256, "done"),
  };

  enum ErrorType {
    ERROR_NONE = Enum (0, "none"),
    ERROR_INTERNAL = Enum (1, "internal"),
    ERROR_UNKNOWN = Enum (2, "unknown"),
    ERROR_IO = Enum (3, "io"),
    ERROR_PERMS = Enum (4, "perms"),
    ERROR_FILE_BUSY = Enum (5, "file-busy"),
    ERROR_FILE_EXISTS = Enum (6, "file-exists"),
    ERROR_FILE_EOF = Enum (7, "file-eof"),
    ERROR_FILE_EMPTY = Enum (8, "file-empty"),
    ERROR_FILE_NOT_FOUND = Enum (9, "file-not-found"),
    ERROR_FILE_IS_DIR = Enum (10, "file-is-dir"),
    ERROR_FILE_OPEN_FAILED = Enum (11, "file-open-failed"),
    ERROR_FILE_SEEK_FAILED = Enum (12, "file-seek-failed"),
    ERROR_FILE_READ_FAILED = Enum (13, "file-read-failed"),
    ERROR_FILE_WRITE_FAILED = Enum (14, "file-write-failed"),
    ERROR_MANY_FILES = Enum (15, "many-files"),
    ERROR_NO_FILES = Enum (16, "no-files"),
    ERROR_NO_SPACE = Enum (17, "no-space"),
    ERROR_NO_MEMORY = Enum (18, "no-memory"),
    ERROR_NO_HEADER = Enum (19, "no-header"),
    ERROR_NO_SEEK_INFO = Enum (20, "no-seek-info"),
    ERROR_NO_DATA = Enum (21, "no-data"),
    ERROR_DATA_CORRUPT = Enum (22, "data-corrupt"),
    ERROR_WRONG_N_CHANNELS = Enum (23, "wrong-n-channels"),
    ERROR_FORMAT_INVALID = Enum (24, "format-invalid"),
    ERROR_FORMAT_UNKNOWN = Enum (25, "format-unknown"),
    ERROR_DATA_UNMATCHED = Enum (26, "data-unmatched"),
    ERROR_TEMP = Enum (27, "temp"),
    ERROR_WAVE_NOT_FOUND = Enum (28, "wave-not-found"),
    ERROR_CODEC_FAILURE = Enum (29, "codec-failure"),
    ERROR_UNIMPLEMENTED = Enum (30, "unimplemented"),
    ERROR_INVALID_PROPERTY = Enum (31, "invalid-property"),
    ERROR_INVALID_MIDI_CONTROL = Enum (32, "invalid-midi-control"),
    ERROR_PARSE_ERROR = Enum (33, "parse-error"),
    ERROR_SPAWN = Enum (34, "spawn"),
    ERROR_DEVICE_NOT_AVAILABLE = Enum (35, "device-not-available"),
    ERROR_DEVICE_ASYNC = Enum (36, "device-async"),
    ERROR_DEVICE_BUSY = Enum (37, "device-busy"),
    ERROR_DEVICE_FORMAT = Enum (38, "device-format"),
    ERROR_DEVICE_BUFFER = Enum (39, "device-buffer"),
    ERROR_DEVICE_LATENCY = Enum (40, "device-latency"),
    ERROR_DEVICE_CHANNELS = Enum (41, "device-channels"),
    ERROR_DEVICE_FREQUENCY = Enum (42, "device-frequency"),
    ERROR_DEVICES_MISMATCH = Enum (43, "devices-mismatch"),
    ERROR_SOURCE_NO_SUCH_MODULE = Enum (44, "source-no-such-module"),
    ERROR_SOURCE_NO_SUCH_ICHANNEL = Enum (45, "source-no-such-ichannel"),
    ERROR_SOURCE_NO_SUCH_OCHANNEL = Enum (46, "source-no-such-ochannel"),
    ERROR_SOURCE_NO_SUCH_CONNECTION = Enum (47, "source-no-such-connection"),
    ERROR_SOURCE_PRIVATE_ICHANNEL = Enum (48, "source-private-ichannel"),
    ERROR_SOURCE_ICHANNEL_IN_USE = Enum (49, "source-ichannel-in-use"),
    ERROR_SOURCE_CHANNELS_CONNECTED = Enum (50, "source-channels-connected"),
    ERROR_SOURCE_CONNECTION_INVALID = Enum (51, "source-connection-invalid"),
    ERROR_SOURCE_PARENT_MISMATCH = Enum (52, "source-parent-mismatch"),
    ERROR_SOURCE_BAD_LOOPBACK = Enum (53, "source-bad-loopback"),
    ERROR_SOURCE_BUSY = Enum (54, "source-busy"),
    ERROR_SOURCE_TYPE_INVALID = Enum (55, "source-type-invalid"),
    ERROR_PROC_NOT_FOUND = Enum (56, "proc-not-found"),
    ERROR_PROC_BUSY = Enum (57, "proc-busy"),
    ERROR_PROC_PARAM_INVAL = Enum (58, "proc-param-inval"),
    ERROR_PROC_EXECUTION = Enum (59, "proc-execution"),
    ERROR_PROC_ABORT = Enum (60, "proc-abort"),
    ERROR_NO_ENTRY = Enum (61, "no-entry"),
    ERROR_NO_EVENT = Enum (62, "no-event"),
    ERROR_NO_TARGET = Enum (63, "no-target"),
    ERROR_NOT_OWNER = Enum (64, "not-owner"),
    ERROR_INVALID_OFFSET = Enum (65, "invalid-offset"),
    ERROR_INVALID_DURATION = Enum (66, "invalid-duration"),
    ERROR_INVALID_OVERLAP = Enum (67, "invalid-overlap"),
  };

  enum ProjectState {
    PROJECT_INACTIVE = Enum (0, "inactive"),
    PROJECT_ACTIVE = Enum (1, "active"),
    PROJECT_PLAYING = Enum (2, "playing"),
  };

  enum StandardOscWaveType {
    STANDARD_OSC_SINE = Enum (1, "Sine"),
    STANDARD_OSC_TRIANGLE = Enum (2, "Triangle"),
    STANDARD_OSC_SAW_RISE = Enum (3, "Rising Saw"),
    STANDARD_OSC_SAW_FALL = Enum (4, "Falling Saw"),
    STANDARD_OSC_PEAK_RISE = Enum (5, "Rising Peak"),
    STANDARD_OSC_PEAK_FALL = Enum (6, "Falling Peak"),
    STANDARD_OSC_MOOG_SAW = Enum (7, "Moog Saw"),
    STANDARD_OSC_SQUARE = Enum (8, "Square"),
    STANDARD_OSC_PULSE = Enum (9, "Pulse"),
  };

  interface Bus;
  interface CSynth;
  interface DataPocket;
  interface EditableSample;
  interface Janitor;
  interface MidiNotifier;
  interface MidiSynth;
  interface Part;
  interface Project;
  interface Song;
  interface Source;
  interface Track;
  interface Wave;
  interface WaveRepo;
  interface Item {
    void add_parasite (String path, Rec parasite) {
      Info help = "Add a new parasite to an item.";
      In  path                = ("Path", "", ":flagstodo");
      In  parasite            = ("Parasite", "", ":flagstodo");
    }
    Bool check_is_a (String type_name) {
      Info help = "Check whether an item has a certain type.";
      In  type_name           = ("Type Name", "", ":flagstodo");
      Out is_a                = ("is-a", "", FALSE, ":flagstodo");
    }
    void clear_undo () {
      Info help = "Call the clear-undo function of the project corresponding to this item if any.";
    }
    Item common_ancestor (Item item2) {
      Info help = "Retrieve the common ancestor of two items if there's any.";
      In  item2               = ("Item2", "Second item", ":flagstodo");
      Out ancestor            = ("ancestor", "Common ancestor of both items", ":flagstodo");
    }
    Bool editable_property (String property_name) {
      Info help = "Test whether a property is editable according to object state and property options.";
      In  property_name       = ("property-name", "Item property name", ":flagstodo");
      Out editable            = ("editable", "", FALSE, ":flagstodo");
    }
    Icon get_icon () {
      Info help = "Get the current icon of an item.";
      Out icon                = ("icon", "", ":flagstodo");
    }
    String get_name () {
      Info help = "Retrieve an item's name.";
      Out name                = ("Name", "", ":flagstodo");
    }
    String get_name_or_type () {
      Info help = "Retrieve an item's name or type if it has no name.";
      Out name                = ("Name", "", ":flagstodo");
    }
    Rec get_parasite (String path) {
      Info help = "Retrieve a parasite from an item.";
      In  path                = ("Path", "", ":flagstodo");
      Out parasite            = ("Parasite", "", ":flagstodo");
    }
    Item get_parent () {
      Info help = "Retrieve an item's parent.";
      Out parent              = ("Parent", "", ":flagstodo");
    }
    Item get_project () {
      Info help = "Retrieve an item's project.";
      Out project             = ("Project", "", ":flagstodo");
    }
    PropertyCandidates get_property_candidates (String property_name) {
      Info help = "Retrieve tentative values for an item or item sequence property.";
      In  property_name       = ("property-name", "Item property name", ":flagstodo");
      Out candidates          = ("Candidates", "", ":flagstodo");
    }
    Int get_seqid () {
      Info help = "Retrieve an item's sequential ID. The sequential ID depends on the item's type an it's position inbetween siblings of the same type within it's immediate container.";
      Out seq_id              = ("Sequential ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    String get_type () {
      Info help = "Retrieve an item's type name.";
      Out string              = ("string", "", ":flagstodo");
    }
    String get_type_authors () {
      Info help = "Retrieve authors of an item's type implementation.";
      Out string              = ("string", "", ":flagstodo");
    }
    String get_type_blurb () {
      Info help = "Retrieve an item's type description.";
      Out string              = ("string", "", ":flagstodo");
    }
    String get_type_license () {
      Info help = "Retrieve the license for an item's type implementation.";
      Out string              = ("string", "", ":flagstodo");
    }
    String get_type_name () {
      Info help = "Retrieve an item's type name.";
      Out string              = ("string", "", ":flagstodo");
    }
    String get_uname_path () {
      Info help = "Retrieve the project relative uname path for this item.";
      Out uname_path          = ("uname-path", "", ":flagstodo");
    }
    void group_undo (String name) {
      Info help = "Request multiple modifying actions on an item to be grouped together as single undo operation.";
      In  name                = ("name", "A name for the undo group to be created", ":flagstodo");
    }
    Bool internal () {
      Info help = "Check whether an item is internal, i.e. owned by another non-internal item.";
      Out internal            = ("Internal", "", FALSE, ":flagstodo");
    }
    StringSeq list_parasites (String path) {
      Info help = "List parasites within a parasite path segment.";
      In  path                = ("Path", "", ":flagstodo");
      Out paths               = ("Parasite Paths", "", ":flagstodo");
    }
    void redo () {
      Info help = "Call the redo function of the project corresponding to this item if any.";
    }
    Int redo_depth () {
      Info help = "Call the redo-depth function of the project corresponding to this item if any.";
      Out redo_depth          = ("redo-depth", "Number of times redo can be called", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    void set_name (String name) {
      Info help = "Set an item's name.";
      In  name                = ("Name", "", ":flagstodo");
    }
    void set_parasite (String path, Rec parasite) {
      Info help = "Set or change a parasite on an item.";
      In  path                = ("Path", "", ":flagstodo");
      In  parasite            = ("Parasite", "", ":flagstodo");
    }
    void undo () {
      Info help = "Call the undo function of the project corresponding to this item if any.";
    }
    Int undo_depth () {
      Info help = "Call the undo-depth function of the project corresponding to this item if any.";
      Out undo_depth          = ("undo-depth", "Number of times undo can be called", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    void ungroup_undo () {
      Info help = "Ends the undo grouping opened up by a previous group-undo() call.";
    }
    void unuse () {
      Info help = "Decrement use count for when an item is not needed anymore.";
    }
    Item use () {
      Info help = "Increment use count to keep an item alive.";
      Out used_item           = ("Item", "", ":flagstodo");
    }
    signal parasites_added (String a);
    signal parasite_changed (String a);
    property Int seqid               = ("Sequential ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
  };

  interface PcmWriter : Item {
  };

  interface Source : Item {
    void clear_inputs () {
      Info help = "Disconnect all module inputs.";
    }
    void clear_outputs () {
      Info help = "Disconnect all module outputs.";
    }
    Int get_automation_channel (String property_name) {
      Info help = "Get MIDI channel from an automation property.";
      In  property_name       = ("property-name", "Item property name", ":flagstodo");
      Out midi_channel        = ("midi-channel", "", 0, 0, 99, 1, ":flagstodo");
    }
    MidiControlType get_automation_control (String property_name) {
      Info help = "Get control type from an automation property.";
      In  property_name       = ("property-name", "Item property name", ":flagstodo");
      Out control_type        = ("control-type", "", ":flagstodo");
    }
    Bool has_output (Int ochannel) {
      Info help = "Check whether a module's output channel is connected.";
      In  ochannel            = ("ochannel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out has_outputs         = ("has-outputs", "", FALSE, ":flagstodo");
    }
    Bool has_outputs () {
      Info help = "Check whether a module has output channel connections.";
      Out has_outputs         = ("Has Outputs", "", FALSE, ":flagstodo");
    }
    String ichannel_blurb (Int input_channel) {
      Info help = "Get input channel description.";
      In  input_channel       = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out channel_blurb       = ("Channel Blurb", "", ":flagstodo");
    }
    Int ichannel_get_n_joints (Int input_channel) {
      Info help = "Retrieve the number of inputs connected to an input channel.";
      In  input_channel       = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out n_joints            = ("Number of Connections", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    Int ichannel_get_ochannel (Int input_channel, Int input_joint) {
      Info help = "Retrieve output channel of the module connected to a specific joint of an input channel.";
      In  input_channel       = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      In  input_joint         = ("Input Joint", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out ochannel            = ("Output Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    Source ichannel_get_osource (Int input_channel, Int input_joint) {
      Info help = "Retrieve output module connected to a specific joint of an input channel";
      In  input_channel       = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      In  input_joint         = ("Input Joint", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out osource             = ("Output Source", "", ":flagstodo");
    }
    String ichannel_ident (Int input_channel) {
      Info help = "Get canonical input channel name.";
      In  input_channel       = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out channel_ident       = ("Channel Name", "", ":flagstodo");
    }
    String ichannel_label (Int input_channel) {
      Info help = "Get input channel name.";
      In  input_channel       = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out channel_label       = ("Channel Name", "", ":flagstodo");
    }
    Bool is_joint_ichannel (String input_channel) {
      Info help = "Check if an input channel is a joint (multi-connect) channel.";
      In  input_channel       = ("Input Channel", "", ":flagstodo");
      Out is_jchannel         = ("Is Joint Channel", "", FALSE, ":flagstodo");
    }
    Bool is_joint_ichannel_by_id (Int input_channel) {
      Info help = "Check if an input channel is a joint (multi-connect) channel.";
      In  input_channel       = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out is_jchannel         = ("Is Joint Channel", "", FALSE, ":flagstodo");
    }
    Bool is_prepared () {
      Info help = "Check whether a source is prepared for synthesis processing.";
      Out is_prepared         = ("is-prepared", "", FALSE, ":flagstodo");
    }
    Int n_ichannels () {
      Info help = "Get the number of input channels of a module.";
      Out n_channels          = ("Number of Channels", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    Int n_ochannels () {
      Info help = "Get the number of output channels of a module.";
      Out n_channels          = ("Number of Channels", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    String ochannel_blurb (Int output_channel) {
      Info help = "Get output channel description.";
      In  output_channel      = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out channel_blurb       = ("Channel Blurb", "", ":flagstodo");
    }
    String ochannel_ident (Int output_channel) {
      Info help = "Get canonical output channel name.";
      In  output_channel      = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out channel_ident       = ("Channel Name", "", ":flagstodo");
    }
    String ochannel_label (Int output_channel) {
      Info help = "Get output channel name.";
      In  output_channel      = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out channel_label       = ("Channel Name", "", ":flagstodo");
    }
    ErrorType set_automation (String property_name, Int midi_channel, MidiControlType control_type) {
      Info help = "Setup automation parameters for a property.";
      In  property_name       = ("property-name", "Item property name", ":flagstodo");
      In  midi_channel        = ("MIDI Channel", "The MIDI Channel from which automation events should be received, 0 designates the default MIDI channel", 0, 0, 99, 1, ":flagstodo");
      In  control_type        = ("Control Type", "The type of control events used for automation", ":flagstodo");
      Out error               = ("Error", "", ":flagstodo");
    }
    ErrorType set_input (String input_channel, Source omodule, String output_channel) {
      Info help = "Connect a module input to another module's output.";
      In  input_channel       = ("Input Channel", "", ":flagstodo");
      In  omodule             = ("Output Module", "", ":flagstodo");
      In  output_channel      = ("Output Channel", "", ":flagstodo");
      Out error               = ("Error", "", ":flagstodo");
    }
    ErrorType set_input_by_id (Int input_channel, Source omodule, Int output_channel) {
      Info help = "Connect a module input to another module's output.";
      In  input_channel       = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      In  omodule             = ("Output Module", "", ":flagstodo");
      In  output_channel      = ("Output Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out error               = ("Error", "", ":flagstodo");
    }
    void set_pos (Real x_pos, Real y_pos) {
      Info help = "Set the x and y position of a module. In contrast to setting the position through ordinary object property setters, this function will not update the module position if the passed in arguments are sufficiently equal to the values already set on the object. As such, it does not record an extra undo step for setting properties to values they already have and if necessary turns setting of x and y positions into an atomic undo operation.";
      In  x_pos               = ("X Position", "", ":flagstodo");
      In  y_pos               = ("Y Position", "", ":flagstodo");
    }
    ErrorType unset_input (String input_channel, Source omodule, String output_channel) {
      Info help = "Disconnect a module input.";
      In  input_channel       = ("Input Channel", "", ":flagstodo");
      In  omodule             = ("Output Module", "", ":flagstodo");
      In  output_channel      = ("Output Channel", "", ":flagstodo");
      Out error               = ("Error", "", ":flagstodo");
    }
    ErrorType unset_input_by_id (Int input_channel, Source omodule, Int output_channel) {
      Info help = "Disconnect a module input.";
      In  input_channel       = ("Input Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      In  omodule             = ("Output Module", "", ":flagstodo");
      In  output_channel      = ("Output Channel", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out error               = ("Error", "", ":flagstodo");
    }
    signal probes (ProbeSeq a);
    signal io_changed ();
    property Real pos_x               = ("Position X", "", ":flagstodo");
    property Real pos_y               = ("Position Y", "", ":flagstodo");
  };

  interface Snooper : Source {
    property Int context_id          = ("Context", "If the snooper module is created multiple times, this is the context id, which is used to actually snoop data.", 0, 0, 65535, 1, ":flagstodo");
  };

  interface Constant : Source {
    property Real value_1             = ("Value [float]", "Constant signal value", ":flagstodo");
    property Real frequency_1         = ("Frequency", "Constant signal value interpreted as frequency value in Hertz", ":flagstodo");
    property Int note_1              = ("Note", "Constant signal value as note, converted to Hertz according to the current musical tuning", 69, 0, 131, 12, ":flagstodo");
    property Real value_2             = ("Value [float]", "Constant signal value", ":flagstodo");
    property Real frequency_2         = ("Frequency", "Constant signal value interpreted as frequency value in Hertz", ":flagstodo");
    property Int note_2              = ("Note", "Constant signal value as note, converted to Hertz according to the current musical tuning", 69, 0, 131, 12, ":flagstodo");
    property Real value_3             = ("Value [float]", "Constant signal value", ":flagstodo");
    property Real frequency_3         = ("Frequency", "Constant signal value interpreted as frequency value in Hertz", ":flagstodo");
    property Int note_3              = ("Note", "Constant signal value as note, converted to Hertz according to the current musical tuning", 69, 0, 131, 12, ":flagstodo");
    property Real value_4             = ("Value [float]", "Constant signal value", ":flagstodo");
    property Real frequency_4         = ("Frequency", "Constant signal value interpreted as frequency value in Hertz", ":flagstodo");
    property Int note_4              = ("Note", "Constant signal value as note, converted to Hertz according to the current musical tuning", 69, 0, 131, 12, ":flagstodo");
  };

  interface Container : Source {
    Item get_item (String item_type, Int seq_id) {
      Info help = "Retrieve a containers immediate child from it's sequential id.";
      In  item_type           = ("item-type", "Type of the item to retrieve", ":flagstodo");
      In  seq_id              = ("seq-id", "Sequential ID", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out item                = ("item", "The item with seqid as requested", ":flagstodo");
    }
    ItemSeq list_children () {
      Info help = "Retrieve all immediate children of a container";
      Out item_list           = ("item-list", "", ":flagstodo");
    }
    Item lookup_item (String uname) {
      Info help = "Find an immediate child of a container from its uname (the uname is the name of the item, unique between all immediate children of a container).";
      In  uname               = ("UName", "Unique item name", ":flagstodo");
      Out item                = ("Item", "The item named by uname", ":flagstodo");
    }
    signal item_added (Item a);
    signal item_remove (Item a, Int b);
  };

  interface Super : Container {
    property String author              = ("Author", "Person changing or creating this object", ":flagstodo");
    property String license             = ("License", "Copyright license applying to this object", ":flagstodo");
    property String copyright           = ("copyright", "", ":flagstodo");
    property Num creation_time       = ("Creation Time", "", ":flagstodo");
    property Num modification_time   = ("Last modification time", "", ":flagstodo");
  };

  interface WaveRepo : Super {
    ErrorType load_file (String file_name) {
      Info help = "Load wave from file";
      In  file_name           = ("File Name", "The file to import waves from", ":flagstodo");
      Out error               = ("Error", "", ":flagstodo");
    }
    void remove_wave (Wave wave) {
      Info help = "Remove a wave from repository";
      In  wave                = ("Wave", "", ":flagstodo");
    }
  };

  interface SNet : Super {
    ErrorType can_create_source (String module_type) {
      Info help = "Check whether inserting a new module into a synthesis network is possible";
      In  module_type         = ("Module Type", "", ":flagstodo");
      Out error               = ("Error", "", ":flagstodo");
    }
    Source create_source (String module_type) {
      Info help = "Insert a new module into a synthesis network";
      In  module_type         = ("Module Type", "", ":flagstodo");
      Out module              = ("New Module", "", ":flagstodo");
    }
    ErrorType remove_source (Source module) {
      Info help = "Remove an existing module from its synthesis network";
      In  module              = ("Module", "", ":flagstodo");
      Out error               = ("Error", "", ":flagstodo");
    }
    Bool supports_user_synths () {
      Info help = "Check whether users may edit synthesis modules of this network";
      Out user_synth          = ("User Synth", "", FALSE, ":flagstodo");
    }
    signal port_unregistered ();
    property Bool auto_activate       = ("Auto Activate", "Automatic activation only needs to be enabled for synthesis networks that don't use virtual ports for their input and output", FALSE, ":flagstodo");
  };

  interface MidiSynth : SNet {
    property Int midi_channel        = ("MIDI Channel", "", 1, 1, 99, 1, ":flagstodo");
    property Int n_voices            = ("Max Voices", "Maximum number of voices for simultaneous playback", 16, 1, 256, 1, ":flagstodo");
    property CSynth snet                = ("Synthesizer", "Synthesis network to be used as MIDI instrument", ":flagstodo");
    property CSynth pnet                = ("Postprocessor", "Synthesis network to be used as postprocessor", ":flagstodo");
    property Real volume_f            = ("Master [float]", "", ":flagstodo");
    property Real volume_dB           = ("Master [dB]", "", ":flagstodo");
    property Int volume_perc         = ("Master [%]", "", 100, 0, 1584, 1, ":flagstodo");
    property Bool auto_activate       = ("auto-activate", "", TRUE, ":flagstodo");
  };

  interface CSynth : SNet {
  };

  interface Song : SNet {
    Bus create_bus () {
      Info help = "Create a new mixer bus for a Song.";
      Out bus                 = ("bus", "", ":flagstodo");
    }
    Part create_part () {
      Info help = "Create a new Part in a Song.";
      Out part                = ("part", "", ":flagstodo");
    }
    Track create_track () {
      Info help = "Create a new Track for a Song.";
      Out track               = ("Track", "", ":flagstodo");
    }
    Bus ensure_master_bus () {
      Info help = "Retrieve master output bus of a song, will create one if it doesn't exist.";
      Out bus                 = ("bus", "", ":flagstodo");
    }
    void ensure_track_links () {
      Info help = "Ensure that each part in a song is inserted into at least one track.";
    }
    Track find_any_track_for_part (Part part) {
      Info help = "Find the first track that contains part, suitable to check for orphan parts.";
      In  part                = ("Part", "", ":flagstodo");
      Out track               = ("Track", "", ":flagstodo");
    }
    Track find_track_for_part (Part part) {
      Info help = "Find a track suitable for playing notes of a given part.";
      In  part                = ("Part", "", ":flagstodo");
      Out track               = ("Track", "", ":flagstodo");
    }
    Bus get_master_bus () {
      Info help = "Retrieve master output bus of a song if it exists.";
      Out bus                 = ("bus", "", ":flagstodo");
    }
    SongTiming get_timing (Int tick) {
      Info help = "Retrieve song timing information at a specific tick.";
      In  tick                = ("Tick", "Tick to retrieve timing info about", 0, 0, SFI_MAXINT, 384, ":flagstodo");
      Out timing              = ("Timing", "Song Timing", ":flagstodo");
    }
    void remove_bus (Bus bus) {
      Info help = "Delete a mixer bus from a Song.";
      In  bus                 = ("bus", "", ":flagstodo");
    }
    void remove_part (Part part) {
      Info help = "Delete a Part from a Song.";
      In  part                = ("Part", "", ":flagstodo");
    }
    void remove_track (Track track) {
      Info help = "Delete a Track from a Song.";
      In  track               = ("Track", "", ":flagstodo");
    }
    void synthesize_note (Track track, Int duration, Int note, Int fine_tune, Real velocity) {
      Info help = "Synthesize a note on a song of an active project.";
      In  track               = ("Track", "", ":flagstodo");
      In  duration            = ("Tick Duration", "", 1, 1, SFI_MAXINT, 384, ":flagstodo");
      In  note                = ("Note", "", 69, 0, 131, 12, ":flagstodo");
      In  fine_tune           = ("Fine Tune", "Fine tune in cents per semitone", 0, -100, 100, 10, ":flagstodo");
      In  velocity            = ("Velocity", "", ":flagstodo");
    }
    signal pointer_changed (Int a);
    property MusicalTuningType musical_tuning      = ("Musical Tuning", "The tuning system which specifies the tones or pitches to be used. Due to the psychoacoustic properties of tones, various pitch combinations can sound "natural" or "pleasing" when used in combination, the musical tuning system defines the number and spacing of frequency values applied.", ":flagstodo");
    property Int tpqn                = ("Ticks", "Number of ticks per quarter note", 384, 384, 384, 0, ":flagstodo");
    property Int numerator           = ("Numerator", "Measure numerator", 4, 1, 256, 1, ":flagstodo");
    property Int denominator         = ("Denominator", "Measure denominator, must be a power of 2", 4, 1, 256, 0, ":flagstodo");
    property Real bpm                 = ("Beats per minute", "", ":flagstodo");
    property CSynth pnet                = ("Postprocessor", "Synthesis network to be used as postprocessor", ":flagstodo");
    property Bool auto_activate       = ("auto-activate", "", TRUE, ":flagstodo");
    property Bool loop_enabled        = ("loop-enabled", "", FALSE, ":flagstodo");
    property Int loop_left           = ("loop-left", "", -1, -1, SFI_MAXINT, 384, ":flagstodo");
    property Int loop_right          = ("loop-right", "", -1, -1, SFI_MAXINT, 384, ":flagstodo");
    property Int tick_pointer        = ("tick-pointer", "", -1, -1, SFI_MAXINT, 384, ":flagstodo");
  };

  interface Project : Container {
    ErrorType import_midi_file (String file_name) {
      Info help = "Import a song from a MIDI file.";
      In  file_name           = ("MIDI File", "MIDI file name", ":flagstodo");
      Out error               = ("Error", "Error indicating possible failures", ":flagstodo");
    }
    ErrorType restore_from_file (String file_name) {
      Info help = "Load a project from file";
      In  file_name           = ("File", "Source file name", ":flagstodo");
      Out error               = ("Error", "Error indicating possible failures", ":flagstodo");
    }
    ErrorType store_bse (Super super, String file_name, Bool self_contained) {
      Info help = "Save supers of a project into a BSE file. If no super is specified, the project itself is stored.";
      In  super               = ("Super", "", ":flagstodo");
      In  file_name           = ("File", "Destination file name", ":flagstodo");
      In  self_contained      = ("Self Contained", "Whether references to other objects (e.g. samples) should be stored or whether to include everything in a self-contained .bse file", FALSE, ":flagstodo");
      Out error               = ("Error", "Error indicating possible failures", ":flagstodo");
    }
    ErrorType activate () {
      Info help = "Activate a project, precondition to start playback.";
      Out error               = ("Error", "", ":flagstodo");
    }
    void auto_deactivate (Int msec_delay) {
      Info help = "Automatically deactivate a project once playback stopped.";
      In  msec_delay          = ("msec-delay", "Delay for deactivation in milliseconds", 0, -1, SFI_MAXINT, 1000, ":flagstodo");
    }
    Bool can_play () {
      Info help = "Check whether project playback would makes sense.";
      Out can_play            = ("Can Play", "Whether project playback makes sense", FALSE, ":flagstodo");
    }
    void change_name (String name) {
      Info help = "Change a project name without recording undo steps.";
      In  name                = ("name", "", ":flagstodo");
    }
    void clean_dirty () {
      Info help = "Clear a projects dirty flags.";
    }
    void clear_undo () {
      Info help = "Delete all recorded undo or redo steps.";
    }
    CSynth create_csynth (String name) {
      Info help = "Create a synthsizer network for this project.";
      In  name                = ("Name", "Synth network name", ":flagstodo");
      Out csynth              = ("Synthesizer Network", "New synth network", ":flagstodo");
    }
    MidiSynth create_midi_synth (String name) {
      Info help = "Create a MIDI synthesizer network for this project.";
      In  name                = ("Name", "MIDI synth name", ":flagstodo");
      Out midi_synth          = ("MIDI Synthesizer", "New MIDI synth", ":flagstodo");
    }
    Song create_song (String name) {
      Info help = "Create a song for this project.";
      In  name                = ("Name", "Song name", ":flagstodo");
      Out song                = ("Song", "The new song", ":flagstodo");
    }
    void deactivate () {
      Info help = "Deactivate the project, automatically stop playback.";
    }
    Item find_item (String uname_path) {
      Info help = "Find an item within a project, given its uname path.";
      In  uname_path          = ("uname-path", "", ":flagstodo");
      Out item                = ("item", "", ":flagstodo");
    }
    DataPocket get_data_pocket (String name) {
      Info help = "Retrieve a specifically named data pocket for this project";
      In  name                = ("Name", "Name of the data pocket", ":flagstodo");
      Out data_pocket         = ("Data Pocket", "The data pocket", ":flagstodo");
    }
    MidiNotifier get_midi_notifier () {
      Info help = "Retrieve the project's midi notifier object.";
      Out midi_notifier       = ("midi-notifier", "", ":flagstodo");
    }
    ProjectState get_state () {
      Info help = "Retrieve the current project state.";
      Out state               = ("State", "Project playback/activation state", ":flagstodo");
    }
    ItemSeq get_supers () {
      Info help = "Retrieve all supers of this project.";
      Out super_list          = ("super-list", "", ":flagstodo");
    }
    WaveRepo get_wave_repo () {
      Info help = "Ensure the project has a wave repository";
      Out wrepo               = ("Wave Repo", "The project's unique wave repo", ":flagstodo");
    }
    void inject_midi_control (Int midi_channel, Int midi_control, Real control_value) {
      Info help = "Inject a MIDI control event into the project's MIDI receiver.";
      In  midi_channel        = ("midi-channel", "", 1, 1, 99, 1, ":flagstodo");
      In  midi_control        = ("midi-control", "", 7, 0, 127, 1, ":flagstodo");
      In  control_value       = ("control-value", "", ":flagstodo");
    }
    Bool is_active () {
      Info help = "Check whether a project is active";
      Out is_active           = ("is-active", "Whether the project is currently producing sound", FALSE, ":flagstodo");
    }
    Bool is_dirty () {
      Info help = "Check whether a project is dirty (needs saving).";
      Out dirty               = ("dirty", "", TRUE, ":flagstodo");
    }
    Bool is_playing () {
      Info help = "Check whether a project is currently playing";
      Out is_playing          = ("Is Playing", "Whether the project is currently playing songs or synths", FALSE, ":flagstodo");
    }
    StringSeq list_uname_paths (String item_type) {
      Info help = "List uname paths for all items of a specified type within this project. By their uname paths, items are uniquely identifyable within a project.";
      In  item_type           = ("item-type", "", ":flagstodo");
      Out uname_paths         = ("Uname Paths", "", ":flagstodo");
    }
    ItemSeq match_items_by_uname (String item_type, String uname) {
      Info help = "Retrieve all items of a specific type within a project with matching uname";
      In  item_type           = ("item-type", "", ":flagstodo");
      In  uname               = ("uname", "", ":flagstodo");
      Out item_list           = ("Item List", "", ":flagstodo");
    }
    ErrorType play () {
      Info help = "Activate a project and start project playback (and already playing project is first halted).";
      Out error               = ("Error", "", ":flagstodo");
    }
    void redo () {
      Info help = "Redo a previously undone operaiton in a project";
    }
    Int redo_depth () {
      Info help = "Check whether a project can perform redo steps";
      Out redo_depth          = ("redo-depth", "Number of times redo can be called on the project", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    void remove_snet (SNet snet) {
      Info help = "Remove an existing synthesizer network from this project.";
      In  snet                = ("SNet", "Synthesizer Network", ":flagstodo");
    }
    void start_playback () {
      Info help = "Start playback in an activated project.";
    }
    void stop () {
      Info help = "Stop project playback and deactivate project.";
    }
    void stop_playback () {
      Info help = "Stop project playback.";
    }
    void undo () {
      Info help = "Undo a previous operation in a project";
    }
    Int undo_depth () {
      Info help = "Check whether a project can perform undo steps";
      Out undo_depth          = ("undo-depth", "Number of times undo can be called on the project", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    signal state_changed (ProjectState a);
    property Bool dirty               = ("dirty", "Whether project needs saving", FALSE, ":flagstodo");
  };

  interface Server : Container {
    Bool can_load (String file_name) {
      Info help = "Check whether a loader can be found for a wave file";
      In  file_name           = ("File Name", "The file to find a loader for", ":flagstodo");
      Out can_load            = ("can-load", "", FALSE, ":flagstodo");
    }
    String get_custom_effect_dir () {
      Info help = "Retrieve user specific effects directory.";
      Out directory           = ("directory", "", ":flagstodo");
    }
    String get_custom_instrument_dir () {
      Info help = "Retrieve user specific instruments directory.";
      Out directory           = ("directory", "", ":flagstodo");
    }
    String get_demo_path () {
      Info help = "Retrieve demo search path.";
      Out path                = ("path", "", ":flagstodo");
    }
    String get_effect_path () {
      Info help = "Retrieve effect search path.";
      Out path                = ("path", "", ":flagstodo");
    }
    String get_instrument_path () {
      Info help = "Retrieve instrument search path.";
      Out path                = ("path", "", ":flagstodo");
    }
    String get_ladspa_path () {
      Info help = "Retrieve ladspa search path.";
      Out path                = ("path", "", ":flagstodo");
    }
    String get_mp3_version () {
      Info help = "Retrieve BSE MP3 handler version.";
      Out version             = ("version", "", ":flagstodo");
    }
    String get_plugin_path () {
      Info help = "Retrieve plugin search path.";
      Out path                = ("path", "", ":flagstodo");
    }
    String get_sample_path () {
      Info help = "Retrieve sample search path.";
      Out path                = ("path", "", ":flagstodo");
    }
    String get_script_path () {
      Info help = "Retrieve script search path.";
      Out path                = ("path", "", ":flagstodo");
    }
    String get_version () {
      Info help = "Retrieve BSE version.";
      Out version             = ("version", "", ":flagstodo");
    }
    String get_vorbis_version () {
      Info help = "Retrieve BSE Vorbis handler version.";
      Out version             = ("version", "", ":flagstodo");
    }
    Int n_scripts () {
      Info help = "Return the number of scripts currently running on this server.";
      Out n_connections       = ("n-connections", "Number of Connections", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    Bool preferences_locked () {
      Info help = "Returns whether the bse-preferences property is currently locked against modifications or not.";
      Out locked              = ("locked", "", FALSE, ":flagstodo");
    }
    void register_core_plugins () {
      Info help = "Register core plugins.";
    }
    void register_ladspa_plugins () {
      Info help = "Register LADSPA (Linux Audio Developer's Simple Plugin API) plugins.";
    }
    void register_scripts () {
      Info help = "Register external scripts.";
    }
    void save_preferences () {
      Info help = "Request the bse-preferences property to be saved into BSE's configuration file.";
    }
    void start_recording (String wave_file, Real n_seconds) {
      Info help = "Start recording to a WAV file.";
      In  wave_file           = ("wave-file", "", ":flagstodo");
      In  n_seconds           = ("n-seconds", "Maximum number of recorded seconds", ":flagstodo");
    }
    Project use_new_project (String name) {
      Info help = "Create a new project, owned by the caller (name is modified to be unique if necessary)";
      In  name                = ("Project Name", "", ":flagstodo");
      Out project             = ("Project", "", ":flagstodo");
    }
    signal registration (RegistrationType a, String b, String c);
    signal message (Message a);
    signal script_start (Janitor a);
    signal script_error (String a, String b, String c);
    property Rec bse_preferences     = ("bse-preferences", "", ":flagstodo");
    property String wave_file           = ("WAVE File", "Name of the WAVE file used for recording BSE sound output", ":flagstodo");
    property Bool log_messages        = ("Log Messages", "Log messages through the log system", TRUE, ":flagstodo");
  };

  interface SubIPort : Source {
    property String in_port_1           = ("Input Port 1", "The port name is a unique name to establish input<->output port relationships", ":flagstodo");
    property String in_port_2           = ("Input Port 2", "The port name is a unique name to establish input<->output port relationships", ":flagstodo");
    property String in_port_3           = ("Input Port 3", "The port name is a unique name to establish input<->output port relationships", ":flagstodo");
    property String in_port_4           = ("Input Port 4", "The port name is a unique name to establish input<->output port relationships", ":flagstodo");
  };

  interface InstrumentInput : SubIPort {
    property String in_port_1           = ("in-port-1", "", ":flagstodo");
    property String in_port_2           = ("in-port-2", "", ":flagstodo");
    property String in_port_3           = ("in-port-3", "", ":flagstodo");
    property String in_port_4           = ("in-port-4", "", ":flagstodo");
  };

  interface WaveOsc : Source {
    void request_pcm_position () {
      Info help = "Request emission of the ::notify_pcm_position signal.";
    }
    void set_from_editable_sample (EditableSample esample) {
      Info help = "Set wave to play from editable sample, bypassing undo and storage mechanisms.";
      In  esample             = ("esample", "Editable Sample", ":flagstodo");
    }
    signal notify_pcm_position (Num a, Int b);
    property Wave wave                = ("Wave", "Wave used as oscillator source", ":flagstodo");
    property Int channel             = ("Channel", "The audio channel to play, usually 1 is left, 2 is right", 1, 1, 256, 2, ":flagstodo");
    property Real fm_perc             = ("Input Modulation [%]", "Modulation Strength for linear frequency modulation", ":flagstodo");
    property Bool exponential_fm      = ("Exponential FM", "Perform exponential frequency modulation instead of linear", FALSE, ":flagstodo");
    property Real fm_n_octaves        = ("Octaves", "Number of octaves to be affected by exponential frequency modulation", ":flagstodo");
  };

  interface MidiVoiceInput : Source {
  };

  interface ContextMerger : Source {
  };

  interface Track : ContextMerger {
    ErrorType ensure_output () {
      Info help = "Ensure the track has an output connection to a bus.";
      Out error               = ("error", "", ":flagstodo");
    }
    Int get_last_tick () {
      Info help = "Retrieve the last tick for this track.";
      Out last_tick           = ("Last Tick", "", 0, 0, SFI_MAXINT, 384, ":flagstodo");
    }
    Source get_output_source () {
      Info help = "Get the output module for this track. The output of this module is the merged result from all polyphonic voices and has all track specific alterations applied.";
      Out source              = ("source", "", ":flagstodo");
    }
    Part get_part (Int tick) {
      Info help = "Get the part starting at a specific tick position.";
      In  tick                = ("Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      Out part                = ("Part", "", ":flagstodo");
    }
    SongTiming get_timing (Int tick) {
      Info help = "Retrieve song timing information at a specific tick.";
      In  tick                = ("Tick", "Tick to retrieve timing info about", 0, 0, SFI_MAXINT, 384, ":flagstodo");
      Out timing              = ("Timing", "Song Timing", ":flagstodo");
    }
    Int insert_part (Int tick, Part part) {
      Info help = "Insert a part into a track and retrieve the corresponding link id.";
      In  tick                = ("Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  part                = ("Part", "", ":flagstodo");
      Out id                  = ("Link ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    TrackPartSeq list_parts () {
      Info help = "List parts scheduled in a track, sorted by tick.";
      Out part_list           = ("Part List", "", ":flagstodo");
    }
    ItemSeq list_parts_uniq () {
      Info help = "List all parts contained in a track.";
      Out part_list           = ("Part List", "", ":flagstodo");
    }
    void remove_link (Int id) {
      Info help = "Remove a specific part link by ID from a track.";
      In  id                  = ("Link ID", "", 0, 0, SFI_MAXINT, 384, ":flagstodo");
    }
    void remove_tick (Int tick) {
      Info help = "Remove a part at specified tick from a track.";
      In  tick                = ("Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
    }
    signal changed ();
    property Bool muted               = ("Muted", "", FALSE, ":flagstodo");
    property CSynth snet                = ("Synthesizer", "Synthesis network to be used as instrument", ":flagstodo");
    property Wave wave                = ("Wave", "Wave to be used as instrument", ":flagstodo");
    property Int midi_channel        = ("MIDI Channel", "Midi channel assigned to this track, 0 uses internal per-track channel", 0, 0, 99, 1, ":flagstodo");
    property Int n_voices            = ("Max Voices", "Maximum number of voices for simultaneous playback", 16, 1, 256, 1, ":flagstodo");
    property CSynth pnet                = ("Postprocessor", "Synthesis network to be used as postprocessor", ":flagstodo");
    property ItemSeq outputs             = ("Output Signals", "Mixer busses used as output for this track", ":flagstodo");
  };

  interface MidiController : Source {
    property Int midi_channel        = ("MIDI Channel", "Input MIDI channel, 0 uses network's default channel", 0, 0, 99, 1, ":flagstodo");
    property MidiSignalType control_1           = ("Signal 1", "", ":flagstodo");
    property MidiSignalType control_2           = ("Signal 2", "", ":flagstodo");
    property MidiSignalType control_3           = ("Signal 3", "", ":flagstodo");
    property MidiSignalType control_4           = ("Signal 4", "", ":flagstodo");
  };

  interface BiquadFilter : Source {
    property BiquadFilterType filter_type         = ("Filter Type", "The filter design type", ":flagstodo");
    property Real freq                = ("Cutoff [Hz]", "Filter cutoff frequency in Hertz", ":flagstodo");
    property Int note                = ("Note", "Filter cutoff frequency as note, converted to Hertz according to the current musical tuning", 81, 0, 131, 12, ":flagstodo");
    property Real gain                = ("Gain [dB]", "", ":flagstodo");
    property Real fm_perc             = ("Input Modulation [%]", "Strength of linear frequency modulation", ":flagstodo");
    property Bool exponential_fm      = ("Exponential FM", "Perform exponential frequency modulation instead of linear", FALSE, ":flagstodo");
    property Real fm_n_octaves        = ("Octaves", "Number of octaves to be affected by exponential frequency modulation", ":flagstodo");
    property Real gain_perc           = ("Gain Modulation [%]", "Strength of gain modulation", ":flagstodo");
  };

  interface SubSynth : Source {
    property CSynth snet                = ("Synthesizer", "Synthesis network to use as embedded sub network", ":flagstodo");
    property String in_port_1           = ("Input Port 1", "Output port name to interface from", ":flagstodo");
    property String out_port_1          = ("Output Port 1", "Input port name to interface to", ":flagstodo");
    property String in_port_2           = ("Input Port 2", "Output port name to interface from", ":flagstodo");
    property String out_port_2          = ("Output Port 2", "Input port name to interface to", ":flagstodo");
    property String in_port_3           = ("Input Port 3", "Output port name to interface from", ":flagstodo");
    property String out_port_3          = ("Output Port 3", "Input port name to interface to", ":flagstodo");
    property String in_port_4           = ("Input Port 4", "Output port name to interface from", ":flagstodo");
    property String out_port_4          = ("Output Port 4", "Input port name to interface to", ":flagstodo");
    property String in_port_5           = ("Input Port 5", "Output port name to interface from", ":flagstodo");
    property String out_port_5          = ("Output Port 5", "Input port name to interface to", ":flagstodo");
    property String in_port_6           = ("Input Port 6", "Output port name to interface from", ":flagstodo");
    property String out_port_6          = ("Output Port 6", "Input port name to interface to", ":flagstodo");
    property String in_port_7           = ("Input Port 7", "Output port name to interface from", ":flagstodo");
    property String out_port_7          = ("Output Port 7", "Input port name to interface to", ":flagstodo");
    property String in_port_8           = ("Input Port 8", "Output port name to interface from", ":flagstodo");
    property String out_port_8          = ("Output Port 8", "Input port name to interface to", ":flagstodo");
  };

  interface Bus : SubSynth {
    ErrorType connect_bus (Bus bus) {
      Info help = "Add a bus to the input list of a bus.";
      In  bus                 = ("bus", "", ":flagstodo");
      Out error               = ("error", "", ":flagstodo");
    }
    ErrorType connect_track (Track track) {
      Info help = "Add a track to the input list of a bus.";
      In  track               = ("track", "", ":flagstodo");
      Out error               = ("error", "", ":flagstodo");
    }
    ErrorType disconnect_bus (Bus bus) {
      Info help = "Remove a bus from the input list of a bus.";
      In  bus                 = ("bus", "", ":flagstodo");
      Out error               = ("error", "", ":flagstodo");
    }
    ErrorType disconnect_track (Track track) {
      Info help = "Remove a track from the input list of a bus.";
      In  track               = ("track", "", ":flagstodo");
      Out error               = ("error", "", ":flagstodo");
    }
    ErrorType ensure_output () {
      Info help = "Ensure that a bus has an output connection.";
      Out error               = ("error", "", ":flagstodo");
    }
    property ItemSeq inputs              = ("Input Signals", "Synthesis signals (from tracks and busses) used as bus input", ":flagstodo");
    property ItemSeq outputs             = ("Output Signals", "Mixer busses used as output for synthesis signals", ":flagstodo");
    property CSynth snet                = ("snet", "", ":flagstodo");
    property Bool mute                = ("Mute", "Mute: turn off the bus volume", FALSE, ":flagstodo");
    property Bool solo                = ("Solo", "Solo: mute all other busses", FALSE, ":flagstodo");
    property Bool sync                = ("Sync", "Syncronize left and right volume", TRUE, ":flagstodo");
    property Real left_volume         = ("Left Volume", "Volume adjustment in decibel of left bus channel", ":flagstodo");
    property Real right_volume        = ("Right Volume", "Volume adjustment in decibel of right bus channel", ":flagstodo");
    property Bool master_output       = ("Master Output", "", FALSE, ":flagstodo");
  };

  interface StandardOsc : Source {
    property StandardOscWaveType wave_form           = ("Wave", "Oscillator wave form", ":flagstodo");
    property Real phase               = ("Phase", "Initial phase of the oscillator wave form (cycle offset in degree)", ":flagstodo");
    property Real base_freq           = ("Frequency", "Oscillator frequency in Hertz, i.e. the number of oscillator cycles per second", ":flagstodo");
    property Int base_note           = ("Note", "Oscillator frequency as note, converted to Hertz according to the current musical tuning", 69, 0, 131, 12, ":flagstodo");
    property Int transpose           = ("Transpose", "Transposition of the oscillator frequency in semitones", 0, -72, 72, 12, ":flagstodo");
    property Int fine_tune           = ("Fine Tune", "Amount of detuning in cent (hundredth part of a semitone)", 0, -100, 100, 10, ":flagstodo");
    property Real fm_perc             = ("Input Modulation [%]", "Strength of linear frequency modulation", ":flagstodo");
    property Bool exponential_fm      = ("Exponential FM", "Perform exponential frequency modulation instead of linear", FALSE, ":flagstodo");
    property Real fm_n_octaves        = ("Octaves", "Number of octaves to be affected by exponential frequency modulation", ":flagstodo");
    property Real self_perc           = ("Self Modulation [%]", "Strength of self modulation", ":flagstodo");
    property Real pulse_width         = ("Pulse Width", "Proportion of the positive component duration of the pulse wave form (Pulse has to be selected as wave form for this to take effect)", ":flagstodo");
    property Real pulse_mod_perc      = ("Pulse Modulation [%]", "Strength of pulse width modulation input (Pulse has to be selected as wave form for this to take effect)", ":flagstodo");
  };

  interface MidiInput : Source {
    property Int midi_channel        = ("MIDI Channel", "Input MIDI channel, 0 uses network's default channel", 0, 0, 99, 1, ":flagstodo");
  };

  interface PcmOutput : Source {
    property Real master_volume_f     = ("Master [float]", "", ":flagstodo");
    property Real master_volume_dB    = ("Master [dB]", "", ":flagstodo");
    property Int master_volume_perc  = ("Master [%]", "", 100, 0, 1584, 1, ":flagstodo");
  };

  interface PcmInput : Source {
    property Real gain_volume_f       = ("Input Gain [float]", "", ":flagstodo");
    property Real gain_volume_dB      = ("Input Gain [dB]", "", ":flagstodo");
    property Int gain_volume_perc    = ("input Gain [%]", "", 100, 0, 1584, 1, ":flagstodo");
  };

  interface SubOPort : Source {
    property String out_port_1          = ("Output Port 1", "The port name is a unique name to establish input<->output port relationships", ":flagstodo");
    property String out_port_2          = ("Output Port 2", "The port name is a unique name to establish input<->output port relationships", ":flagstodo");
    property String out_port_3          = ("Output Port 3", "The port name is a unique name to establish input<->output port relationships", ":flagstodo");
    property String out_port_4          = ("Output Port 4", "The port name is a unique name to establish input<->output port relationships", ":flagstodo");
  };

  interface InstrumentOutput : SubOPort {
    property String out_port_1          = ("out-port-1", "", ":flagstodo");
    property String out_port_2          = ("out-port-2", "", ":flagstodo");
    property String out_port_3          = ("out-port-3", "", ":flagstodo");
    property String out_port_4          = ("out-port-4", "", ":flagstodo");
  };

  interface Wave : Source {
    Real chunk_get_mix_freq (Int chunk_index) {
      Info help = "Retrieve mixing frequency of a wave chunk.";
      In  chunk_index         = ("Chunk Index", "Index of chunk", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out mix_freq            = ("mix-freq", "", ":flagstodo");
    }
    Real chunk_get_osc_freq (Int chunk_index) {
      Info help = "Retrieve oscillating frequency of a wave chunk.";
      In  chunk_index         = ("Chunk Index", "Index of chunk", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out osc_freq            = ("osc-freq", "", ":flagstodo");
    }
    ErrorType load_wave (String file_name, String wave_name) {
      Info help = "Load sample chunks from a wave file";
      In  file_name           = ("File Name", "The wave file to read wave chunks from", ":flagstodo");
      In  wave_name           = ("Wave Name", "The name of the wave to read wave chunks from", ":flagstodo");
      Out error               = ("Error", "BSE error type", ":flagstodo");
    }
    Int n_wave_chunks () {
      Info help = "Get the number of wave chunks of a wave";
      Out n_chunks            = ("Number of Wave Chunks", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    EditableSample use_editable (Int chunk_index) {
      Info help = "Retrieve an editable sample object for a wave chunk.";
      In  chunk_index         = ("chunk-index", "Index of chunk to edit", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out esample             = ("esample", "Editable sample", ":flagstodo");
    }
    property Bool locator_set         = ("Locator Set", "", FALSE, ":flagstodo");
    property String file_name           = ("File Name", "", ":flagstodo");
    property String wave_name           = ("Wave Name", "", ":flagstodo");
  };

  interface MidiVoiceSwitch : Source {
  };

  interface LadspaModule : Source {
  };

  interface MidiNotifier : Item {
    Int current_time () {
      Info help = "Test";
      Out msec_time           = ("Time [ms]", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
  };

  interface Part : Item {
    ErrorType change_control (Int id, Int tick, MidiSignalType control_type, Real value) {
      Info help = "Change an existing control event within a part.";
      In  id                  = ("ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      In  tick                = ("Start Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  control_type        = ("Control Type", "", ":flagstodo");
      In  value               = ("Value", "", ":flagstodo");
      Out error               = ("Error", "", ":flagstodo");
    }
    ErrorType change_note (Int id, Int tick, Int duration, Int note, Int fine_tune, Real velocity) {
      Info help = "Change an existing note within a part.";
      In  id                  = ("ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      In  tick                = ("Start Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Tick Duration", "", 1, 1, SFI_MAXINT, 384, ":flagstodo");
      In  note                = ("Note", "", 69, 0, 131, 12, ":flagstodo");
      In  fine_tune           = ("Fine Tune", "Fine tune in cents per semitone", 0, -100, 100, 10, ":flagstodo");
      In  velocity            = ("Velocity", "", ":flagstodo");
      Out error               = ("Error", "", ":flagstodo");
    }
    PartNoteSeq check_overlap (Int tick, Int duration, Int note) {
      Info help = "Check whether a note would overlap with neighbours.";
      In  tick                = ("Start Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Tick Duration", "", 1, 0, SFI_MAXINT, 384, ":flagstodo");
      In  note                = ("Note", "", 69, 0, 131, 12, ":flagstodo");
      Out note_list           = ("Note List", "", ":flagstodo");
    }
    ErrorType delete_event (Int id) {
      Info help = "Delete an existing event from a part.";
      In  id                  = ("ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out error               = ("Error", "", ":flagstodo");
    }
    void deselect_controls (Int tick, Int duration, MidiSignalType control_type) {
      Info help = "Deselect all controls within given range.";
      In  tick                = ("Tick", "Selection Tick", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Duration", "Selection Duration", 0, 0, SFI_MAXINT, 384, ":flagstodo");
      In  control_type        = ("Control Type", "", ":flagstodo");
    }
    void deselect_event (Int id) {
      Info help = "Deselect an existing event.";
      In  id                  = ("ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    void deselect_notes (Int tick, Int duration, Int min_note, Int max_note) {
      Info help = "Deselect all notes within rectangle.";
      In  tick                = ("Tick", "Selection Tick", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Duration", "Selection Duration", 0, 0, SFI_MAXINT, 384, ":flagstodo");
      In  min_note            = ("Minimum Selection Note", "", 69, 0, 131, 12, ":flagstodo");
      In  max_note            = ("Maximum Selection Note", "", 69, 0, 131, 12, ":flagstodo");
    }
    PartControlSeq get_channel_controls (Int channel, Int tick, Int duration, MidiSignalType control_type) {
      Info help = "Retrieve all control events of a specific type within range of a channel.";
      In  channel             = ("Channel", "", 0, 0, 4132, 4, ":flagstodo");
      In  tick                = ("Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Tick Duration", "", 1, 1, SFI_MAXINT, 384, ":flagstodo");
      In  control_type        = ("Control Type", "", ":flagstodo");
      Out control_list        = ("Control List", "", ":flagstodo");
    }
    PartControlSeq get_controls (Int tick, MidiSignalType control_type) {
      Info help = "Retrieve all control events of a specific type at specified tick.";
      In  tick                = ("Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  control_type        = ("Control Type", "", ":flagstodo");
      Out control_list        = ("Control List", "", ":flagstodo");
    }
    Int get_max_note () {
      Info help = "Retrieve the maximum note supported in this part.";
      Out note                = ("Note", "", 69, 0, 131, 12, ":flagstodo");
    }
    Int get_min_note () {
      Info help = "Retrieve the minimum note supported in this part.";
      Out note                = ("Note", "", 69, 0, 131, 12, ":flagstodo");
    }
    PartNoteSeq get_notes (Int tick, Int note) {
      Info help = "Retrieve all notes of specific frequency at or crossing a specific tick.";
      In  tick                = ("Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  note                = ("Note", "", 69, 0, 131, 12, ":flagstodo");
      Out note_list           = ("Note List", "", ":flagstodo");
    }
    SongTiming get_timing (Int tick) {
      Info help = "Retrieve song timing information at a specific tick.";
      In  tick                = ("Tick", "Tick to retrieve timing info about", 0, 0, SFI_MAXINT, 384, ":flagstodo");
      Out timing              = ("Timing", "Song Timing", ":flagstodo");
    }
    Int insert_control (Int tick, MidiSignalType control_type, Real value) {
      Info help = "Insert a new control event into a part.";
      In  tick                = ("Start Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  control_type        = ("Control Type", "", ":flagstodo");
      In  value               = ("Value", "", ":flagstodo");
      Out id                  = ("ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    Int insert_note (Int channel, Int tick, Int duration, Int note, Int fine_tune, Real velocity) {
      Info help = "Insert a new note into a part.";
      In  channel             = ("Channel", "", 0, 0, 4132, 4, ":flagstodo");
      In  tick                = ("Start Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Tick Duration", "", 1, 1, SFI_MAXINT, 384, ":flagstodo");
      In  note                = ("Note", "", 69, 0, 131, 12, ":flagstodo");
      In  fine_tune           = ("Fine Tune", "Fine tune in cents per semitone", 0, -100, 100, 10, ":flagstodo");
      In  velocity            = ("Velocity", "", ":flagstodo");
      Out id                  = ("ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    Int insert_note_auto (Int tick, Int duration, Int note, Int fine_tune, Real velocity) {
      Info help = "Insert a new note into a part with automatic channel selection.";
      In  tick                = ("Start Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Tick Duration", "", 1, 1, SFI_MAXINT, 384, ":flagstodo");
      In  note                = ("Note", "", 69, 0, 131, 12, ":flagstodo");
      In  fine_tune           = ("Fine Tune", "Fine tune in cents per semitone", 0, -100, 100, 10, ":flagstodo");
      In  velocity            = ("Velocity", "", ":flagstodo");
      Out id                  = ("ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    Bool is_event_selected (Int id) {
      Info help = "Check whether an event is selected.";
      In  id                  = ("ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out selected            = ("Selected", "", FALSE, ":flagstodo");
    }
    PartControlSeq list_controls (Int tick, Int duration, MidiSignalType control_type) {
      Info help = "List all control events within a tick range.";
      In  tick                = ("Start Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Tick Duration", "", 1, 1, SFI_MAXINT, 384, ":flagstodo");
      In  control_type        = ("Control Type", "", ":flagstodo");
      Out control_list        = ("Control List", "", ":flagstodo");
    }
    PartLinkSeq list_links () {
      Info help = "List all places where parts are used (linked) from tracks, sorted by tick.";
      Out link_list           = ("Link List", "", ":flagstodo");
    }
    PartNoteSeq list_notes_crossing (Int tick, Int duration) {
      Info help = "List all notes within or crossing a tick range.";
      In  tick                = ("Start Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Tick Duration", "", 1, 1, SFI_MAXINT, 384, ":flagstodo");
      Out note_list           = ("Note List", "", ":flagstodo");
    }
    PartNoteSeq list_notes_within (Int channel, Int tick, Int duration) {
      Info help = "List all notes within a tick range.";
      In  channel             = ("Channel", "", 0, 0, 4132, 4, ":flagstodo");
      In  tick                = ("Start Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Tick Duration", "", 1, 1, SFI_MAXINT, 384, ":flagstodo");
      Out note_list           = ("Note List", "", ":flagstodo");
    }
    PartControlSeq list_selected_controls (MidiSignalType control_type) {
      Info help = "List all currently selected control events of a specific type.";
      In  control_type        = ("Control Type", "", ":flagstodo");
      Out control_list        = ("Control List", "", ":flagstodo");
    }
    PartNoteSeq list_selected_notes () {
      Info help = "List all currently selected notes.";
      Out note_list           = ("Note List", "", ":flagstodo");
    }
    void queue_controls (Int tick, Int duration) {
      Info help = "Queue updates for all control events and notes starting within the given range.";
      In  tick                = ("Start Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Tick Duration", "", 1, 1, SFI_MAXINT, 384, ":flagstodo");
    }
    void queue_notes (Int tick, Int duration, Int min_note, Int max_note) {
      Info help = "Queue updates for all notes starting within the given rectangle.";
      In  tick                = ("Start Tick", "", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Tick Duration", "", 1, 1, SFI_MAXINT, 384, ":flagstodo");
      In  min_note            = ("Minimum Note", "", 69, 0, 131, 12, ":flagstodo");
      In  max_note            = ("Maximum Note", "", 69, 0, 131, 12, ":flagstodo");
    }
    void select_controls (Int tick, Int duration, MidiSignalType control_type) {
      Info help = "Select all control events within range.";
      In  tick                = ("Tick", "Selection Tick", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Duration", "Selection Duration", 0, 0, SFI_MAXINT, 384, ":flagstodo");
      In  control_type        = ("Control Type", "", ":flagstodo");
    }
    void select_controls_exclusive (Int tick, Int duration, MidiSignalType control_type) {
      Info help = "Select all control events within range and deselect all others.";
      In  tick                = ("Tick", "Selection Tick", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Duration", "Selection Duration", 0, 0, SFI_MAXINT, 384, ":flagstodo");
      In  control_type        = ("Control Type", "", ":flagstodo");
    }
    void select_event (Int id) {
      Info help = "Select an existing event.";
      In  id                  = ("ID", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    void select_notes (Int tick, Int duration, Int min_note, Int max_note) {
      Info help = "Select all notes within rectangle.";
      In  tick                = ("Tick", "Selection Tick", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Duration", "Selection Duration", 0, 0, SFI_MAXINT, 384, ":flagstodo");
      In  min_note            = ("Minimum Selection Note", "", 69, 0, 131, 12, ":flagstodo");
      In  max_note            = ("Maximum Selection Note", "", 69, 0, 131, 12, ":flagstodo");
    }
    void select_notes_exclusive (Int tick, Int duration, Int min_note, Int max_note) {
      Info help = "Select all notes within rectangle and deselect all others.";
      In  tick                = ("Tick", "Selection Tick", 0, 0, 2147483646, 384, ":flagstodo");
      In  duration            = ("Duration", "Selection Duration", 0, 0, SFI_MAXINT, 384, ":flagstodo");
      In  min_note            = ("Minimum Selection Note", "", 69, 0, 131, 12, ":flagstodo");
      In  max_note            = ("Maximum Selection Note", "", 69, 0, 131, 12, ":flagstodo");
    }
    signal range_changed (Int a, Int b, Int c, Int d);
    signal links_changed ();
    property Int n_channels          = ("Channels", "", 1, 1, 4132, 4, ":flagstodo");
    property Int last_tick           = ("Last Tick", "", 0, 0, SFI_MAXINT, 384, ":flagstodo");
  };

  interface DataPocket : Item {
    Int create_entry () {
      Info help = "Create a new entry in a data pocket. Entries have a unique ID which is required to set values in a data pocket.";
      Out entry_id            = ("Entry ID", "The unique pocket entry ID", 1, 1, SFI_MAXINT, 1, ":flagstodo");
    }
    ErrorType delete_entry (Int entry_id) {
      Info help = "Delete an existing entry from a data pocket";
      In  entry_id            = ("Entry ID", "The unique pocket entry ID", 1, 1, SFI_MAXINT, 1, ":flagstodo");
      Out error               = ("Error", "BSE error code", ":flagstodo");
    }
    Real get_float (Int entry_id, String name) {
      Info help = "Retrieve a previously set floating point value from a data pocket entry.";
      In  entry_id            = ("Entry ID", "The unique pocket entry ID", 1, 1, SFI_MAXINT, 1, ":flagstodo");
      In  name                = ("Name", "Name for the value", ":flagstodo");
      Out number              = ("Number", "The value stored in the data pocket entry", ":flagstodo");
    }
    Int get_int (Int entry_id, String name) {
      Info help = "Retrieve a previously set integer value from a data pocket entry.";
      In  entry_id            = ("Entry ID", "The unique pocket entry ID", 1, 1, SFI_MAXINT, 1, ":flagstodo");
      In  name                = ("Name", "Name for the value", ":flagstodo");
      Out number              = ("Number", "The value stored in the data pocket entry", 0, SFI_MININT, SFI_MAXINT, 1, ":flagstodo");
    }
    Int get_n_entries () {
      Info help = "Retrieve the number of entries created in a data pocket.";
      Out n_entries           = ("N Entries", "The number of entries in use", 1, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    Int get_nth_entry_id (Int entry_index) {
      Info help = "Retrieve the ID of an entry in the data pocket by sequential index.";
      In  entry_index         = ("Entry Index", "index into number of entries present", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out entry_id            = ("Entry ID", "The unique pocket entry ID (or 0 if there's no such entry)", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    Item get_object (Int entry_id, String name) {
      Info help = "Retrieve a previously set object reference from a data pocket entry.";
      In  entry_id            = ("Entry ID", "The unique pocket entry ID", 1, 1, SFI_MAXINT, 1, ":flagstodo");
      In  name                = ("Name", "Name for the value", ":flagstodo");
      Out item                = ("Item", "The value stored in the data pocket entry", ":flagstodo");
    }
    String get_string (Int entry_id, String name) {
      Info help = "Retrieve a previously set string from a data pocket entry.";
      In  entry_id            = ("Entry ID", "The unique pocket entry ID", 1, 1, SFI_MAXINT, 1, ":flagstodo");
      In  name                = ("Name", "Name for the value", ":flagstodo");
      Out string              = ("String", "The value stored in the data pocket entry", ":flagstodo");
    }
    ErrorType set_float (Int entry_id, String name, Real number) {
      Info help = "Set a named floating point value in a data pocket entry. Names are required to distinguish different values from each other when accessing values in a data pocket.";
      In  entry_id            = ("Entry ID", "The unique pocket entry ID", 1, 1, SFI_MAXINT, 1, ":flagstodo");
      In  name                = ("Name", "Name for the value", ":flagstodo");
      In  number              = ("Number", "The value to store in the data pocket entry", ":flagstodo");
      Out error               = ("Error", "BSE error code", ":flagstodo");
    }
    ErrorType set_int (Int entry_id, String name, Int number) {
      Info help = "Set a named integer value in a data pocket entry. Names are required to distinguish different values from each other when accessing values in a data pocket.";
      In  entry_id            = ("Entry ID", "The unique pocket entry ID", 1, 1, SFI_MAXINT, 1, ":flagstodo");
      In  name                = ("Name", "Name for the value", ":flagstodo");
      In  number              = ("Number", "The value to store in the data pocket entry", 0, SFI_MININT, SFI_MAXINT, 1, ":flagstodo");
      Out error               = ("Error", "BSE error code", ":flagstodo");
    }
    ErrorType set_object (Int entry_id, String name, Item item) {
      Info help = "Set a named object reference in a data pocket entry. Object references stored in a data pocket must exist within the same project that the data pocket belongs to";
      In  entry_id            = ("Entry ID", "The unique pocket entry ID", 1, 1, SFI_MAXINT, 1, ":flagstodo");
      In  name                = ("Name", "Name for the value", ":flagstodo");
      In  item                = ("Item", "The value to store in the data pocket entry", ":flagstodo");
      Out error               = ("Error", "BSE error code", ":flagstodo");
    }
    ErrorType set_string (Int entry_id, String name, String string) {
      Info help = "Set a named string in a data pocket entry.";
      In  entry_id            = ("Entry ID", "The unique pocket entry ID", 1, 1, SFI_MAXINT, 1, ":flagstodo");
      In  name                = ("Name", "Name for the value", ":flagstodo");
      In  string              = ("String", "The value to store in the data pocket entry", ":flagstodo");
      Out error               = ("Error", "BSE error code", ":flagstodo");
    }
    signal entry_added (Int a);
    signal entry_removed (Int a);
    signal entry_changed (Int a);
  };

  interface Janitor : Item {
    String get_action (Int nth_action) {
      Info help = "Retrieve an action of this janitor.";
      In  nth_action          = ("Nth Action", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out action              = ("Action", "", ":flagstodo");
    }
    String get_action_blurb (Int nth_action) {
      Info help = "Retrieve the help string of an action of this janitor.";
      In  nth_action          = ("Nth Action", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out action_blurb        = ("Action Blurb", "", ":flagstodo");
    }
    String get_action_name (Int nth_action) {
      Info help = "Retrieve the name of an action of this janitor.";
      In  nth_action          = ("Nth Action", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out action_name         = ("Action Name", "", ":flagstodo");
    }
    String get_proc_name () {
      Info help = "Retrieve the procedure name of this janitor.";
      Out proc_name           = ("Proc Name", "", ":flagstodo");
    }
    String get_script_name () {
      Info help = "Retrieve the script name of this janitor.";
      Out script_name         = ("Script Name", "", ":flagstodo");
    }
    void kill () {
      Info help = "Kill a currently running janitor.";
    }
    Int n_actions () {
      Info help = "Retrieve number of user actions of this janitor.";
      Out n_actions           = ("N Actions", "", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    void trigger_action (String action) {
      Info help = "Trigger an installed user action of this janitor.";
      In  action              = ("Action", "", ":flagstodo");
    }
    signal action (String a, Int b);
    signal progress (Real a);
    signal action_changed (String a, Int b);
    signal shutdown ();
    property String ident               = ("Script Identifier", "", ":flagstodo");
    property Bool connected           = ("Connected", "", FALSE, ":flagstodo");
    property String status_message      = ("Status Message", "", ":flagstodo");
    property Int exit_code           = ("Exit Code", "", 0, -256, 256, 0, ":flagstodo");
    property String exit_reason         = ("Exit Reason", "", ":flagstodo");
  };

  interface EditableSample : Item {
    void close () {
      Info help = "Close an opened sample.";
    }
    FloatSeq collect_stats (Int voffset, Real offset_scale, Int block_size, Int stepping, Int max_pairs) {
      Info help = "Collect statistics from sample blocks as (minimum, maximum) pairs.";
      In  voffset             = ("voffset", "Offset of first stat block", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      In  offset_scale        = ("offset-scale", "Factor to scale voffset increments with", ":flagstodo");
      In  block_size          = ("block-size", "Block size to compute stat pairs from", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      In  stepping            = ("stepping", "Stepping within a stat block", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      In  max_pairs           = ("max-pairs", "Maximum number of (min, max) pairs to collect", 1, 0, SFI_MAXINT, 1, ":flagstodo");
      Out sample_block        = ("sample-block", "Block of samples", ":flagstodo");
    }
    Int get_length () {
      Info help = "Return the number of values in the sample.";
      Out length              = ("length", "Number of values", 1, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    Int get_n_channels () {
      Info help = "Return the number of channels in the sample.";
      Out n_channels          = ("n-channels", "Number of channels", 0, 0, SFI_MAXINT, 1, ":flagstodo");
    }
    Real get_osc_freq () {
      Info help = "Return the oscillator frequency for the sample.";
      Out osc_freq            = ("osc-freq", "Oscillator Frequency", ":flagstodo");
    }
    ErrorType open () {
      Info help = "Open the sample for reading.";
      Out error               = ("Error", "", ":flagstodo");
    }
    FloatSeq read_samples (Int voffset) {
      Info help = "Read a set of samples from a specific offset.";
      In  voffset             = ("voffset", "Value offset", 0, 0, SFI_MAXINT, 1, ":flagstodo");
      Out sample_block        = ("sample-block", "Block of samples", ":flagstodo");
    }
    signal changed ();
  };

  Category category_from_id (Int category_id) {
    Info help = "Find a BSE category from it's unique ID.";
    In  category_id         = ("Category ID", "", 1, 1, SFI_MAXINT, 1, ":flagstodo");
    Out category            = ("Category", "", ":flagstodo");
  }
  CategorySeq categories_match (String pattern) {
    Info help = "List BSE categories according to a pattern match.";
    In  pattern             = ("Pattern", "Pattern to match category, supports '*' and '?' wildcards.", ":flagstodo");
    Out categories          = ("Categories", "", ":flagstodo");
  }
  CategorySeq categories_match_method (String pattern, String type) {
    Info help = "List BSE categories according to a pattern, of type procedure and applying to a certain object type.";
    In  pattern             = ("Pattern", "Pattern to match category, supports '*' and '?' wildcards.", ":flagstodo");
    In  type                = ("Type", "Object base type for methods to conform to.", ":flagstodo");
    Out categories          = ("Categories", "", ":flagstodo");
  }
  CategorySeq categories_match_typed (String pattern, String type) {
    Info help = "List BSE categories according to a pattern and type match.";
    In  pattern             = ("Pattern", "Pattern to match category, supports '*' and '?' wildcards.", ":flagstodo");
    In  type                = ("Type", "Base type for categories to conform to.", ":flagstodo");
    Out categories          = ("Categories", "", ":flagstodo");
  }
  NoteDescription note_describe (MusicalTuningType musical_tuning, Int note, Int fine_tune) {
    Info help = "Describe a note, providing information about its octave, semitone, frequency, etc.";
    In  musical_tuning      = ("Musical Tuning", "", ":flagstodo");
    In  note                = ("Note", "", 69, 0, 131, 12, ":flagstodo");
    In  fine_tune           = ("Fine Tune", "", 0, -100, 100, 10, ":flagstodo");
    Out note_description    = ("Note Description", "", ":flagstodo");
  }
  NoteDescription note_describe_from_freq (MusicalTuningType musical_tuning, Real freq) {
    Info help = "Describe a note, given its frequency.";
    In  musical_tuning      = ("Musical Tuning", "", ":flagstodo");
    In  freq                = ("Frequency", "", ":flagstodo");
    Out note_description    = ("Note Description", "", ":flagstodo");
  }
  String error_blurb (ErrorType error) {
    Info help = "Retrieve the description of an error value";
    In  error               = ("Error", "", ":flagstodo");
    Out blurb               = ("Blurb", "", ":flagstodo");
  }
  String error_name (ErrorType error) {
    Info help = "Retrieve the name of an error value";
    In  error               = ("Error", "", ":flagstodo");
    Out name                = ("Name", "", ":flagstodo");
  }
  NoteDescription note_construct (MusicalTuningType musical_tuning, Int semitone, Int octave, Int fine_tune) {
    Info help = "Describe a note, given its semitone, octave and fine tune.";
    In  musical_tuning      = ("Musical Tuning", "", ":flagstodo");
    In  semitone            = ("semitone", "", 9, 0, 11, 1, ":flagstodo");
    In  octave              = ("octave", "", 1, -4, 6, 2, ":flagstodo");
    In  fine_tune           = ("Fine Tune", "", 0, -100, 100, 10, ":flagstodo");
    Out note_description    = ("Note Description", "", ":flagstodo");
  }
  NoteDescription note_from_string (MusicalTuningType musical_tuning, String name) {
    Info help = "Describe a note, given its name and octave offset.";
    In  musical_tuning      = ("Musical Tuning", "", ":flagstodo");
    In  name                = ("Name", "", ":flagstodo");
    Out note_description    = ("Note Description", "", ":flagstodo");
  }
  Int note_from_freq (MusicalTuningType musical_tuning, Real frequency) {
    Info help = "Retrieve the note of a certain frequency.";
    In  musical_tuning      = ("Musical Tuning", "", ":flagstodo");
    In  frequency           = ("Frequency", "", ":flagstodo");
    Out note                = ("Note", "", 69, 0, 131, 12, ":flagstodo");
  }
  Real note_to_freq (MusicalTuningType musical_tuning, Int note, Int fine_tune) {
    Info help = "Retrieve the frequency of a certain note.";
    In  musical_tuning      = ("Musical Tuning", "", ":flagstodo");
    In  note                = ("Note", "", 69, 0, 131, 12, ":flagstodo");
    In  fine_tune           = ("Fine Tune", "", 0, -100, 100, 10, ":flagstodo");
    Out frequency           = ("Frequency", "", ":flagstodo");
  }
  Bool proxy_check (Item item, String type_name) {
    Info help = "Check whether a proxy has a certain type.";
    In  item                = ("Item", "The Item", ":flagstodo");
    In  type_name           = ("Type Name", "", ":flagstodo");
    Out is_a                = ("is-a", "", FALSE, ":flagstodo");
  }
  SampleFileInfo sample_file_info (String file_name) {
    Info help = "Load sample file info from file";
    In  file_name           = ("File Name", "The file to load info from", ":flagstodo");
    Out sample_file_info    = ("sample-file-info", "", ":flagstodo");
  }
  void script_add_action (String action, String name, String blurb) {
    Info help = "Install a user action for script control.";
    In  action              = ("Action", "", ":flagstodo");
    In  name                = ("Name", "", ":flagstodo");
    In  blurb               = ("Blurb", "", ":flagstodo");
  }
  Janitor script_janitor () {
    Info help = "Retrieve the connection dependant janitor object.";
    Out janitor             = ("Janitor", "", ":flagstodo");
  }
  void script_send_message (String domain, String msg_type, String title, String primary, String secondary, String details, String config_check) {
    Info help = "Send a message from a script.";
    In  domain              = ("domain", "", ":flagstodo");
    In  msg_type            = ("msg-type", "", ":flagstodo");
    In  title               = ("title", "", ":flagstodo");
    In  primary             = ("primary", "", ":flagstodo");
    In  secondary           = ("secondary", "", ":flagstodo");
    In  details             = ("details", "", ":flagstodo");
    In  config_check        = ("config-check", "", ":flagstodo");
  }
  void script_progress (Real progress) {
    Info help = "Indicate progress (from 0.0 to 1.0 or -1 for unknown amount).";
    In  progress            = ("Progress", "", ":flagstodo");
  }
  void script_quit () {
    Info help = "Exit a script succesfully (server side).";
  }
  void script_remove_action (String action) {
    Info help = "Remove a previously installed user action from script control.";
    In  action              = ("Action", "", ":flagstodo");
  }
  void script_set_status (String message) {
    Info help = "Alter script status message.";
    In  message             = ("Message", "", ":flagstodo");
  }
  void wave_osc_mass_seek_perc (ItemSeq wosc_seq, Real pos_perc) {
    Info help = "Seek a list of wave oscillators to a pcm position given in percentage. The oscillators will seek to the given position syncronously.";
    In  wosc_seq            = ("Wave Oscilators", "", ":flagstodo");
    In  pos_perc            = ("pos-perc", "", ":flagstodo");
  }
  Real string_extract_number (String string, String format, Real aux_base, Real dflt) {
    Info help = "Retrieve numbers from a string.";
    In  string              = ("string", "", ":flagstodo");
    In  format              = ("format", "", ":flagstodo");
    In  aux_base            = ("aux-base", "", ":flagstodo");
    In  dflt                = ("dflt", "", ":flagstodo");
    Out number              = ("number", "", ":flagstodo");
  }
  String type_authors (String type) {
    Info help = "Retrieve the authors who implemented a specific type.";
    In  type                = ("type", "", ":flagstodo");
    Out string              = ("string", "", ":flagstodo");
  }
  String type_blurb (String type) {
    Info help = "Retrieve the description of a specific type.";
    In  type                = ("type", "", ":flagstodo");
    Out string              = ("string", "", ":flagstodo");
  }
  String type_license (String type) {
    Info help = "Retrieve the license of a type impementation.";
    In  type                = ("type", "", ":flagstodo");
    Out string              = ("string", "", ":flagstodo");
  }
  String type_options (String type) {
    Info help = "Retrieve the options of a specific type.";
    In  type                = ("type", "", ":flagstodo");
    Out string              = ("string", "", ":flagstodo");
  }
};