I found two references to '14' in the D5 activex.pas.
Maybe this will help those familiar with this area.

Thanks, Andy Garner.

=======================================================================
Once here
=======================================================================
{ from WTYPES.H }
{ VARENUM usage key,

[V] - may appear in a VARIANT
[T] - may appear in a TYPEDESC
[P] - may appear in an OLE property set
[S] - may appear in a Safe Array }

{$EXTERNALSYM VT_EMPTY}
VT_EMPTY = 0; { [V] [P] nothing }
{$EXTERNALSYM VT_NULL}
VT_NULL = 1; { [V] SQL style Null }
{$EXTERNALSYM VT_I2}
VT_I2 = 2; { [V][T][P] 2 byte signed int }
{$EXTERNALSYM VT_I4}
VT_I4 = 3; { [V][T][P] 4 byte signed int }
{$EXTERNALSYM VT_R4}
VT_R4 = 4; { [V][T][P] 4 byte real }
{$EXTERNALSYM VT_R8}
VT_R8 = 5; { [V][T][P] 8 byte real }
{$EXTERNALSYM VT_CY}
VT_CY = 6; { [V][T][P] currency }
{$EXTERNALSYM VT_DATE}
VT_DATE = 7; { [V][T][P] date }
{$EXTERNALSYM VT_BSTR}
VT_BSTR = 8; { [V][T][P] binary string }
{$EXTERNALSYM VT_DISPATCH}
VT_DISPATCH = 9; { [V][T] IDispatch FAR* }
{$EXTERNALSYM VT_ERROR}
VT_ERROR = 10; { [V][T] SCODE }
{$EXTERNALSYM VT_BOOL}
VT_BOOL = 11; { [V][T][P] True=-1, False=0 }
{$EXTERNALSYM VT_VARIANT}
VT_VARIANT = 12; { [V][T][P] VARIANT FAR* }
{$EXTERNALSYM VT_UNKNOWN}
VT_UNKNOWN = 13; { [V][T] IUnknown FAR* }
{$EXTERNALSYM VT_DECIMAL}
VT_DECIMAL = 14; { [V][T] [S] 16 byte fixed point }

{$EXTERNALSYM VT_I1}
VT_I1 = 16; { [T] signed char }
{$EXTERNALSYM VT_UI1}
VT_UI1 = 17; { [T] unsigned char }
{$EXTERNALSYM VT_UI2}
VT_UI2 = 18; { [T] unsigned short }
{$EXTERNALSYM VT_UI4}
VT_UI4 = 19; { [T] unsigned short }
{$EXTERNALSYM VT_I8}
VT_I8 = 20; { [T][P] signed 64-bit int }
{$EXTERNALSYM VT_UI8}
VT_UI8 = 21; { [T] unsigned 64-bit int }
{$EXTERNALSYM VT_INT}
VT_INT = 22; { [T] signed machine int }
{$EXTERNALSYM VT_UINT}
VT_UINT = 23; { [T] unsigned machine int }
{$EXTERNALSYM VT_VOID}
VT_VOID = 24; { [T] C style void }
{$EXTERNALSYM VT_HRESULT}
VT_HRESULT = 25; { [T] }
{$EXTERNALSYM VT_PTR}
VT_PTR = 26; { [T] pointer type }
{$EXTERNALSYM VT_SAFEARRAY}
VT_SAFEARRAY = 27; { [T] (use VT_ARRAY in VARIANT) }
{$EXTERNALSYM VT_CARRAY}
VT_CARRAY = 28; { [T] C style array }
{$EXTERNALSYM VT_USERDEFINED}
VT_USERDEFINED = 29; { [T] user defined type }
{$EXTERNALSYM VT_LPSTR}
VT_LPSTR = 30; { [T][P] null terminated string }
{$EXTERNALSYM VT_LPWSTR}
VT_LPWSTR = 31; { [T][P] wide null terminated string }

{$EXTERNALSYM VT_FILETIME}
VT_FILETIME = 64; { [P] FILETIME }
{$EXTERNALSYM VT_BLOB}
VT_BLOB = 65; { [P] Length prefixed bytes }
{$EXTERNALSYM VT_STREAM}
VT_STREAM = 66; { [P] Name of the stream follows }
{$EXTERNALSYM VT_STORAGE}
VT_STORAGE = 67; { [P] Name of the storage follows }
{$EXTERNALSYM VT_STREAMED_OBJECT}
VT_STREAMED_OBJECT = 68; { [P] Stream contains an object }
{$EXTERNALSYM VT_STORED_OBJECT}
VT_STORED_OBJECT = 69; { [P] Storage contains an object }
{$EXTERNALSYM VT_BLOB_OBJECT}
VT_BLOB_OBJECT = 70; { [P] Blob contains an object }
{$EXTERNALSYM VT_CF}
VT_CF = 71; { [P] Clipboard format }
{$EXTERNALSYM VT_CLSID}
VT_CLSID = 72; { [P] A Class ID }

{$EXTERNALSYM VT_VECTOR}
VT_VECTOR = $1000; { [P] simple counted array }
{$EXTERNALSYM VT_ARRAY}
VT_ARRAY = $2000; { [V] SAFEARRAY* }
{$EXTERNALSYM VT_BYREF}
VT_BYREF = $4000; { [V] }
{$EXTERNALSYM VT_RESERVED}
VT_RESERVED = $8000;
{$EXTERNALSYM VT_ILLEGAL}
VT_ILLEGAL = $ffff;
{$EXTERNALSYM VT_ILLEGALMASKED}
VT_ILLEGALMASKED = $0fff;
{$EXTERNALSYM VT_TYPEMASK}
VT_TYPEMASK = $0fff;



=======================================================================
and later on here
=======================================================================

{$EXTERNALSYM tagPROPVARIANT}
tagPROPVARIANT = packed record
vt: TVarType;
wReserved1: Word;
wReserved2: Word;
wReserved3: Word;
case Integer of
0: (bVal: Byte);
1: (iVal: SmallInt);
2: (uiVal: Word);
3: (boolVal: TOleBool);
4: (bool: TOleBool);
5: (lVal: Longint);
6: (ulVal: Cardinal);
7: (fltVal: Single);
8: (scode: SCODE);
9: (hVal: LARGE_INTEGER);
10: (uhVal: ULARGE_INTEGER);
11: (dblVal: Double);
12: (cyVal: Currency);
13: (date: TOleDate);
14: (filetime: TFileTime);
15: (puuid: PGUID);
16: (blob: TBlob);
17: (pclipdata: PClipData);
18: (pStream: Pointer{IStream});
19: (pStorage: Pointer{IStorage});
20: (bstrVal: TBStr);
21: (pszVal: PAnsiChar);
22: (pwszVal: PWideChar);
23: (caub: TCAUB);
24: (cai: TCAI);
25: (caui: TCAUI);
26: (cabool: TCABOOL);
27: (cal: TCAL);
28: (caul: TCAUL);
29: (caflt: TCAFLT);
30: (cascode: TCASCODE);
31: (cah: TCAH);
32: (cauh: TCAUH);
33: (cadbl: TCADBL);
34: (cacy: TCACY);
35: (cadate: TCADATE);
36: (cafiletime: TCAFILETIME);
37: (cauuid: TCACLSID);
38: (caclipdata: TCACLIPDATA);
39: (cabstr: TCABSTR);
40: (calpstr: TCALPSTR);
41: (calpwstr: TCALPWSTR );
42: (capropvar: TCAPROPVARIANT);
end;
{$EXTERNALSYM PROPVARIANT}
PROPVARIANT = tagPROPVARIANT;
TPropVariant = tagPROPVARIANT;

----- Original Message -----
From: "Claudio Valderrama C." <cvalde@...>
To: <IBObjects@egroups.com>
Sent: Wednesday, January 03, 2001 5:51 AM
Subject: RE: [IBO] Fields[xx].value - unidentifyed type: 14


> > -----Original Message-----
> > From: Helen Borrie [mailto:helebor@...]
> > Sent: Martes 2 de Enero de 2001 3:50
> >
> > At 12:50 AM 02-01-01 -0400, Claudio wrote:
> >
> > >In other words, variant of type 14 is longlong, I mean INT64.
> >
> > Claudio,
> > Are the variant types documented anywhere? This is not UD types as in
> > RDB$TYPES, right? Or are these Delphi variant types? Prolly not, as
the
> > D5 doc says INT64 can't be a variant...
> >
> > HNY
>
> When Jason wrote in the code "Avoiding having to load in the ActiveX
unit."
> this indicates to me that type is not an IBO invention, but that's defined
> in the AxtiveX unit but Jason didn't want to include it for avoiding more
> overhead. We are talking about Delphi variant types that can be used to
map
> to the IB data types. I can't check because I have only D3, but if Jason
> wrote {$IFDEF IBO_VCL40_OR_GREATER} then there's some support in D4 and
> above. If D5 doc says INT64 can't be a variant, then I request anyone with
> D5 to check what's type 14 in the D5's ActiveX unit. I don't know what
> Borland considers type 14, but Jason used it for INT64 support.
>
> C.