type
  asktype        = (yes, no, ask, only);
  videotype      = (auto, short, long);
  msgtype        = (localmail, netmail, echomail);
  msgkindstype   = (both, private, public, ronly);
  orphantype     = (ignore, create, kill);
  flagtype       = array[1..4] of byte;
  time           = string[5];
  date           = string[8];
  longdate       = string[9];

  netaddress     = record
    zone,
    net,
    node,
    point          : word;
  end;

  languagerecord = record
    name           : string[20];
    attribute      : byte;
    defname,
    menupath,
    textpath,
    quespath       : string[60];
    freespace      : array[1..200] of byte;
  end;

  msginforecord  = record
    lowmsg,
    highmsg,
    totalmsgs      : word;
    totalonboard   : array[1..200] of word;
  end;

  msgidxrecord   = record
    msgnum         : integer;
    board          : byte;
  end;

  msgtoidxrecord = string[35];

  msghdrrecord   = record
    msgnum         : integer;
    prevreply,
    nextreply,
    timesread      : word;
    startblock     : word;
    numblocks,
    destnet,
    destnode,
    orignet,
    orignode       : word;
    destzone,
    origzone       : byte;
    cost           : word;
    msgattr,
    netattr,
    board          : byte;
    posttime       : time;
    postdate       : date;
    whoto,
    whofrom        : msgtoidxrecord;
    subject        : string[72];
  end;

  msgtxtrecord   = string[255];

  useronrecord   = record
    name,
    handle         : msgtoidxrecord;
    line           : byte;
    baud           : word;
    city           : string[25];
    donotdisturb   : boolean;
    status         : byte;
    attribute      : byte;
  end;

  { status byte - 0 : browsing (in a menu)
                  1 : uploading/downloading
                  2 : reading/posting messages
                  3 : in a door/external utility
                  4 : chatting with sysop
                  5 : answering questionnaire
                  6 : system ready (0=busy)

    attribute   - bit 0 : hidden }

  lastcallrecord = record
    line           : byte;
    name,
    handle         : msgtoidxrecord;
    city           : string[25];
    baud           : word;
    times          : longint;
    logon          : string[5];
    logoff         : string[5];
    attribute      : byte;
  end;

                { attribute - bit 0 : hidden }

  lastreadrecord = array[1..200] of word;

  combinedrecord = array[1..25] of byte;

  usersidxrecord = record
    namecrc32,
    handlecrc32    : longint;
  end;

  usersxirecord  = record
    handle         : string[35];
    comment        : string[80];
    firstdate      : date;
    combinedinfo   : combinedrecord;
    birthdate,
    subdate        : date;
    screenwidth,
    msgarea,
    filearea,
    language,
    dateformat     : byte;
    forwardto      : string[35];
    extraspace     : array[1..43] of byte;
  end;

  usersrecord    = record
    name           : msgtoidxrecord;
    location       : string[25];
    password       : string[15];
    dataphone,
    voicephone     : string[12];
    lasttime       : time;
    lastdate       : date;
    attribute      : byte;

     { bit 0 : deleted
           1 : clear screen
           2 : more prompt
           3 : ansi
           4 : no-kill
           5 : xfer priority
           6 : full screen msg editor
           7 : quiet mode }

    flags          : flagtype;
    credit,
    pending        : word;
    msgsposted,
    lastread,
    security,
    nocalls,
    uploads,
    downloads,
    uploadsk,
    downloadsk     : word;
    todayk,
    elapsed        : integer;
    screenlength   : word;
    lastpwdchange,
    attribute2,

     { bit 0 : hot-keys
           1 : avt/0
           2 : full screen message viewer
           3 : hidden from userlist }


    group          : byte;
    xirecord       : word;
    extraspace     : array[1..3] of byte;
  end;

  sysinforecord  = record
    totalcalls     : longint;
    lastcaller     : msgtoidxrecord;
    extraspace     : array[1..128] of byte;
  end;

  timelogrecord  = record
    startdate      : date;
    busyperhour    : array[0..23] of word;
    busyperday     : array[0..6] of word;
  end;

  mnurecord      = record
    typ            : byte;
    security       : word;
    flags          : flagtype;
    display        : string[75];
    hotkey         : char;
    miscdata       : string[80];
    foreground,
    background     : byte;
  end;

  eventrecord    = record
    status         : byte; { 0=deleted 1=enabled 2=disabled }
    starttime      : time;
    errorlevel     : byte;
    days           : byte;
    forced         : boolean;
    lasttimerun    : date;
  end;

  eventrecordarray = array[1..20] of eventrecord;

  messagerecord  = record
    name           : string[40];
    typ            : msgtype;
    msgkinds       : msgkindstype;
    attribute      : byte;

     { bit 0 : enable echoinfo
           1 : combined access
           2 : file attaches
           3 : allow aliases
           4 : use softcrs as characters
           5 : force handle
           6 : allow deletes }

    dayskill,    { kill older than 'x' days }
    recvkill       : byte; { kill recv msgs, recv for more than 'x' days }
    countkill      : word;

    readsecurity   : word;
    readflags      : flagtype;

    writesecurity  : word;
    writeflags     : flagtype;

    sysopsecurity  : word;
    sysopflags     : flagtype;

    originline     : string[60];
    akaaddress     : byte;
  end;

  filesrecord    = record
    name           : string[30];
    attrib         : byte;

     { bit 0 : include in new files scan
           1 : include in upload dupe scan
           2 : permit long descriptions }

    filepath       : string[40];
    freespace      : array[1..35] of byte;
    uploadsecurity : word;
    uploadflags    : flagtype;
    security       : word;
    flags          : flagtype;
    listsecurity   : word;
    listflags      : flagtype;
  end;

  configrecord = record
    versionid           : word;
    commport            : byte;
    baud                : longint;
    inittries           : byte;
    initstr,
    busystr             : string[70];
    initresp,
    busyresp,
    connect300,
    connect1200,
    connect2400,
    connect4800,
    connect9600,
    connect19k,
    connect38k          : string[40];
    answerphone         : boolean;
    ring,
    answerstr           : string[20];
    flushbuffer         : boolean;
    modemdelay          : integer;

    minimumbaud,
    graphicsbaud,
    transferbaud        : integer;
    slowbaudtimestart,
    slowbaudtimeend,
    downloadtimestart,
    downloadtimeend     : time;

    pagestart           : array[0..6] of time;
    pageend             : array[0..6] of time;

{}  freespace1          : array[1..70] of byte;
    pwdexpiry           : word;

    menupath,
    textpath,
    attachpath,
    nodelistpath,
    msgbasepath,
    syspath,
    externaledcmd       : string[60];

    address             : array[0..9] of netaddress;
    systemname          : string[30];

    newsecurity         : word;
    newcredit           : word;
    newflags            : flagtype;

    originline          : string[60];
    quotestring         : string[15];
    sysop               : string[35];
    logfilename         : string[60];
    fastlogon,
    allowsysrem,
    monomode,
    strictpwdchecking,
    directwrite,
    snowcheck           : boolean;
    creditfactor        : integer;

    usertimeout,
    logontime,
    passwordtries,
    maxpage,
    pagelength          : word;
    checkformultilogon,
    excludesysopfromlist,
    onewordnames        : boolean;
    checkmail           : asktype;
    askvoicephone,
    askdataphone,
    dofullmailcheck,
    allowfileshells,
    fixuploaddates,
    freezechat          : boolean;
    ansi,                       { ansi: yes, no, or ask new users     }
    clearscreen,                { clear:        "                     }
    moreprompt          : asktype;    { more:         "                     }
    uploadmsgs          : boolean;
    killsent            : asktype;    { kill/sent     "                     }

    crashasksec         : word;       { min sec# to ask 'Crash Mail ?'      }
    crashaskflags       : flagtype;
    crashsec            : word;       { min sec# to always send crash mail. }
    crashflags          : flagtype;
    fattachsec          : word;       {        "    ask 'File Attach ?'     }
    fattachflags        : flagtype;

    normfore,
    normback,
    statfore,
    statback,
    hiback,
    hifore,
    windfore,
    windback,
    exitlocal,
    exit300,
    exit1200,
    exit2400,
    exit4800,
    exit9600,
    exit19k,
    exit38k             : byte;

    multiline           : boolean;
    minpwdlen           : byte;
    minupspace          : word;
    hotkeys             : asktype;
    borderfore,
    borderback,
    barfore,
    barback,
    logstyle,
    multitasker,
    pwdboard            : byte;
    buffersize          : word;
    fkeys               : array[1..10] of string[60];

    whypage             : boolean;
    leavemsg            : byte;
    showmissingfiles    : boolean;
{}  freespace2          : array[1..11] of byte;
    allownetmailreplies : boolean;
    logonprompt         : string[40];
    checknewfiles       : asktype;
    replyheader         : string[60];
    blanksecs           : byte;
    protocolattrib      : array[1..6] of byte;
    errorfreestring     : string[15];
    defaultcombined     : combinedrecord;
    renumthreshold      : word;
    leftbracket,
    rightbracket        : char;
    askforhandle        : boolean;
    askforbirthdate     : boolean;

    groupmailsec        : word;

    confirmmsgdeletes   : boolean;
    freespace3          : array[1..163] of byte;
    newusergroup        : byte;
    avatar              : asktype;
    badpwdarea          : byte;
    location            : string[40];
    doafteraction       : byte; {0 = wait for cr, > 0 = wait for x seconds}
    fileline            : string[40];
    crfore,
    crback              : byte;
    langhdr             : string[40];
    sendbreak           : boolean;
    listpath            : string[60];
    fullmsgview         : asktype;
    emsi_enable         : asktype;
    emsi_newuser        : boolean;

    echochar            : string[1];
    connect7200,
    connect12000,
    connect14400        : string[40];
    exit7200,
    exit12000,
    exit14400           : byte;
    chatcommand         : string[60];
    exted               : asktype;
    newuserlanguage     : byte;
    languageprompt      : string[40];
    videomode           : videotype;
    autodetectansi      : boolean;
    offhook             : boolean;
    newuserdateformat   : byte;
    keyboardpwd         : string[15];
    caplocation         : boolean;
    newusersub          : byte;
    printername         : string[4];
    hilitepromptfore,
    hilitepromptback    : byte;
    initstr2            : string[70];
    altjswap            : boolean;
    sempath             : string[60];
    autochatcapture     : boolean;

    futureexpansion : array[1..97] of byte;
  end;

  exitinforecord = record
    baud             : word;
    sysinfo          : sysinforecord;
    timeloginfo      : timelogrecord;
    userinfo         : usersrecord;
    eventinfo        : eventrecord;
    netmailentered,
    echomailentered  : boolean;
    logintime        : time;
    logindate        : date;
    timelimit        : word;
    loginsec,
    credit           : longint;
    userrecord       : integer;
    readthru,
    numberpages,
    downloadlimit    : word;
    timeofcreation   : time;
    logonpassword    : string[15];
    wantchat         : boolean;

    deductedtime     : integer;
    menustack        : array[1..50] of string[8];
    menustackpointer : byte;
    userxiinfo       : usersxirecord;
    errorfreeconnect,
    sysopnext        : boolean;

    emsi_session     : boolean;        { these fields hold  }
    emsi_crtdef,                       { data related to an }
    emsi_protocols,                    { emsi session       }
    emsi_capabilities,
    emsi_requests,
    emsi_software    : string[40];
    hold_attr1,
    hold_attr2,
    hold_len         : byte;

    extraspace       : array[1..100] of byte;
  end;

  protocolrecord = record
    name           : string[15];
    activekey      : char;
    opustypectlfile,
    batchavailable : boolean;
    attribute      : byte; { 0=disabled, 1=enabled }
    logfilename,
    ctlfilename,
    dncmdstring,
    dnctlstring,
    upcmdstring,
    upctlstring    : string[80];
    uplogkeyword,
    dnlogkeyword   : string[20];
    xferdescwordnum,
    xfernamewordnum : byte;
  end;