Exporting Web Services (Delphi)

Note

This demo is available in your FlexCel installation at <FlexCel Install Folder>\Demo\Delphi\Modules\20.Reports\27.Exporting Web Services and also at https:​//​github.​com/​tmssoftware/​TMS-​FlexCel.​VCL-​demos/​tree/​master/​Delphi/​Modules/​20.​Reports/​27.​Exporting Web Services

Overview

A demo that accesses the NOAA Meteorological web service and returns an Excel file with the forecast. Just in case you do not have an Internet connection available, some sample data is included to work offline too.

Concepts

How to export the data on a Web Service to Excel or PDF.

Files

ndfdXML.pas

// ************************************************************************ //
// The types declared in this file were generated from data read from the
// WSDL File described below:
// WSDL     : http://www.weather.gov/forecasts/xml/DWMLgen/wsdl/ndfdXML.wsdl
//  >Import : http://www.weather.gov/forecasts/xml/DWMLgen/wsdl/ndfdXML.wsdl>0
// Version  : 1.0
// (25/09/2014 14:06:51 - - $Rev: 45757 $)
// ************************************************************************ //

unit ndfdXML;

interface

uses InvokeRegistry, SOAPHTTPClient, Types, XSBuiltIns;

type

  // ************************************************************************ //
  // The following types, referred to in the WSDL document are not being represented
  // in this file. They are either aliases[@] of other types represented or were referred
  // to but never[!] declared in the document. The types from the latter category
  // typically map to predefined/known XML or Embarcadero types; however, they could also 
  // indicate incorrect WSDL documents that failed to declare or import a schema type.
  // ************************************************************************ //
  // !:date            - "http://www.w3.org/2001/XMLSchema"[]
  // !:integer         - "http://www.w3.org/2001/XMLSchema"[]
  // !:decimal         - "http://www.w3.org/2001/XMLSchema"[]
  // !:dateTime        - "http://www.w3.org/2001/XMLSchema"[]
  // !:boolean         - "http://www.w3.org/2001/XMLSchema"[Gbl]
  // !:string          - "http://www.w3.org/2001/XMLSchema"[Gbl]

  weatherParametersType = class;                { "http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd"[GblCplx] }

  {$SCOPEDENUMS ON}
  { "http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd"[GblSmpl] }
  displayLevelType = (_1, _2, _3, _4, _12, _34, _1234);

  { "http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd"[GblSmpl] }
  featureTypeType = (Forecast_Gml2Point, Forecast_Gml2AllWx, Forecast_GmlsfPoint, Forecast_GmlObs, NdfdMultiPointCoverage, Ndfd_KmlPoint);

  { "http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd"[GblSmpl] }
  compTypeType = (IsEqual, Between, GreaterThan, GreaterThanEqualTo, LessThan, LessThanEqualTo);

  { "http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd"[GblSmpl] }
  formatType = (_24_hourly, _12_hourly);

  { "http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd"[GblSmpl] }
  productType = (time_series, glance);

  { "http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd"[GblSmpl] }
  sectorType = (conus, nhemi, alaska, guam, hawaii, puertori, npacocn);

  { "http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd"[GblSmpl] }
  unitType = (e, m);

  {$SCOPEDENUMS OFF}



  // ************************************************************************ //
  // XML       : weatherParametersType, global, <complexType>
  // Namespace : http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd
  // ************************************************************************ //
  weatherParametersType = class(TRemotable)
  private
    Fmaxt: Boolean;
    Fmint: Boolean;
    Ftemp: Boolean;
    Fdew: Boolean;
    Fpop12: Boolean;
    Fqpf: Boolean;
    Fsky: Boolean;
    Fsnow: Boolean;
    Fwspd: Boolean;
    Fwdir: Boolean;
    Fwx: Boolean;
    Fwaveh: Boolean;
    Ficons: Boolean;
    Frh: Boolean;
    Fappt: Boolean;
    Fincw34: Boolean;
    Fincw50: Boolean;
    Fincw64: Boolean;
    Fcumw34: Boolean;
    Fcumw50: Boolean;
    Fcumw64: Boolean;
    Fcritfireo: Boolean;
    Fdryfireo: Boolean;
    Fconhazo: Boolean;
    Fptornado: Boolean;
    Fphail: Boolean;
    Fptstmwinds: Boolean;
    Fpxtornado: Boolean;
    Fpxhail: Boolean;
    Fpxtstmwinds: Boolean;
    Fptotsvrtstm: Boolean;
    Fpxtotsvrtstm: Boolean;
    Ftmpabv14d: Boolean;
    Ftmpblw14d: Boolean;
    Ftmpabv30d: Boolean;
    Ftmpblw30d: Boolean;
    Ftmpabv90d: Boolean;
    Ftmpblw90d: Boolean;
    Fprcpabv14d: Boolean;
    Fprcpblw14d: Boolean;
    Fprcpabv30d: Boolean;
    Fprcpblw30d: Boolean;
    Fprcpabv90d: Boolean;
    Fprcpblw90d: Boolean;
    Fprecipa_r: Boolean;
    Fsky_r: Boolean;
    Ftd_r: Boolean;
    Ftemp_r: Boolean;
    Fwdir_r: Boolean;
    Fwspd_r: Boolean;
    Fwwa: Boolean;
    Fwgust: Boolean;
    Ficeaccum: Boolean;
    Fmaxrh: Boolean;
    Fminrh: Boolean;
  published
    property maxt:         Boolean  read Fmaxt write Fmaxt;
    property mint:         Boolean  read Fmint write Fmint;
    property temp:         Boolean  read Ftemp write Ftemp;
    property dew:          Boolean  read Fdew write Fdew;
    property pop12:        Boolean  read Fpop12 write Fpop12;
    property qpf:          Boolean  read Fqpf write Fqpf;
    property sky:          Boolean  read Fsky write Fsky;
    property snow:         Boolean  read Fsnow write Fsnow;
    property wspd:         Boolean  read Fwspd write Fwspd;
    property wdir:         Boolean  read Fwdir write Fwdir;
    property wx:           Boolean  read Fwx write Fwx;
    property waveh:        Boolean  read Fwaveh write Fwaveh;
    property icons:        Boolean  read Ficons write Ficons;
    property rh:           Boolean  read Frh write Frh;
    property appt:         Boolean  read Fappt write Fappt;
    property incw34:       Boolean  read Fincw34 write Fincw34;
    property incw50:       Boolean  read Fincw50 write Fincw50;
    property incw64:       Boolean  read Fincw64 write Fincw64;
    property cumw34:       Boolean  read Fcumw34 write Fcumw34;
    property cumw50:       Boolean  read Fcumw50 write Fcumw50;
    property cumw64:       Boolean  read Fcumw64 write Fcumw64;
    property critfireo:    Boolean  read Fcritfireo write Fcritfireo;
    property dryfireo:     Boolean  read Fdryfireo write Fdryfireo;
    property conhazo:      Boolean  read Fconhazo write Fconhazo;
    property ptornado:     Boolean  read Fptornado write Fptornado;
    property phail:        Boolean  read Fphail write Fphail;
    property ptstmwinds:   Boolean  read Fptstmwinds write Fptstmwinds;
    property pxtornado:    Boolean  read Fpxtornado write Fpxtornado;
    property pxhail:       Boolean  read Fpxhail write Fpxhail;
    property pxtstmwinds:  Boolean  read Fpxtstmwinds write Fpxtstmwinds;
    property ptotsvrtstm:  Boolean  read Fptotsvrtstm write Fptotsvrtstm;
    property pxtotsvrtstm: Boolean  read Fpxtotsvrtstm write Fpxtotsvrtstm;
    property tmpabv14d:    Boolean  read Ftmpabv14d write Ftmpabv14d;
    property tmpblw14d:    Boolean  read Ftmpblw14d write Ftmpblw14d;
    property tmpabv30d:    Boolean  read Ftmpabv30d write Ftmpabv30d;
    property tmpblw30d:    Boolean  read Ftmpblw30d write Ftmpblw30d;
    property tmpabv90d:    Boolean  read Ftmpabv90d write Ftmpabv90d;
    property tmpblw90d:    Boolean  read Ftmpblw90d write Ftmpblw90d;
    property prcpabv14d:   Boolean  read Fprcpabv14d write Fprcpabv14d;
    property prcpblw14d:   Boolean  read Fprcpblw14d write Fprcpblw14d;
    property prcpabv30d:   Boolean  read Fprcpabv30d write Fprcpabv30d;
    property prcpblw30d:   Boolean  read Fprcpblw30d write Fprcpblw30d;
    property prcpabv90d:   Boolean  read Fprcpabv90d write Fprcpabv90d;
    property prcpblw90d:   Boolean  read Fprcpblw90d write Fprcpblw90d;
    property precipa_r:    Boolean  read Fprecipa_r write Fprecipa_r;
    property sky_r:        Boolean  read Fsky_r write Fsky_r;
    property td_r:         Boolean  read Ftd_r write Ftd_r;
    property temp_r:       Boolean  read Ftemp_r write Ftemp_r;
    property wdir_r:       Boolean  read Fwdir_r write Fwdir_r;
    property wspd_r:       Boolean  read Fwspd_r write Fwspd_r;
    property wwa:          Boolean  read Fwwa write Fwwa;
    property wgust:        Boolean  read Fwgust write Fwgust;
    property iceaccum:     Boolean  read Ficeaccum write Ficeaccum;
    property maxrh:        Boolean  read Fmaxrh write Fmaxrh;
    property minrh:        Boolean  read Fminrh write Fminrh;
  end;

  listLatLonType  = string;         { "http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd"[GblSmpl] }
  zipCodeListType = string;         { "http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd"[GblSmpl] }
  listCityNamesType = string;       { "http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd"[GblSmpl] }

  // ************************************************************************ //
  // Namespace : http://graphical.weather.gov/xml/DWMLgen/wsdl/ndfdXML.wsdl
  // soapAction: http://graphical.weather.gov/xml/DWMLgen/wsdl/ndfdXML.wsdl#%operationName%
  // transport : http://schemas.xmlsoap.org/soap/http
  // style     : rpc
  // use       : encoded
  // binding   : ndfdXMLBinding
  // service   : ndfdXML
  // port      : ndfdXMLPort
  // URL       : http://graphical.weather.gov/xml/SOAP_server/ndfdXMLserver.php
  // ************************************************************************ //
  ndfdXMLPortType = interface(IInvokable)
  ['{1E6F1B25-B6D9-BB0E-5BE9-05D3A60F2020}']
    function  NDFDgen(const latitude: TXSDecimal; const longitude: TXSDecimal; const product: productType; const startTime: TXSDateTime; const endTime: TXSDateTime; const Unit_: unitType; 
                      const weatherParameters: weatherParametersType): string; stdcall;
    function  NDFDgenByDay(const latitude: TXSDecimal; const longitude: TXSDecimal; const startDate: TXSDate; const numDays: Int64; const Unit_: unitType; const format: formatType
                           ): string; stdcall;
    function  NDFDgenLatLonList(const listLatLon: listLatLonType; const product: productType; const startTime: TXSDateTime; const endTime: TXSDateTime; const Unit_: unitType; const weatherParameters: weatherParametersType
                                ): string; stdcall;
    function  NDFDgenByDayLatLonList(const listLatLon: listLatLonType; const startDate: TXSDate; const numDays: Int64; const Unit_: unitType; const format: formatType): string; stdcall;
    function  GmlLatLonList(const listLatLon: listLatLonType; const requestedTime: TXSDateTime; const featureType: featureTypeType; const weatherParameters: weatherParametersType): string; stdcall;
    function  GmlTimeSeries(const listLatLon: listLatLonType; const startTime: TXSDateTime; const endTime: TXSDateTime; const compType: compTypeType; const featureType: featureTypeType; const propertyName: string
                            ): string; stdcall;
    function  LatLonListSubgrid(const lowerLeftLatitude: TXSDecimal; const lowerLeftLongitude: TXSDecimal; const upperRightLatitude: TXSDecimal; const upperRightLongitude: TXSDecimal; const resolution: TXSDecimal): listLatLonType; stdcall;
    function  LatLonListLine(const endPoint1Lat: TXSDecimal; const endPoint1Lon: TXSDecimal; const endPoint2Lat: TXSDecimal; const endPoint2Lon: TXSDecimal): listLatLonType; stdcall;
    function  LatLonListZipCode(const zipCodeList: zipCodeListType): listLatLonType; stdcall;
    function  LatLonListSquare(const centerPointLat: TXSDecimal; const centerPointLon: TXSDecimal; const distanceLat: TXSDecimal; const distanceLon: TXSDecimal; const resolution: TXSDecimal): listLatLonType; stdcall;
    function  CornerPoints(const sector: sectorType): listLatLonType; stdcall;
    function  LatLonListCityNames(const displayLevel: displayLevelType): listCityNamesType; stdcall;
  end;

function GetndfdXMLPortType(UseWSDL: Boolean=System.False; Addr: string=''; HTTPRIO: THTTPRIO = nil): ndfdXMLPortType;


implementation
  uses SysUtils;

function GetndfdXMLPortType(UseWSDL: Boolean; Addr: string; HTTPRIO: THTTPRIO): ndfdXMLPortType;
const
  defWSDL = 'http://www.weather.gov/forecasts/xml/DWMLgen/wsdl/ndfdXML.wsdl';
  defURL  = 'http://graphical.weather.gov/xml/SOAP_server/ndfdXMLserver.php';
  defSvc  = 'ndfdXML';
  defPrt  = 'ndfdXMLPort';
var
  RIO: THTTPRIO;
begin
  Result := nil;
  if (Addr = '') then
  begin
    if UseWSDL then
      Addr := defWSDL
    else
      Addr := defURL;
  end;
  if HTTPRIO = nil then
    RIO := THTTPRIO.Create(nil)
  else
    RIO := HTTPRIO;
  try
    Result := (RIO as ndfdXMLPortType);
    if UseWSDL then
    begin
      RIO.WSDLLocation := Addr;
      RIO.Service := defSvc;
      RIO.Port := defPrt;
    end else
      RIO.URL := Addr;
  finally
    if (Result = nil) and (HTTPRIO = nil) then
      RIO.Free;
  end;
end;


initialization
  { ndfdXMLPortType }
  InvRegistry.RegisterInterface(TypeInfo(ndfdXMLPortType), 'http://graphical.weather.gov/xml/DWMLgen/wsdl/ndfdXML.wsdl', '');
  InvRegistry.RegisterDefaultSOAPAction(TypeInfo(ndfdXMLPortType), 'http://graphical.weather.gov/xml/DWMLgen/wsdl/ndfdXML.wsdl#%operationName%');
  { ndfdXMLPortType.NDFDgen }
  InvRegistry.RegisterParamInfo(TypeInfo(ndfdXMLPortType), 'NDFDgen', 'Unit_', 'Unit', '');
  { ndfdXMLPortType.NDFDgenByDay }
  InvRegistry.RegisterParamInfo(TypeInfo(ndfdXMLPortType), 'NDFDgenByDay', 'Unit_', 'Unit', '');
  { ndfdXMLPortType.NDFDgenLatLonList }
  InvRegistry.RegisterParamInfo(TypeInfo(ndfdXMLPortType), 'NDFDgenLatLonList', 'Unit_', 'Unit', '');
  { ndfdXMLPortType.NDFDgenByDayLatLonList }
  InvRegistry.RegisterParamInfo(TypeInfo(ndfdXMLPortType), 'NDFDgenByDayLatLonList', 'Unit_', 'Unit', '');
  RemClassRegistry.RegisterXSInfo(TypeInfo(displayLevelType), 'http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd', 'displayLevelType');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(displayLevelType), '_1', '1');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(displayLevelType), '_2', '2');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(displayLevelType), '_3', '3');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(displayLevelType), '_4', '4');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(displayLevelType), '_12', '12');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(displayLevelType), '_34', '34');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(displayLevelType), '_1234', '1234');
  RemClassRegistry.RegisterXSInfo(TypeInfo(featureTypeType), 'http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd', 'featureTypeType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(compTypeType), 'http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd', 'compTypeType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(formatType), 'http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd', 'formatType');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(formatType), '_24_hourly', '24 hourly');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(formatType), '_12_hourly', '12 hourly');
  RemClassRegistry.RegisterXSInfo(TypeInfo(productType), 'http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd', 'productType');
  RemClassRegistry.RegisterExternalPropName(TypeInfo(productType), 'time_series', 'time-series');
  RemClassRegistry.RegisterXSInfo(TypeInfo(sectorType), 'http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd', 'sectorType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(unitType), 'http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd', 'unitType');
  RemClassRegistry.RegisterXSClass(weatherParametersType, 'http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd', 'weatherParametersType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(listLatLonType), 'http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd', 'listLatLonType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(zipCodeListType), 'http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd', 'zipCodeListType');
  RemClassRegistry.RegisterXSInfo(TypeInfo(listCityNamesType), 'http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd', 'listCityNamesType');

end.

UDataModel.pas

unit UDataModel;

interface
uses SysUtils, Generics.Collections;

type

  TWeather = class
    private
      FDay: TDateTime;
      FLow: double;
      FHigh: double;
      FIcon: TBytes;

    public
      property Day: TDateTime read FDay;
      property Low: double read FLow;
      property High: double read FHigh;
      property Icon: TBytes read FIcon;

      constructor Create(const aDay: TDateTime; const aLow, aHigh: double; const aIcon: TBytes);
  end;

  TWeatherList = class(TObjectList<TWeather>)
  end;


implementation

{ TWeather }

constructor TWeather.Create(const aDay: TDateTime; const aLow, aHigh: double;
  const aIcon: TBytes);
begin
  FDay := aDay;
  FLow := aLow;
  FHigh := aHigh;
  FIcon := aIcon;
end;

end.

ULatLong.pas

unit ULatLong;

interface
type
  TLatLong = record
    public
    Latitude,
    Longitude: Currency;

    constructor Create(const aLatitude, aLongitude: Currency);

  end;
implementation

{ LatLong }

constructor TLatLong.Create(const aLatitude, aLongitude: Currency);
begin
  Latitude := aLatitude;
  Longitude := aLongitude;
end;

end.

UMainForm.pas

unit UMainForm;
{*This program is inspired on the progam by Mikhail Arkhipov
 * at http://blogs.msdn.com/mikhailarkhipov/archive/2004/08/12/213963.aspx
 * Thanks!
 */

/* UPDATE: This was patched with the info on
 * http://weblogs.asp.net/jan/archive/2004/01/28/63771.aspx
 * to make it work.
 *
 * Thanks again...
 *
 * UPDATE 2!
 * The NOAA broke the service again, and it has not fixed it for more than a year.
 * I give up. We will use http://www.webservicex.net/WeatherForecast.asmx instead.
 * The code for NOAA is still there on the SetupNOAA method, just not used so you can see it (and try it if it ever starts working again)
 *
 * UPDATE 3!
 * Now WebserviceX is not working, going back to NOAA. As you can see, it isn't very trustable that a webservice will be there in the
 * future, so this demo might not work in online mode when you try it. But you can always look at in in offline mode.
 * *}

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics,
  XMLDoc, XMLIntf, Generics.Collections, ULatLong, Types,
  UDataModel,
  Controls, Forms, Dialogs, StdCtrls;

type
  TMainForm = class(TForm)
    edCity: TComboBox;
    lblCity: TLabel;
    cbOffline: TCheckBox;
    btnExportPdf: TButton;
    btnCancel: TButton;
    btnExportExcel: TButton;
    SaveDialogExcel: TSaveDialog;
    SaveDialogPdf: TSaveDialog;
    procedure btnExportExcelClick(Sender: TObject);
    procedure btnExportPdfClick(Sender: TObject);
    procedure edCityKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
    procedure btnCancelClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    Cities: TDictionary<string, TLatLong>;
    procedure LoadCities;
    procedure Export(const SaveDialog: TSaveDialog; const ToPdf: boolean);
    function DataPath: string;
    function ReadData(const CityCoords: TLatLong; const OnLine: Boolean): string;
    function ReadOnlineData(const CityCoords: TLatLong): string;
    function GetCity(const Cities: TDictionary<string, TLatLong>; const CityName: string): TLatLong;
    function ReadOfflineData: string;
    function GetWeatherList(const dtStart: TDateTime; const xml: string): TWeatherList;
    function GetIcon(const Url: string; const UseOfflineData: boolean): TBytes;
    function LoadFileIcon(const FileName: string): TBytes;
    function LoadWebIcon(const Url: string): TBytes;
    function GetInvariantFormat: TFormatSettings;
    { Private declarations }
  public
    { Public declarations }
  end;

var
  MainForm: TMainForm;

implementation
uses
  FlexCel.VCLSupport, FlexCel.Core, FlexCel.XlsAdapter, FlexCel.Report, FlexCel.Render,
  ndfdXML, XSBuiltIns, DateUtils,
  IdHTTP, IdComponent,
  {$if CompilerVersion >= 23.0} System.UITypes, {$IFEND}
  IOUtils, StrUtils, ShellApi, XMLMapping;

{$R *.dfm}

procedure TMainForm.btnCancelClick(Sender: TObject);
begin
  Close;
end;

procedure TMainForm.btnExportExcelClick(Sender: TObject);
begin
  Export(SaveDialogExcel, false);
end;

procedure TMainForm.btnExportPdfClick(Sender: TObject);
begin
  Export(SaveDialogPdf, true);
end;

procedure TMainForm.edCityKeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
  edCity.DroppedDown := false;
end;

procedure TMainForm.FormCreate(Sender: TObject);
begin
  LoadCities;
end;

procedure TMainForm.FormDestroy(Sender: TObject);
begin
  Cities.Free;
end;

function TMainForm.DataPath: string;
begin
  Result := TPath.Combine(TPath.Combine(TPath.GetDirectoryName(ParamStr(0)),'..'),'..') + TPath.DirectorySeparatorChar;

end;

function TMainForm.GetInvariantFormat: TFormatSettings;
begin
  Result := TFormatSettings.Create('en-US');
end;

procedure TMainForm.LoadCities;
var
  xml: IXmlDocument;
  latLonList,
  cityNameList: IXMLNode;
  lats, cits: string;
  latsparsed,
  citsParsed,
  ll: TStringDynArray;
  i: Integer;
  Invariant: TFormatSettings;
begin
  Cities := TDictionary<string, TLatLong>.Create;
  Invariant := GetInvariantFormat;
  xml := TXmlDocument.Create(nil);

    xml.LoadFromFile(TPath.Combine(DataPath, 'cities.xml'));
    latLonList := xml.DocumentElement.ChildNodes.FindNode('latLonList');
    cityNameList := xml.DocumentElement.ChildNodes.FindNode('cityNameList');

    lats := latLonList.Text;
    cits := cityNameList.Text;

    latsParsed := SplitString(lats, ' ');
    citsParsed := SplitString(cits, '|');

    if Length(citsParsed) <> Length(latsParsed) then raise Exception.Create('Invalid city list');

    for i := 0 to Length(citsParsed) - 1 do
    begin
      ll := SplitString(latsParsed[i], ',');
      if (Length(ll) <> 2) then raise Exception.Create('Invalid city list');

      Cities.Add(citsParsed[i], TLatLong.Create(StrToCurr(ll[0], Invariant), StrToCurr(ll[1], Invariant)));
      edcity.Items.Add(citsParsed[i]);
    end;

    edCity.Text := 'New York,NY';

end;

function TMainForm.GetCity(const Cities: TDictionary<string, TLatLong>; const CityName: string): TLatLong;
begin
  if (not Cities.TryGetValue(CityName, Result)) then raise Exception.Create('Can''t find the city ' + CityName);
end;

function TMainForm.LoadFileIcon(const FileName: string): TBytes;
var
  fs: TFileStream;
begin
  fs := TFileStream.Create(FileName, fmOpenRead);
  try
    SetLength(Result, fs.Size);
    if (Length(Result) > 0) then fs.Read(Result[0], Length(Result));
  finally
    fs.Free;
  end;
end;

function TMainForm.LoadWebIcon(const Url: string): TBytes;
var
  Http: TIdHTTP;
  ms: TMemoryStream;
begin
  Http := TIdHTTP.Create(nil);
  try
    ms := TMemoryStream.Create;
    try
      Http.Get(Url, ms);
      SetLength(Result, ms.Size);
      ms.Position := 0;
      ms.Read(Result[0], Length(Result));
    finally
      ms.Free;
    end;
  finally
    Http.Free;
  end;
end;

function TMainForm.GetIcon(const Url: string; const UseOfflineData: boolean): TBytes;
begin
  if (Trim(url) = '') then exit(nil); //no image
  if UseOfflineData then Result := LoadFileIcon(TPath.Combine(DataPath, TPath.GetFileName(url)))
  else Result := LoadWebIcon(Url);

end;

function TMainForm.GetWeatherList(const dtStart: TDateTime; const xml: string): TWeatherList;
var
  doc: IXMLDocument;
  dwml: IXMLDwml;
  LowList,
  HighList: IXmlTempValTypeList;
  MinTemp, MaxTemp: double;
  Url: string;
  i, j, k, z: Integer;
  Invariant: TFormatSettings;

begin
  Invariant := GetInvariantFormat;

  doc := TXMLDocument.Create(nil);
  doc.LoadFromXML(xml);
  dwml := Getdwml(doc);
  Result := TWeatherList.Create();
  try
    for i := 0 to dwml.Data.Count - 1 do
    begin
      for j := 0 to dwml.Data[i].Parameters.Count - 1 do
      begin
        LowList := nil;
        HighList := nil;
        for k := 0 to dwml.Data[i].Parameters[j].Temperature.Count - 1 do
        begin
          if dwml.Data[i].Parameters[j].Temperature[k].Type_ = 'minimum'
            then LowList := dwml.Data[i].Parameters[j].Temperature[k].Value;
          if dwml.Data[i].Parameters[j].Temperature[k].Type_ = 'maximum'
            then HighList := dwml.Data[i].Parameters[j].Temperature[k].Value;

        end;

        if (LowList = nil) or (HighList = nil) then exit;

        for k := 0 to dwml.Data[i].Parameters[j].Conditionsicon.Count - 1 do
        begin
          for z := 0 to dwml.Data[i].Parameters[j].Conditionsicon[k].Iconlink.Count - 1 do
          begin
            if (z >= LowList.Count) or (z >= HighList.Count) then exit;

            MinTemp := 0;
            MaxTemp := 0;
            Url := dwml.Data[i].Parameters[j].Conditionsicon[k].Iconlink[z];
            if Trim(LowList[z].Text) <> '' then MinTemp := StrToFloat(LowList[z].Text, Invariant);
            if Trim(HighList[z].Text) <> '' then MaxTemp := StrToFloat(HighList[z].Text, Invariant);
            Result.Add(TWeather.Create(IncDay(dtStart, i),
                                       MinTemp,
                                       MaxTemp,
                                       GetIcon(Url, cbOffline.Checked)));
          end;
        end;

      end;
    end;
  Except
    Result.Free;
    raise;
  end;
end;

procedure TMainForm.Export(const SaveDialog: TSaveDialog; const ToPdf: boolean);
var
  Xls: TExcelFile;
  Pdf: TFlexCelPdfExport;
  Report: TFlexCelReport;
  CityCoords: TLatLong;
  Data: String;
  CityName: String;
  Weather: TWeatherList;
begin
  CityName := edCity.Text;
  CityCoords := GetCity(Cities, CityName);
  Data := ReadData(CityCoords, not cbOffline.Checked);

  if not SaveDialog.Execute then exit;

  Report := TFlexCelReport.Create(true);
  try
    Report.SetValue('Latitude', CityCoords.Latitude);
    Report.SetValue('Longitude', CityCoords.Longitude);
    Report.SetValue('Place', CityName);

    Weather := GetWeatherList(now, Data);
    try
      Report.AddTable<TWeather>('weather', Weather, TDisposeMode.DoNotDispose);
      if (ToPdf) then
      begin
        Xls := TXlsFile.Create(DataPath + 'Exporting Web Services.template.xls');
        try
          Report.Run(Xls);
          Pdf := TFlexCelPdfExport.Create(Xls, true);
          try
            Pdf.Export(SaveDialog.FileName);
          finally
            Pdf.Free;
          end;
        finally
          Xls.Free;
        end;
      end else
      begin
        Report.Run(DataPath + 'Exporting Web Services.template.xls', SaveDialog.FileName);
      end;
    finally
      Weather.Free;
    end;
  finally
    Report.Free;
  end;

  if MessageDlg('Do you want to open the generated file?', mtConfirmation, [mbYes, mbNo], 0) = mrYes then
  begin
    ShellExecute(0, 'open', PCHAR(SaveDialog.FileName), nil, nil, SW_SHOWNORMAL);
  end;

end;

function TMainForm.ReadData(const CityCoords: TLatLong;
  const OnLine: Boolean): string;
begin
  if Online then Result := ReadOnlineData(CityCoords)
  else Result := ReadOfflineData;
end;

function TMainForm.ReadOfflineData: string;
var
  fs: TFileStream;
  b: TBytes;
begin
  fs := TFileStream.Create(DataPath + 'OfflineData.xml', fmOpenRead);
  try
    SetLength(b, fs.Size);
    fs.Read(b[0], Length(b));
    Result := TEncoding.UTF8.GetString(b);
  finally
    fs.Free;
  end;

end;

function TMainForm.ReadOnlineData(const CityCoords: TLatLong): string;
var
  nf: ndfdXMLPortType;
  dtNow: TDateTime;
  dtStart, dtEnd: TXSDateTime;
  wp: weatherParametersType;
  Lat, Long: TXSDecimal;
  Invariant: TFormatSettings;
begin
  Invariant := GetInvariantFormat;
  dtNow := now;
  dtStart := nil;
  dtEnd := nil;
  Lat := nil;
  Long := nil;
  try
    dtStart := TXSDateTime.Create;
    dtStart.AsDateTime := dtNow;
    dtEnd := TXSDateTime.Create;
    dtEnd.AsDateTime := IncDay(dtNow, 7);


    Lat := TXSDecimal.Create;
    Lat.XSToNative(CurrToStr(CityCoords.Latitude, Invariant));

    Long := TXSDecimal.Create;
    Long.XSToNative(CurrToStr(CityCoords.Longitude, Invariant));

    nf := GetndfdXMLPortType;
    wp := weatherParametersType.Create;
    try
      Result := nf.NDFDgen(Lat, Long, productType.glance, dtStart, dtEnd, unitType.m, wp);
    finally
      wp.Free;
    end;
  finally
    dtStart.Free;
    dtEnd.Free;
    Lat.Free;
    Long.Free;
  end;
end;

end.

XMLMapping.pas

{*****************************************************************************************************************************}
{                                                                                                                             }
{                                                      XML Data Binding                                                       }
{                                                                                                                             }
{         Generated on: 25/09/2014 23:11:50                                                                                   }
{       Generated from: http://graphical.weather.gov/xml/DWMLgen/schema/DWML.xsd                                              }
{                                                                                                                             }
{*****************************************************************************************************************************}

unit XMLMapping;

interface

uses xmldom, XMLDoc, XMLIntf;

type

{ Forward Decls }

  IXMLDwml = interface;
  IXMLHeadType = interface;
  IXMLProductType = interface;
  IXMLCreationdateType = interface;
  IXMLSourceType = interface;
  IXMLProductioncenterType = interface;
  IXMLDataType = interface;
  IXMLDataTypeList = interface;
  IXMLLocationType = interface;
  IXMLLocationTypeList = interface;
  IXMLPointType = interface;
  IXMLNwszoneType = interface;
  IXMLAreaType = interface;
  IXMLCircleType = interface;
  IXMLRadiusType = interface;
  IXMLRectangleType = interface;
  IXMLCityType = interface;
  IXMLHeightType = interface;
  IXMLLevelType = interface;
  IXMLLayerType = interface;
  IXMLMoreWeatherInformationType = interface;
  IXMLMoreWeatherInformationTypeList = interface;
  IXMLTimelayoutElementType = interface;
  IXMLTimelayoutElementTypeList = interface;
  IXMLStartvalidtimeType = interface;
  IXMLStartvalidtimeTypeList = interface;
  IXMLParametersType = interface;
  IXMLParametersTypeList = interface;
  IXMLCategoriesType = interface;
  IXMLCategoriesTypeList = interface;
  IXMLValueListType = interface;
  IXMLValueListTypeList = interface;
  IXMLTemperature = interface;
  IXMLTemperatureList = interface;
  IXMLTempValType = interface;
  IXMLTempValTypeList = interface;
  IXMLValueWithUncertainty = interface;
  IXMLValueWithUncertaintyList = interface;
  IXMLUncertaintyType = interface;
  IXMLError = interface;
  IXMLPrecipitation = interface;
  IXMLPrecipitationList = interface;
  IXMLDecimalValType = interface;
  IXMLDecimalValTypeList = interface;
  IXMLProbabilityofprecipitation = interface;
  IXMLProbabilityofprecipitationList = interface;
  IXMLPercentageValType = interface;
  IXMLPercentageValTypeList = interface;
  IXMLFireweather = interface;
  IXMLFireweatherList = interface;
  IXMLConvectivehazard = interface;
  IXMLConvectivehazardList = interface;
  IXMLOutlook = interface;
  IXMLSeverecomponent = interface;
  IXMLSeverecomponentList = interface;
  IXMLValue = interface;
  IXMLValueList = interface;
  IXMLClimateanomaly = interface;
  IXMLClimateanomalyList = interface;
  IXMLAnomalyType = interface;
  IXMLAnomalyTypeList = interface;
  IXMLWindspeed = interface;
  IXMLWindspeedList = interface;
  IXMLWspdValType = interface;
  IXMLWspdValTypeList = interface;
  IXMLDirection = interface;
  IXMLDirectionList = interface;
  IXMLWdirValType = interface;
  IXMLWdirValTypeList = interface;
  IXMLCloudamount = interface;
  IXMLCloudamountList = interface;
  IXMLHumidity = interface;
  IXMLHumidityList = interface;
  IXMLWeather = interface;
  IXMLWeatherList = interface;
  IXMLWeatherconditions = interface;
  IXMLWeatherconditionsList = interface;
  IXMLConditionsicon = interface;
  IXMLConditionsiconList = interface;
  IXMLHazards = interface;
  IXMLHazardsList = interface;
  IXMLHazardconditions = interface;
  IXMLHazardconditionsList = interface;
  IXMLHazard = interface;
  IXMLWordedForecast = interface;
  IXMLPressure = interface;
  IXMLPressureList = interface;
  IXMLProbabilisticCondition = interface;
  IXMLProbabilisticConditionList = interface;
  IXMLValueForRangeType = interface;
  IXMLValueForRangeTypeList = interface;
  IXMLWaterstate = interface;
  IXMLWaterstateList = interface;
  IXMLWaves = interface;
  IXMLWavesList = interface;
  IXMLSwell = interface;
  IXMLSwellList = interface;
  IXMLSeas = interface;
  IXMLSeasList = interface;
  IXMLNonNegativeIntegerList = interface;
  IXMLDateTimeList = interface;
  IXMLAnyURIList = interface;
  IXMLString_List = interface;

{ IXMLDwml }

  IXMLDwml = interface(IXMLNode)
    ['{E2FA236E-2095-4A07-B755-5B9EF9F502C3}']
    { Property Accessors }
    function Get_Version: UnicodeString;
    function Get_Head: IXMLHeadType;
    function Get_Data: IXMLDataTypeList;
    function Get_MinResolution: UnicodeString;
    function Get_LatLonList: UnicodeString;
    function Get_CityNameList: UnicodeString;
    procedure Set_Version(Value: UnicodeString);
    procedure Set_MinResolution(Value: UnicodeString);
    procedure Set_LatLonList(Value: UnicodeString);
    procedure Set_CityNameList(Value: UnicodeString);
    { Methods & Properties }
    property Version: UnicodeString read Get_Version write Set_Version;
    property Head: IXMLHeadType read Get_Head;
    property Data: IXMLDataTypeList read Get_Data;
    property MinResolution: UnicodeString read Get_MinResolution write Set_MinResolution;
    property LatLonList: UnicodeString read Get_LatLonList write Set_LatLonList;
    property CityNameList: UnicodeString read Get_CityNameList write Set_CityNameList;
  end;

{ IXMLHeadType }

  IXMLHeadType = interface(IXMLNode)
    ['{49A96FB4-A869-43F0-A89C-678B20B90563}']
    { Property Accessors }
    function Get_Product: IXMLProductType;
    function Get_Source: IXMLSourceType;
    { Methods & Properties }
    property Product: IXMLProductType read Get_Product;
    property Source: IXMLSourceType read Get_Source;
  end;

{ IXMLProductType }

  IXMLProductType = interface(IXMLNode)
    ['{C53D23ED-40C7-4F42-AFB3-E46CA1AA2F2E}']
    { Property Accessors }
    function Get_Concisename: UnicodeString;
    function Get_Operationalmode: UnicodeString;
    function Get_SrsName: UnicodeString;
    function Get_Title: UnicodeString;
    function Get_Field: UnicodeString;
    function Get_Category: UnicodeString;
    function Get_Creationdate: IXMLCreationdateType;
    procedure Set_Concisename(Value: UnicodeString);
    procedure Set_Operationalmode(Value: UnicodeString);
    procedure Set_SrsName(Value: UnicodeString);
    procedure Set_Title(Value: UnicodeString);
    procedure Set_Field(Value: UnicodeString);
    procedure Set_Category(Value: UnicodeString);
    { Methods & Properties }
    property Concisename: UnicodeString read Get_Concisename write Set_Concisename;
    property Operationalmode: UnicodeString read Get_Operationalmode write Set_Operationalmode;
    property SrsName: UnicodeString read Get_SrsName write Set_SrsName;
    property Title: UnicodeString read Get_Title write Set_Title;
    property Field: UnicodeString read Get_Field write Set_Field;
    property Category: UnicodeString read Get_Category write Set_Category;
    property Creationdate: IXMLCreationdateType read Get_Creationdate;
  end;

{ IXMLCreationdateType }

  IXMLCreationdateType = interface(IXMLNode)
    ['{298426AA-5763-4682-81C9-ED38796884CB}']
    { Property Accessors }
    function Get_Refreshfrequency: UnicodeString;
    procedure Set_Refreshfrequency(Value: UnicodeString);
    { Methods & Properties }
    property Refreshfrequency: UnicodeString read Get_Refreshfrequency write Set_Refreshfrequency;
  end;

{ IXMLSourceType }

  IXMLSourceType = interface(IXMLNode)
    ['{B59A0976-F9B8-4BE5-A049-1F01A79739EA}']
    { Property Accessors }
    function Get_Moreinformation: UnicodeString;
    function Get_Productioncenter: IXMLProductioncenterType;
    function Get_Disclaimer: UnicodeString;
    function Get_Credit: UnicodeString;
    function Get_Creditlogo: UnicodeString;
    function Get_Feedback: UnicodeString;
    procedure Set_Moreinformation(Value: UnicodeString);
    procedure Set_Disclaimer(Value: UnicodeString);
    procedure Set_Credit(Value: UnicodeString);
    procedure Set_Creditlogo(Value: UnicodeString);
    procedure Set_Feedback(Value: UnicodeString);
    { Methods & Properties }
    property Moreinformation: UnicodeString read Get_Moreinformation write Set_Moreinformation;
    property Productioncenter: IXMLProductioncenterType read Get_Productioncenter;
    property Disclaimer: UnicodeString read Get_Disclaimer write Set_Disclaimer;
    property Credit: UnicodeString read Get_Credit write Set_Credit;
    property Creditlogo: UnicodeString read Get_Creditlogo write Set_Creditlogo;
    property Feedback: UnicodeString read Get_Feedback write Set_Feedback;
  end;

{ IXMLProductioncenterType }

  IXMLProductioncenterType = interface(IXMLNode)
    ['{074FA7D0-9D66-4209-963C-DF50DB30AB13}']
    { Property Accessors }
    function Get_Subcenter: UnicodeString;
    procedure Set_Subcenter(Value: UnicodeString);
    { Methods & Properties }
    property Subcenter: UnicodeString read Get_Subcenter write Set_Subcenter;
  end;

{ IXMLDataType }

  IXMLDataType = interface(IXMLNode)
    ['{A3A07AA7-B64C-4A78-81AC-C8DAD6A266A8}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Location: IXMLLocationTypeList;
    function Get_MoreWeatherInformation: IXMLMoreWeatherInformationTypeList;
    function Get_Timelayout: IXMLTimelayoutElementTypeList;
    function Get_Parameters: IXMLParametersTypeList;
    procedure Set_Type_(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Location: IXMLLocationTypeList read Get_Location;
    property MoreWeatherInformation: IXMLMoreWeatherInformationTypeList read Get_MoreWeatherInformation;
    property Timelayout: IXMLTimelayoutElementTypeList read Get_Timelayout;
    property Parameters: IXMLParametersTypeList read Get_Parameters;
  end;

{ IXMLDataTypeList }

  IXMLDataTypeList = interface(IXMLNodeCollection)
    ['{3CE23E73-3851-470E-B22A-33743DAF015B}']
    { Methods & Properties }
    function Add: IXMLDataType;
    function Insert(const Index: Integer): IXMLDataType;

    function Get_Item(Index: Integer): IXMLDataType;
    property Items[Index: Integer]: IXMLDataType read Get_Item; default;
  end;

{ IXMLLocationType }

  IXMLLocationType = interface(IXMLNode)
    ['{A47559A0-CEA0-415E-BE00-783BFCEA08F2}']
    { Property Accessors }
    function Get_Locationkey: UnicodeString;
    function Get_Description: UnicodeString;
    function Get_Point: IXMLPointType;
    function Get_Nwszone: IXMLNwszoneType;
    function Get_Area: IXMLAreaType;
    function Get_City: IXMLCityType;
    function Get_Areadescription: UnicodeString;
    function Get_Height: IXMLHeightType;
    function Get_Level: IXMLLevelType;
    function Get_Layer: IXMLLayerType;
    procedure Set_Locationkey(Value: UnicodeString);
    procedure Set_Description(Value: UnicodeString);
    procedure Set_Areadescription(Value: UnicodeString);
    { Methods & Properties }
    property Locationkey: UnicodeString read Get_Locationkey write Set_Locationkey;
    property Description: UnicodeString read Get_Description write Set_Description;
    property Point: IXMLPointType read Get_Point;
    property Nwszone: IXMLNwszoneType read Get_Nwszone;
    property Area: IXMLAreaType read Get_Area;
    property City: IXMLCityType read Get_City;
    property Areadescription: UnicodeString read Get_Areadescription write Set_Areadescription;
    property Height: IXMLHeightType read Get_Height;
    property Level: IXMLLevelType read Get_Level;
    property Layer: IXMLLayerType read Get_Layer;
  end;

{ IXMLLocationTypeList }

  IXMLLocationTypeList = interface(IXMLNodeCollection)
    ['{56EF8DD3-A574-40F5-905C-F4B7C4F86979}']
    { Methods & Properties }
    function Add: IXMLLocationType;
    function Insert(const Index: Integer): IXMLLocationType;

    function Get_Item(Index: Integer): IXMLLocationType;
    property Items[Index: Integer]: IXMLLocationType read Get_Item; default;
  end;

{ IXMLPointType }

  IXMLPointType = interface(IXMLNode)
    ['{E22CB1AE-B403-4C3A-A2B7-FED9027D062D}']
    { Property Accessors }
    function Get_Latitude: UnicodeString;
    function Get_Longitude: UnicodeString;
    function Get_Summarization: UnicodeString;
    procedure Set_Latitude(Value: UnicodeString);
    procedure Set_Longitude(Value: UnicodeString);
    procedure Set_Summarization(Value: UnicodeString);
    { Methods & Properties }
    property Latitude: UnicodeString read Get_Latitude write Set_Latitude;
    property Longitude: UnicodeString read Get_Longitude write Set_Longitude;
    property Summarization: UnicodeString read Get_Summarization write Set_Summarization;
  end;

{ IXMLNwszoneType }

  IXMLNwszoneType = interface(IXMLNode)
    ['{F4A7A734-43CD-4E02-A036-25B2FDBB5119}']
    { Property Accessors }
    function Get_State: UnicodeString;
    function Get_Summarization: UnicodeString;
    procedure Set_State(Value: UnicodeString);
    procedure Set_Summarization(Value: UnicodeString);
    { Methods & Properties }
    property State: UnicodeString read Get_State write Set_State;
    property Summarization: UnicodeString read Get_Summarization write Set_Summarization;
  end;

{ IXMLAreaType }

  IXMLAreaType = interface(IXMLNode)
    ['{F604E0F9-9C8E-438E-8505-5AA606C61728}']
    { Property Accessors }
    function Get_Areatype: UnicodeString;
    function Get_Circle: IXMLCircleType;
    function Get_Rectangle: IXMLRectangleType;
    procedure Set_Areatype(Value: UnicodeString);
    { Methods & Properties }
    property Areatype: UnicodeString read Get_Areatype write Set_Areatype;
    property Circle: IXMLCircleType read Get_Circle;
    property Rectangle: IXMLRectangleType read Get_Rectangle;
  end;

{ IXMLCircleType }

  IXMLCircleType = interface(IXMLNode)
    ['{7F094A52-BB6D-457F-81E0-35A13D0F3B4B}']
    { Property Accessors }
    function Get_Summarization: UnicodeString;
    function Get_Point: IXMLPointType;
    function Get_Radius: IXMLRadiusType;
    procedure Set_Summarization(Value: UnicodeString);
    { Methods & Properties }
    property Summarization: UnicodeString read Get_Summarization write Set_Summarization;
    property Point: IXMLPointType read Get_Point;
    property Radius: IXMLRadiusType read Get_Radius;
  end;

{ IXMLRadiusType }

  IXMLRadiusType = interface(IXMLNode)
    ['{8113FF8E-9F22-4F18-8E6F-56A38E7F3811}']
    { Property Accessors }
    function Get_Radiusunits: UnicodeString;
    procedure Set_Radiusunits(Value: UnicodeString);
    { Methods & Properties }
    property Radiusunits: UnicodeString read Get_Radiusunits write Set_Radiusunits;
  end;

{ IXMLRectangleType }

  IXMLRectangleType = interface(IXMLNodeCollection)
    ['{93F85AA2-4466-4D09-B6ED-4CCBD2220559}']
    { Property Accessors }
    function Get_Summarization: UnicodeString;
    function Get_Point(Index: Integer): IXMLPointType;
    procedure Set_Summarization(Value: UnicodeString);
    { Methods & Properties }
    function Add: IXMLPointType;
    function Insert(const Index: Integer): IXMLPointType;
    property Summarization: UnicodeString read Get_Summarization write Set_Summarization;
    property Point[Index: Integer]: IXMLPointType read Get_Point; default;
  end;

{ IXMLCityType }

  IXMLCityType = interface(IXMLNode)
    ['{E4150AE8-0D4E-463E-B4AF-2A190173E87B}']
    { Property Accessors }
    function Get_State: UnicodeString;
    function Get_Summarization: UnicodeString;
    procedure Set_State(Value: UnicodeString);
    procedure Set_Summarization(Value: UnicodeString);
    { Methods & Properties }
    property State: UnicodeString read Get_State write Set_State;
    property Summarization: UnicodeString read Get_Summarization write Set_Summarization;
  end;

{ IXMLHeightType }

  IXMLHeightType = interface(IXMLNode)
    ['{2F6C61DE-A1A9-4D2A-B043-3A1BC35121C1}']
    { Property Accessors }
    function Get_Datum: UnicodeString;
    function Get_Heightunits: UnicodeString;
    procedure Set_Datum(Value: UnicodeString);
    procedure Set_Heightunits(Value: UnicodeString);
    { Methods & Properties }
    property Datum: UnicodeString read Get_Datum write Set_Datum;
    property Heightunits: UnicodeString read Get_Heightunits write Set_Heightunits;
  end;

{ IXMLLevelType }

  IXMLLevelType = interface(IXMLNode)
    ['{8AB3896F-43A5-425E-8814-75CA30D08BE1}']
    { Property Accessors }
    function Get_Verticalcoordinate: UnicodeString;
    procedure Set_Verticalcoordinate(Value: UnicodeString);
    { Methods & Properties }
    property Verticalcoordinate: UnicodeString read Get_Verticalcoordinate write Set_Verticalcoordinate;
  end;

{ IXMLLayerType }

  IXMLLayerType = interface(IXMLNode)
    ['{89B97DC3-0B05-4C56-81CD-5E1A9E6E3675}']
    { Property Accessors }
    function Get_Verticalcoordinate: UnicodeString;
    procedure Set_Verticalcoordinate(Value: UnicodeString);
    { Methods & Properties }
    property Verticalcoordinate: UnicodeString read Get_Verticalcoordinate write Set_Verticalcoordinate;
  end;

{ IXMLMoreWeatherInformationType }

  IXMLMoreWeatherInformationType = interface(IXMLNode)
    ['{6330AEA8-C7BA-44C8-B252-1E5925B5E3F5}']
    { Property Accessors }
    function Get_Applicablelocation: UnicodeString;
    procedure Set_Applicablelocation(Value: UnicodeString);
    { Methods & Properties }
    property Applicablelocation: UnicodeString read Get_Applicablelocation write Set_Applicablelocation;
  end;

{ IXMLMoreWeatherInformationTypeList }

  IXMLMoreWeatherInformationTypeList = interface(IXMLNodeCollection)
    ['{A039DFDD-9176-4878-AB30-9174CA2C23B4}']
    { Methods & Properties }
    function Add: IXMLMoreWeatherInformationType;
    function Insert(const Index: Integer): IXMLMoreWeatherInformationType;

    function Get_Item(Index: Integer): IXMLMoreWeatherInformationType;
    property Items[Index: Integer]: IXMLMoreWeatherInformationType read Get_Item; default;
  end;

{ IXMLTimelayoutElementType }

  IXMLTimelayoutElementType = interface(IXMLNode)
    ['{25C3A58B-2141-4344-8AE8-1E20C5DBA950}']
    { Property Accessors }
    function Get_Timecoordinate: UnicodeString;
    function Get_Summarization: UnicodeString;
    function Get_Layoutkey: UnicodeString;
    function Get_Startvalidtime: IXMLStartvalidtimeTypeList;
    function Get_Endvalidtime: IXMLDateTimeList;
    procedure Set_Timecoordinate(Value: UnicodeString);
    procedure Set_Summarization(Value: UnicodeString);
    procedure Set_Layoutkey(Value: UnicodeString);
    { Methods & Properties }
    property Timecoordinate: UnicodeString read Get_Timecoordinate write Set_Timecoordinate;
    property Summarization: UnicodeString read Get_Summarization write Set_Summarization;
    property Layoutkey: UnicodeString read Get_Layoutkey write Set_Layoutkey;
    property Startvalidtime: IXMLStartvalidtimeTypeList read Get_Startvalidtime;
    property Endvalidtime: IXMLDateTimeList read Get_Endvalidtime;
  end;

{ IXMLTimelayoutElementTypeList }

  IXMLTimelayoutElementTypeList = interface(IXMLNodeCollection)
    ['{9208F31D-5150-4041-A61F-C43923DD24AF}']
    { Methods & Properties }
    function Add: IXMLTimelayoutElementType;
    function Insert(const Index: Integer): IXMLTimelayoutElementType;

    function Get_Item(Index: Integer): IXMLTimelayoutElementType;
    property Items[Index: Integer]: IXMLTimelayoutElementType read Get_Item; default;
  end;

{ IXMLStartvalidtimeType }

  IXMLStartvalidtimeType = interface(IXMLNode)
    ['{2168E6E5-FB41-436C-A3CB-F30FF4458AC4}']
    { Property Accessors }
    function Get_Periodname: UnicodeString;
    procedure Set_Periodname(Value: UnicodeString);
    { Methods & Properties }
    property Periodname: UnicodeString read Get_Periodname write Set_Periodname;
  end;

{ IXMLStartvalidtimeTypeList }

  IXMLStartvalidtimeTypeList = interface(IXMLNodeCollection)
    ['{6F062C79-EB7F-4B14-B489-C542AD481C07}']
    { Methods & Properties }
    function Add: IXMLStartvalidtimeType;
    function Insert(const Index: Integer): IXMLStartvalidtimeType;

    function Get_Item(Index: Integer): IXMLStartvalidtimeType;
    property Items[Index: Integer]: IXMLStartvalidtimeType read Get_Item; default;
  end;

{ IXMLParametersType }

  IXMLParametersType = interface(IXMLNode)
    ['{3979E775-2545-46A5-A147-5906A336FDB4}']
    { Property Accessors }
    function Get_Applicablelocation: UnicodeString;
    function Get_Categories: IXMLCategoriesTypeList;
    function Get_Temperature: IXMLTemperatureList;
    function Get_Precipitation: IXMLPrecipitationList;
    function Get_Probabilityofprecipitation: IXMLProbabilityofprecipitationList;
    function Get_Fireweather: IXMLFireweatherList;
    function Get_Convectivehazard: IXMLConvectivehazardList;
    function Get_Climateanomaly: IXMLClimateanomalyList;
    function Get_Windspeed: IXMLWindspeedList;
    function Get_Direction: IXMLDirectionList;
    function Get_Cloudamount: IXMLCloudamountList;
    function Get_Humidity: IXMLHumidityList;
    function Get_Weather: IXMLWeatherList;
    function Get_Conditionsicon: IXMLConditionsiconList;
    function Get_Hazards: IXMLHazardsList;
    function Get_WordedForecast: IXMLWordedForecast;
    function Get_Pressure: IXMLPressureList;
    function Get_ProbabilisticCondition: IXMLProbabilisticConditionList;
    function Get_Waterstate: IXMLWaterstateList;
    procedure Set_Applicablelocation(Value: UnicodeString);
    { Methods & Properties }
    property Applicablelocation: UnicodeString read Get_Applicablelocation write Set_Applicablelocation;
    property Categories: IXMLCategoriesTypeList read Get_Categories;
    property Temperature: IXMLTemperatureList read Get_Temperature;
    property Precipitation: IXMLPrecipitationList read Get_Precipitation;
    property Probabilityofprecipitation: IXMLProbabilityofprecipitationList read Get_Probabilityofprecipitation;
    property Fireweather: IXMLFireweatherList read Get_Fireweather;
    property Convectivehazard: IXMLConvectivehazardList read Get_Convectivehazard;
    property Climateanomaly: IXMLClimateanomalyList read Get_Climateanomaly;
    property Windspeed: IXMLWindspeedList read Get_Windspeed;
    property Direction: IXMLDirectionList read Get_Direction;
    property Cloudamount: IXMLCloudamountList read Get_Cloudamount;
    property Humidity: IXMLHumidityList read Get_Humidity;
    property Weather: IXMLWeatherList read Get_Weather;
    property Conditionsicon: IXMLConditionsiconList read Get_Conditionsicon;
    property Hazards: IXMLHazardsList read Get_Hazards;
    property WordedForecast: IXMLWordedForecast read Get_WordedForecast;
    property Pressure: IXMLPressureList read Get_Pressure;
    property ProbabilisticCondition: IXMLProbabilisticConditionList read Get_ProbabilisticCondition;
    property Waterstate: IXMLWaterstateList read Get_Waterstate;
  end;

{ IXMLParametersTypeList }

  IXMLParametersTypeList = interface(IXMLNodeCollection)
    ['{774E83F2-E0C6-41E9-AFAF-61D3D14C39CB}']
    { Methods & Properties }
    function Add: IXMLParametersType;
    function Insert(const Index: Integer): IXMLParametersType;

    function Get_Item(Index: Integer): IXMLParametersType;
    property Items[Index: Integer]: IXMLParametersType read Get_Item; default;
  end;

{ IXMLCategoriesType }

  IXMLCategoriesType = interface(IXMLNode)
    ['{D6F637A6-6A5D-4BC8-BA9C-545BBE17CFDD}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Probabilitytype: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Categorieskey: UnicodeString;
    function Get_ValueList: IXMLValueListType;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Probabilitytype(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    procedure Set_Categorieskey(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Probabilitytype: UnicodeString read Get_Probabilitytype write Set_Probabilitytype;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Categorieskey: UnicodeString read Get_Categorieskey write Set_Categorieskey;
    property ValueList: IXMLValueListType read Get_ValueList;
  end;

{ IXMLCategoriesTypeList }

  IXMLCategoriesTypeList = interface(IXMLNodeCollection)
    ['{27864505-4C68-4E84-B3D8-3461F4821702}']
    { Methods & Properties }
    function Add: IXMLCategoriesType;
    function Insert(const Index: Integer): IXMLCategoriesType;

    function Get_Item(Index: Integer): IXMLCategoriesType;
    property Items[Index: Integer]: IXMLCategoriesType read Get_Item; default;
  end;

{ IXMLValueListType }

  IXMLValueListType = interface(IXMLNode)
    ['{2FEC65A6-4003-4F63-A899-F9E86751A5C8}']
    { Property Accessors }
    function Get_Median: UnicodeString;
    function Get_ConfidenceInterval50: UnicodeString;
    function Get_ConfidenceInterval80: UnicodeString;
    function Get_Skew80: UnicodeString;
    procedure Set_Median(Value: UnicodeString);
    procedure Set_ConfidenceInterval50(Value: UnicodeString);
    procedure Set_ConfidenceInterval80(Value: UnicodeString);
    procedure Set_Skew80(Value: UnicodeString);
    { Methods & Properties }
    property Median: UnicodeString read Get_Median write Set_Median;
    property ConfidenceInterval50: UnicodeString read Get_ConfidenceInterval50 write Set_ConfidenceInterval50;
    property ConfidenceInterval80: UnicodeString read Get_ConfidenceInterval80 write Set_ConfidenceInterval80;
    property Skew80: UnicodeString read Get_Skew80 write Set_Skew80;
  end;

{ IXMLValueListTypeList }

  IXMLValueListTypeList = interface(IXMLNodeCollection)
    ['{51D51DBF-84B1-4BA3-975A-624BAF4A76BF}']
    { Methods & Properties }
    function Add: IXMLValueListType;
    function Insert(const Index: Integer): IXMLValueListType;

    function Get_Item(Index: Integer): IXMLValueListType;
    property Items[Index: Integer]: IXMLValueListType read Get_Item; default;
  end;

{ IXMLTemperature }

  IXMLTemperature = interface(IXMLNode)
    ['{2639DD19-20A7-4468-88B8-DB5BE94B97F0}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_LikelihoodUnits: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Applicablecategories: UnicodeString;
    function Get_Probabilitytype: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLTempValTypeList;
    function Get_ValueList: IXMLValueListTypeList;
    function Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_LikelihoodUnits(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Applicablecategories(Value: UnicodeString);
    procedure Set_Probabilitytype(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property LikelihoodUnits: UnicodeString read Get_LikelihoodUnits write Set_LikelihoodUnits;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Applicablecategories: UnicodeString read Get_Applicablecategories write Set_Applicablecategories;
    property Probabilitytype: UnicodeString read Get_Probabilitytype write Set_Probabilitytype;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLTempValTypeList read Get_Value;
    property ValueList: IXMLValueListTypeList read Get_ValueList;
    property ValueWithUncertainty: IXMLValueWithUncertaintyList read Get_ValueWithUncertainty;
  end;

{ IXMLTemperatureList }

  IXMLTemperatureList = interface(IXMLNodeCollection)
    ['{948DABB9-E2C2-4FE8-9CA5-7F90C301DC62}']
    { Methods & Properties }
    function Add: IXMLTemperature;
    function Insert(const Index: Integer): IXMLTemperature;

    function Get_Item(Index: Integer): IXMLTemperature;
    property Items[Index: Integer]: IXMLTemperature read Get_Item; default;
  end;

{ IXMLTempValType }

  IXMLTempValType = interface(IXMLNode)
    ['{F205CEDA-1353-4248-9E2B-A9CEC528FC8A}']
    { Property Accessors }
    function Get_Upperrange: Integer;
    function Get_Lowerrange: Integer;
    function Get_Type_: UnicodeString;
    procedure Set_Upperrange(Value: Integer);
    procedure Set_Lowerrange(Value: Integer);
    procedure Set_Type_(Value: UnicodeString);
    { Methods & Properties }
    property Upperrange: Integer read Get_Upperrange write Set_Upperrange;
    property Lowerrange: Integer read Get_Lowerrange write Set_Lowerrange;
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
  end;

{ IXMLTempValTypeList }

  IXMLTempValTypeList = interface(IXMLNodeCollection)
    ['{AF4660AD-0732-490A-9F60-7213AE03548B}']
    { Methods & Properties }
    function Add: IXMLTempValType;
    function Insert(const Index: Integer): IXMLTempValType;

    function Get_Item(Index: Integer): IXMLTempValType;
    property Items[Index: Integer]: IXMLTempValType read Get_Item; default;
  end;

{ IXMLValueWithUncertainty }

  IXMLValueWithUncertainty = interface(IXMLNode)
    ['{95BCCDC0-A5A1-4757-9714-B0F098527BBF}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Value: IXMLTempValType;
    function Get_Uncertainty: IXMLUncertaintyType;
    function Get_NumberWithEquality: UnicodeString;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_NumberWithEquality(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Value: IXMLTempValType read Get_Value;
    property Uncertainty: IXMLUncertaintyType read Get_Uncertainty;
    property NumberWithEquality: UnicodeString read Get_NumberWithEquality write Set_NumberWithEquality;
  end;

{ IXMLValueWithUncertaintyList }

  IXMLValueWithUncertaintyList = interface(IXMLNodeCollection)
    ['{BBA2FF18-91B3-4A67-AD36-9C26829EA4CD}']
    { Methods & Properties }
    function Add: IXMLValueWithUncertainty;
    function Insert(const Index: Integer): IXMLValueWithUncertainty;

    function Get_Item(Index: Integer): IXMLValueWithUncertainty;
    property Items[Index: Integer]: IXMLValueWithUncertainty read Get_Item; default;
  end;

{ IXMLUncertaintyType }

  IXMLUncertaintyType = interface(IXMLNode)
    ['{EBC6D20E-F28D-4D26-B0A1-4F016C0B0057}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Error: IXMLError;
    procedure Set_Type_(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Error: IXMLError read Get_Error;
  end;

{ IXMLError }

  IXMLError = interface(IXMLNode)
    ['{3322E9EA-3C48-4C25-AAFC-49EE68AA405C}']
    { Property Accessors }
    function Get_Qualifier: UnicodeString;
    procedure Set_Qualifier(Value: UnicodeString);
    { Methods & Properties }
    property Qualifier: UnicodeString read Get_Qualifier write Set_Qualifier;
  end;

{ IXMLPrecipitation }

  IXMLPrecipitation = interface(IXMLNode)
    ['{534400A7-4778-46FE-846A-DD576A965FE2}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_LikelihoodUnits: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Probabilitytype: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLDecimalValTypeList;
    function Get_ValueList: IXMLValueListTypeList;
    function Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_LikelihoodUnits(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Probabilitytype(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property LikelihoodUnits: UnicodeString read Get_LikelihoodUnits write Set_LikelihoodUnits;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Probabilitytype: UnicodeString read Get_Probabilitytype write Set_Probabilitytype;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLDecimalValTypeList read Get_Value;
    property ValueList: IXMLValueListTypeList read Get_ValueList;
    property ValueWithUncertainty: IXMLValueWithUncertaintyList read Get_ValueWithUncertainty;
  end;

{ IXMLPrecipitationList }

  IXMLPrecipitationList = interface(IXMLNodeCollection)
    ['{4AD8B55B-5148-4F35-9051-72DB33F3D90B}']
    { Methods & Properties }
    function Add: IXMLPrecipitation;
    function Insert(const Index: Integer): IXMLPrecipitation;

    function Get_Item(Index: Integer): IXMLPrecipitation;
    property Items[Index: Integer]: IXMLPrecipitation read Get_Item; default;
  end;

{ IXMLDecimalValType }

  IXMLDecimalValType = interface(IXMLNode)
    ['{6B812AA1-D328-4EF3-AB8B-4996C74D4579}']
    { Property Accessors }
    function Get_Upperrange: LongWord;
    function Get_Lowerrange: LongWord;
    function Get_Type_: UnicodeString;
    procedure Set_Upperrange(Value: LongWord);
    procedure Set_Lowerrange(Value: LongWord);
    procedure Set_Type_(Value: UnicodeString);
    { Methods & Properties }
    property Upperrange: LongWord read Get_Upperrange write Set_Upperrange;
    property Lowerrange: LongWord read Get_Lowerrange write Set_Lowerrange;
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
  end;

{ IXMLDecimalValTypeList }

  IXMLDecimalValTypeList = interface(IXMLNodeCollection)
    ['{90C97817-D880-4BA8-A713-7E928718FFD5}']
    { Methods & Properties }
    function Add: IXMLDecimalValType;
    function Insert(const Index: Integer): IXMLDecimalValType;

    function Get_Item(Index: Integer): IXMLDecimalValType;
    property Items[Index: Integer]: IXMLDecimalValType read Get_Item; default;
  end;

{ IXMLProbabilityofprecipitation }

  IXMLProbabilityofprecipitation = interface(IXMLNode)
    ['{9824090F-3202-4A96-AD04-1B22FAD3DC2B}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_LikelihoodUnits: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Applicablecategories: UnicodeString;
    function Get_Probabilitytype: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLPercentageValTypeList;
    function Get_ValueList: IXMLValueListTypeList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_LikelihoodUnits(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Applicablecategories(Value: UnicodeString);
    procedure Set_Probabilitytype(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property LikelihoodUnits: UnicodeString read Get_LikelihoodUnits write Set_LikelihoodUnits;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Applicablecategories: UnicodeString read Get_Applicablecategories write Set_Applicablecategories;
    property Probabilitytype: UnicodeString read Get_Probabilitytype write Set_Probabilitytype;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLPercentageValTypeList read Get_Value;
    property ValueList: IXMLValueListTypeList read Get_ValueList;
  end;

{ IXMLProbabilityofprecipitationList }

  IXMLProbabilityofprecipitationList = interface(IXMLNodeCollection)
    ['{46275599-309E-48FF-90E8-DEB126362061}']
    { Methods & Properties }
    function Add: IXMLProbabilityofprecipitation;
    function Insert(const Index: Integer): IXMLProbabilityofprecipitation;

    function Get_Item(Index: Integer): IXMLProbabilityofprecipitation;
    property Items[Index: Integer]: IXMLProbabilityofprecipitation read Get_Item; default;
  end;

{ IXMLPercentageValType }

  IXMLPercentageValType = interface(IXMLNode)
    ['{2FA7992E-BCC4-466F-8F2D-A7892BA0D107}']
    { Property Accessors }
    function Get_Upperrange: LongWord;
    function Get_Lowerrange: LongWord;
    function Get_Type_: UnicodeString;
    procedure Set_Upperrange(Value: LongWord);
    procedure Set_Lowerrange(Value: LongWord);
    procedure Set_Type_(Value: UnicodeString);
    { Methods & Properties }
    property Upperrange: LongWord read Get_Upperrange write Set_Upperrange;
    property Lowerrange: LongWord read Get_Lowerrange write Set_Lowerrange;
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
  end;

{ IXMLPercentageValTypeList }

  IXMLPercentageValTypeList = interface(IXMLNodeCollection)
    ['{C1203563-393E-49BE-A7CF-21C55EAF55FA}']
    { Methods & Properties }
    function Add: IXMLPercentageValType;
    function Insert(const Index: Integer): IXMLPercentageValType;

    function Get_Item(Index: Integer): IXMLPercentageValType;
    property Items[Index: Integer]: IXMLPercentageValType read Get_Item; default;
  end;

{ IXMLFireweather }

  IXMLFireweather = interface(IXMLNode)
    ['{C7B5959A-CF8D-4212-9C9C-412ECE3C76AA}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLValueList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLValueList read Get_Value;
  end;

{ IXMLFireweatherList }

  IXMLFireweatherList = interface(IXMLNodeCollection)
    ['{B08CCAFC-B134-4F36-9F6E-3B957A431224}']
    { Methods & Properties }
    function Add: IXMLFireweather;
    function Insert(const Index: Integer): IXMLFireweather;

    function Get_Item(Index: Integer): IXMLFireweather;
    property Items[Index: Integer]: IXMLFireweather read Get_Item; default;
  end;

{ IXMLConvectivehazard }

  IXMLConvectivehazard = interface(IXMLNode)
    ['{28901AD9-97C5-47CA-BC52-558D51B5676C}']
    { Property Accessors }
    function Get_Outlook: IXMLOutlook;
    function Get_Severecomponent: IXMLSeverecomponentList;
    { Methods & Properties }
    property Outlook: IXMLOutlook read Get_Outlook;
    property Severecomponent: IXMLSeverecomponentList read Get_Severecomponent;
  end;

{ IXMLConvectivehazardList }

  IXMLConvectivehazardList = interface(IXMLNodeCollection)
    ['{7C2E2EBC-CCEF-4E14-9ECE-12BD87BD2081}']
    { Methods & Properties }
    function Add: IXMLConvectivehazard;
    function Insert(const Index: Integer): IXMLConvectivehazard;

    function Get_Item(Index: Integer): IXMLConvectivehazard;
    property Items[Index: Integer]: IXMLConvectivehazard read Get_Item; default;
  end;

{ IXMLOutlook }

  IXMLOutlook = interface(IXMLNode)
    ['{D96F8826-11E1-4104-B759-7AD99A6FF80C}']
    { Property Accessors }
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLValueList;
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLValueList read Get_Value;
  end;

{ IXMLSeverecomponent }

  IXMLSeverecomponent = interface(IXMLNode)
    ['{45296031-B2C2-4320-B709-8CBB47676BC4}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLValueList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLValueList read Get_Value;
  end;

{ IXMLSeverecomponentList }

  IXMLSeverecomponentList = interface(IXMLNodeCollection)
    ['{07CF13A1-438F-43C1-89EB-FF817D15B0F1}']
    { Methods & Properties }
    function Add: IXMLSeverecomponent;
    function Insert(const Index: Integer): IXMLSeverecomponent;

    function Get_Item(Index: Integer): IXMLSeverecomponent;
    property Items[Index: Integer]: IXMLSeverecomponent read Get_Item; default;
  end;

{ IXMLValue }

  IXMLValue = interface(IXMLNode)
    ['{9928FCE8-328C-4AE4-8955-1F3543274046}']
    { Property Accessors }
    function Get_Upperrange: LongWord;
    function Get_Lowerrange: LongWord;
    procedure Set_Upperrange(Value: LongWord);
    procedure Set_Lowerrange(Value: LongWord);
    { Methods & Properties }
    property Upperrange: LongWord read Get_Upperrange write Set_Upperrange;
    property Lowerrange: LongWord read Get_Lowerrange write Set_Lowerrange;
  end;

{ IXMLValueList }

  IXMLValueList = interface(IXMLNodeCollection)
    ['{56314207-9B68-4E3E-BDB8-F3B14882FD23}']
    { Methods & Properties }
    function Add: IXMLValue;
    function Insert(const Index: Integer): IXMLValue;

    function Get_Item(Index: Integer): IXMLValue;
    property Items[Index: Integer]: IXMLValue read Get_Item; default;
  end;

{ IXMLClimateanomaly }

  IXMLClimateanomaly = interface(IXMLNode)
    ['{415CD271-9278-447A-9875-286ED1C6DB7B}']
    { Property Accessors }
    function Get_Weekly: IXMLAnomalyTypeList;
    function Get_Monthly: IXMLAnomalyTypeList;
    function Get_Seasonal: IXMLAnomalyTypeList;
    { Methods & Properties }
    property Weekly: IXMLAnomalyTypeList read Get_Weekly;
    property Monthly: IXMLAnomalyTypeList read Get_Monthly;
    property Seasonal: IXMLAnomalyTypeList read Get_Seasonal;
  end;

{ IXMLClimateanomalyList }

  IXMLClimateanomalyList = interface(IXMLNodeCollection)
    ['{9397D81D-530E-4F42-84E7-23C9CF582D75}']
    { Methods & Properties }
    function Add: IXMLClimateanomaly;
    function Insert(const Index: Integer): IXMLClimateanomaly;

    function Get_Item(Index: Integer): IXMLClimateanomaly;
    property Items[Index: Integer]: IXMLClimateanomaly read Get_Item; default;
  end;

{ IXMLAnomalyType }

  IXMLAnomalyType = interface(IXMLNode)
    ['{61B5413E-AD00-4713-89C7-BE1D85B7A4FD}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLValueList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLValueList read Get_Value;
  end;

{ IXMLAnomalyTypeList }

  IXMLAnomalyTypeList = interface(IXMLNodeCollection)
    ['{FF1E91A4-E14B-4FF2-9E35-0B9FF36A9C33}']
    { Methods & Properties }
    function Add: IXMLAnomalyType;
    function Insert(const Index: Integer): IXMLAnomalyType;

    function Get_Item(Index: Integer): IXMLAnomalyType;
    property Items[Index: Integer]: IXMLAnomalyType read Get_Item; default;
  end;

{ IXMLWindspeed }

  IXMLWindspeed = interface(IXMLNode)
    ['{C89448E1-1E60-4D7B-B86A-95EEE646ECAE}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLWspdValTypeList;
    function Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLWspdValTypeList read Get_Value;
    property ValueWithUncertainty: IXMLValueWithUncertaintyList read Get_ValueWithUncertainty;
  end;

{ IXMLWindspeedList }

  IXMLWindspeedList = interface(IXMLNodeCollection)
    ['{AC9AE092-553A-4DB6-82E1-BDB386FFD169}']
    { Methods & Properties }
    function Add: IXMLWindspeed;
    function Insert(const Index: Integer): IXMLWindspeed;

    function Get_Item(Index: Integer): IXMLWindspeed;
    property Items[Index: Integer]: IXMLWindspeed read Get_Item; default;
  end;

{ IXMLWspdValType }

  IXMLWspdValType = interface(IXMLNode)
    ['{C635F830-7EE3-4A28-9510-29DDE784887D}']
    { Property Accessors }
    function Get_Upperrange: LongWord;
    function Get_Lowerrange: LongWord;
    function Get_Type_: UnicodeString;
    procedure Set_Upperrange(Value: LongWord);
    procedure Set_Lowerrange(Value: LongWord);
    procedure Set_Type_(Value: UnicodeString);
    { Methods & Properties }
    property Upperrange: LongWord read Get_Upperrange write Set_Upperrange;
    property Lowerrange: LongWord read Get_Lowerrange write Set_Lowerrange;
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
  end;

{ IXMLWspdValTypeList }

  IXMLWspdValTypeList = interface(IXMLNodeCollection)
    ['{D46E873D-0E8B-4B44-B0B9-3F694FAC0D85}']
    { Methods & Properties }
    function Add: IXMLWspdValType;
    function Insert(const Index: Integer): IXMLWspdValType;

    function Get_Item(Index: Integer): IXMLWspdValType;
    property Items[Index: Integer]: IXMLWspdValType read Get_Item; default;
  end;

{ IXMLDirection }

  IXMLDirection = interface(IXMLNode)
    ['{22C14062-95E8-425A-A538-A57B33A36263}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLWdirValTypeList;
    function Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLWdirValTypeList read Get_Value;
    property ValueWithUncertainty: IXMLValueWithUncertaintyList read Get_ValueWithUncertainty;
  end;

{ IXMLDirectionList }

  IXMLDirectionList = interface(IXMLNodeCollection)
    ['{AF4C7566-907F-41E7-B6AD-F1FC56FE5C3A}']
    { Methods & Properties }
    function Add: IXMLDirection;
    function Insert(const Index: Integer): IXMLDirection;

    function Get_Item(Index: Integer): IXMLDirection;
    property Items[Index: Integer]: IXMLDirection read Get_Item; default;
  end;

{ IXMLWdirValType }

  IXMLWdirValType = interface(IXMLNode)
    ['{7027D65B-6FA6-4477-AA74-5BC258A4709A}']
    { Property Accessors }
    function Get_Upperrange: LongWord;
    function Get_Lowerrange: LongWord;
    function Get_Type_: UnicodeString;
    procedure Set_Upperrange(Value: LongWord);
    procedure Set_Lowerrange(Value: LongWord);
    procedure Set_Type_(Value: UnicodeString);
    { Methods & Properties }
    property Upperrange: LongWord read Get_Upperrange write Set_Upperrange;
    property Lowerrange: LongWord read Get_Lowerrange write Set_Lowerrange;
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
  end;

{ IXMLWdirValTypeList }

  IXMLWdirValTypeList = interface(IXMLNodeCollection)
    ['{9C68D0BE-2302-4F7C-AF13-833D694D855F}']
    { Methods & Properties }
    function Add: IXMLWdirValType;
    function Insert(const Index: Integer): IXMLWdirValType;

    function Get_Item(Index: Integer): IXMLWdirValType;
    property Items[Index: Integer]: IXMLWdirValType read Get_Item; default;
  end;

{ IXMLCloudamount }

  IXMLCloudamount = interface(IXMLNode)
    ['{79093039-3753-4005-B5B2-FFACE7B0FBB5}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLPercentageValTypeList;
    function Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLPercentageValTypeList read Get_Value;
    property ValueWithUncertainty: IXMLValueWithUncertaintyList read Get_ValueWithUncertainty;
  end;

{ IXMLCloudamountList }

  IXMLCloudamountList = interface(IXMLNodeCollection)
    ['{940FF66D-287A-44F7-9EA3-3D0BFD212287}']
    { Methods & Properties }
    function Add: IXMLCloudamount;
    function Insert(const Index: Integer): IXMLCloudamount;

    function Get_Item(Index: Integer): IXMLCloudamount;
    property Items[Index: Integer]: IXMLCloudamount read Get_Item; default;
  end;

{ IXMLHumidity }

  IXMLHumidity = interface(IXMLNode)
    ['{F4BD6E96-1A83-48A4-83AA-AE333CC2BCCE}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLValueList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLValueList read Get_Value;
  end;

{ IXMLHumidityList }

  IXMLHumidityList = interface(IXMLNodeCollection)
    ['{13113142-81A2-48D9-9D92-2F9E471306D5}']
    { Methods & Properties }
    function Add: IXMLHumidity;
    function Insert(const Index: Integer): IXMLHumidity;

    function Get_Item(Index: Integer): IXMLHumidity;
    property Items[Index: Integer]: IXMLHumidity read Get_Item; default;
  end;

{ IXMLWeather }

  IXMLWeather = interface(IXMLNode)
    ['{727AFD5F-FC92-448D-BD15-FF95CF583354}']
    { Property Accessors }
    function Get_Timelayout: UnicodeString;
    function Get_Name: IXMLString_List;
    function Get_Weatherconditions: IXMLWeatherconditionsList;
    procedure Set_Timelayout(Value: UnicodeString);
    { Methods & Properties }
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Name: IXMLString_List read Get_Name;
    property Weatherconditions: IXMLWeatherconditionsList read Get_Weatherconditions;
  end;

{ IXMLWeatherList }

  IXMLWeatherList = interface(IXMLNodeCollection)
    ['{7CC36A73-67D2-498A-BED8-2B3BD325C0F3}']
    { Methods & Properties }
    function Add: IXMLWeather;
    function Insert(const Index: Integer): IXMLWeather;

    function Get_Item(Index: Integer): IXMLWeather;
    property Items[Index: Integer]: IXMLWeather read Get_Item; default;
  end;

{ IXMLWeatherconditions }

  IXMLWeatherconditions = interface(IXMLNodeCollection)
    ['{61FB88CB-BB11-472A-BF23-86619A7D5CBF}']
    { Property Accessors }
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Weathersummary: UnicodeString;
    function Get_Value(Index: Integer): IXMLValue;
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Weathersummary(Value: UnicodeString);
    { Methods & Properties }
    function Add: IXMLValue;
    function Insert(const Index: Integer): IXMLValue;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Weathersummary: UnicodeString read Get_Weathersummary write Set_Weathersummary;
    property Value[Index: Integer]: IXMLValue read Get_Value; default;
  end;

{ IXMLWeatherconditionsList }

  IXMLWeatherconditionsList = interface(IXMLNodeCollection)
    ['{2FD03FCC-CACF-48A1-82C4-738F438DAE65}']
    { Methods & Properties }
    function Add: IXMLWeatherconditions;
    function Insert(const Index: Integer): IXMLWeatherconditions;

    function Get_Item(Index: Integer): IXMLWeatherconditions;
    property Items[Index: Integer]: IXMLWeatherconditions read Get_Item; default;
  end;

{ IXMLConditionsicon }

  IXMLConditionsicon = interface(IXMLNode)
    ['{666E7483-32C7-44EA-85F4-649AAE92B59F}']
    { Property Accessors }
    function Get_Timelayout: UnicodeString;
    function Get_Type_: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Iconlink: IXMLAnyURIList;
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Iconlink: IXMLAnyURIList read Get_Iconlink;
  end;

{ IXMLConditionsiconList }

  IXMLConditionsiconList = interface(IXMLNodeCollection)
    ['{D32C960C-D8FA-4C7E-B67C-95231A5F4E6D}']
    { Methods & Properties }
    function Add: IXMLConditionsicon;
    function Insert(const Index: Integer): IXMLConditionsicon;

    function Get_Item(Index: Integer): IXMLConditionsicon;
    property Items[Index: Integer]: IXMLConditionsicon read Get_Item; default;
  end;

{ IXMLHazards }

  IXMLHazards = interface(IXMLNode)
    ['{29533A48-3713-497A-AD33-05A87A65BD3B}']
    { Property Accessors }
    function Get_Timelayout: UnicodeString;
    function Get_Name: IXMLString_List;
    function Get_Hazardconditions: IXMLHazardconditionsList;
    procedure Set_Timelayout(Value: UnicodeString);
    { Methods & Properties }
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Name: IXMLString_List read Get_Name;
    property Hazardconditions: IXMLHazardconditionsList read Get_Hazardconditions;
  end;

{ IXMLHazardsList }

  IXMLHazardsList = interface(IXMLNodeCollection)
    ['{056F7228-7F8E-48E7-ABE8-C3CBA2BD8F67}']
    { Methods & Properties }
    function Add: IXMLHazards;
    function Insert(const Index: Integer): IXMLHazards;

    function Get_Item(Index: Integer): IXMLHazards;
    property Items[Index: Integer]: IXMLHazards read Get_Item; default;
  end;

{ IXMLHazardconditions }

  IXMLHazardconditions = interface(IXMLNodeCollection)
    ['{049B3586-F98F-44A9-98C8-FC3ABACE7973}']
    { Property Accessors }
    function Get_Hazard(Index: Integer): IXMLHazard;
    { Methods & Properties }
    function Add: IXMLHazard;
    function Insert(const Index: Integer): IXMLHazard;
    property Hazard[Index: Integer]: IXMLHazard read Get_Hazard; default;
  end;

{ IXMLHazardconditionsList }

  IXMLHazardconditionsList = interface(IXMLNodeCollection)
    ['{7BBB8DD0-0E3E-4AE8-A5D7-466A2779E060}']
    { Methods & Properties }
    function Add: IXMLHazardconditions;
    function Insert(const Index: Integer): IXMLHazardconditions;

    function Get_Item(Index: Integer): IXMLHazardconditions;
    property Items[Index: Integer]: IXMLHazardconditions read Get_Item; default;
  end;

{ IXMLHazard }

  IXMLHazard = interface(IXMLNode)
    ['{3B9FF185-06CC-4A11-8638-23155D2E6DF1}']
    { Property Accessors }
    function Get_HazardCode: UnicodeString;
    function Get_Phenomena: UnicodeString;
    function Get_Significance: UnicodeString;
    function Get_HazardType: UnicodeString;
    function Get_EventTrackingNumber: Integer;
    function Get_Headline: UnicodeString;
    function Get_HazardTextURL: UnicodeString;
    function Get_HazardIcon: UnicodeString;
    procedure Set_HazardCode(Value: UnicodeString);
    procedure Set_Phenomena(Value: UnicodeString);
    procedure Set_Significance(Value: UnicodeString);
    procedure Set_HazardType(Value: UnicodeString);
    procedure Set_EventTrackingNumber(Value: Integer);
    procedure Set_Headline(Value: UnicodeString);
    procedure Set_HazardTextURL(Value: UnicodeString);
    procedure Set_HazardIcon(Value: UnicodeString);
    { Methods & Properties }
    property HazardCode: UnicodeString read Get_HazardCode write Set_HazardCode;
    property Phenomena: UnicodeString read Get_Phenomena write Set_Phenomena;
    property Significance: UnicodeString read Get_Significance write Set_Significance;
    property HazardType: UnicodeString read Get_HazardType write Set_HazardType;
    property EventTrackingNumber: Integer read Get_EventTrackingNumber write Set_EventTrackingNumber;
    property Headline: UnicodeString read Get_Headline write Set_Headline;
    property HazardTextURL: UnicodeString read Get_HazardTextURL write Set_HazardTextURL;
    property HazardIcon: UnicodeString read Get_HazardIcon write Set_HazardIcon;
  end;

{ IXMLWordedForecast }

  IXMLWordedForecast = interface(IXMLNode)
    ['{4639CEA2-7EC9-474B-8438-EA08B1616F20}']
    { Property Accessors }
    function Get_Timelayout: UnicodeString;
    function Get_DataSource: UnicodeString;
    function Get_WordGenerator: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Text: IXMLString_List;
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_DataSource(Value: UnicodeString);
    procedure Set_WordGenerator(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property DataSource: UnicodeString read Get_DataSource write Set_DataSource;
    property WordGenerator: UnicodeString read Get_WordGenerator write Set_WordGenerator;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Text: IXMLString_List read Get_Text;
  end;

{ IXMLPressure }

  IXMLPressure = interface(IXMLNode)
    ['{1337D4C9-B9D6-4F2F-9F44-5D9C0D730108}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLDecimalValTypeList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLDecimalValTypeList read Get_Value;
  end;

{ IXMLPressureList }

  IXMLPressureList = interface(IXMLNodeCollection)
    ['{6E717E49-F459-4F75-9FC7-65CA4CE8D804}']
    { Methods & Properties }
    function Add: IXMLPressure;
    function Insert(const Index: Integer): IXMLPressure;

    function Get_Item(Index: Integer): IXMLPressure;
    property Items[Index: Integer]: IXMLPressure read Get_Item; default;
  end;

{ IXMLProbabilisticCondition }

  IXMLProbabilisticCondition = interface(IXMLNode)
    ['{584FA26B-10D8-4283-934B-554D33011948}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_LikelihoodUnits: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Applicablecategories: UnicodeString;
    function Get_Probabilitytype: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLPercentageValTypeList;
    function Get_ValueForRange: IXMLValueForRangeTypeList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_LikelihoodUnits(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Applicablecategories(Value: UnicodeString);
    procedure Set_Probabilitytype(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property LikelihoodUnits: UnicodeString read Get_LikelihoodUnits write Set_LikelihoodUnits;
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Applicablecategories: UnicodeString read Get_Applicablecategories write Set_Applicablecategories;
    property Probabilitytype: UnicodeString read Get_Probabilitytype write Set_Probabilitytype;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLPercentageValTypeList read Get_Value;
    property ValueForRange: IXMLValueForRangeTypeList read Get_ValueForRange;
  end;

{ IXMLProbabilisticConditionList }

  IXMLProbabilisticConditionList = interface(IXMLNodeCollection)
    ['{9544F25F-E9AB-4BFE-A1E6-3287A74DBB27}']
    { Methods & Properties }
    function Add: IXMLProbabilisticCondition;
    function Insert(const Index: Integer): IXMLProbabilisticCondition;

    function Get_Item(Index: Integer): IXMLProbabilisticCondition;
    property Items[Index: Integer]: IXMLProbabilisticCondition read Get_Item; default;
  end;

{ IXMLValueForRangeType }

  IXMLValueForRangeType = interface(IXMLNode)
    ['{F3475F4E-0366-4D3D-8551-DB0C9A075D29}']
    { Property Accessors }
    function Get_Value: IXMLPercentageValTypeList;
    function Get_Gt: UnicodeString;
    function Get_Ge: UnicodeString;
    function Get_Lt: UnicodeString;
    function Get_Le: UnicodeString;
    function Get_Eq: UnicodeString;
    procedure Set_Gt(Value: UnicodeString);
    procedure Set_Ge(Value: UnicodeString);
    procedure Set_Lt(Value: UnicodeString);
    procedure Set_Le(Value: UnicodeString);
    procedure Set_Eq(Value: UnicodeString);
    { Methods & Properties }
    property Value: IXMLPercentageValTypeList read Get_Value;
    property Gt: UnicodeString read Get_Gt write Set_Gt;
    property Ge: UnicodeString read Get_Ge write Set_Ge;
    property Lt: UnicodeString read Get_Lt write Set_Lt;
    property Le: UnicodeString read Get_Le write Set_Le;
    property Eq: UnicodeString read Get_Eq write Set_Eq;
  end;

{ IXMLValueForRangeTypeList }

  IXMLValueForRangeTypeList = interface(IXMLNodeCollection)
    ['{24A882FF-0879-401D-A042-4568582C81E9}']
    { Methods & Properties }
    function Add: IXMLValueForRangeType;
    function Insert(const Index: Integer): IXMLValueForRangeType;

    function Get_Item(Index: Integer): IXMLValueForRangeType;
    property Items[Index: Integer]: IXMLValueForRangeType read Get_Item; default;
  end;

{ IXMLWaterstate }

  IXMLWaterstate = interface(IXMLNode)
    ['{4561FD71-9297-45BB-8B96-31FAF9EB03FC}']
    { Property Accessors }
    function Get_Timelayout: UnicodeString;
    function Get_Waves: IXMLWavesList;
    function Get_Swell: IXMLSwellList;
    function Get_Seas: IXMLSeasList;
    function Get_Icecoverage: IXMLNonNegativeIntegerList;
    procedure Set_Timelayout(Value: UnicodeString);
    { Methods & Properties }
    property Timelayout: UnicodeString read Get_Timelayout write Set_Timelayout;
    property Waves: IXMLWavesList read Get_Waves;
    property Swell: IXMLSwellList read Get_Swell;
    property Seas: IXMLSeasList read Get_Seas;
    property Icecoverage: IXMLNonNegativeIntegerList read Get_Icecoverage;
  end;

{ IXMLWaterstateList }

  IXMLWaterstateList = interface(IXMLNodeCollection)
    ['{A0A73533-2413-4D73-A90E-50228A9AFE9D}']
    { Methods & Properties }
    function Add: IXMLWaterstate;
    function Insert(const Index: Integer): IXMLWaterstate;

    function Get_Item(Index: Integer): IXMLWaterstate;
    property Items[Index: Integer]: IXMLWaterstate read Get_Item; default;
  end;

{ IXMLWaves }

  IXMLWaves = interface(IXMLNode)
    ['{99BB2675-9E60-47F4-A150-927CCDC10A57}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Period: LongWord;
    function Get_Steepness: LongWord;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLNonNegativeIntegerList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Period(Value: LongWord);
    procedure Set_Steepness(Value: LongWord);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Period: LongWord read Get_Period write Set_Period;
    property Steepness: LongWord read Get_Steepness write Set_Steepness;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLNonNegativeIntegerList read Get_Value;
  end;

{ IXMLWavesList }

  IXMLWavesList = interface(IXMLNodeCollection)
    ['{106DC785-5795-4EB5-AA69-3CC8AF893093}']
    { Methods & Properties }
    function Add: IXMLWaves;
    function Insert(const Index: Integer): IXMLWaves;

    function Get_Item(Index: Integer): IXMLWaves;
    property Items[Index: Integer]: IXMLWaves read Get_Item; default;
  end;

{ IXMLSwell }

  IXMLSwell = interface(IXMLNode)
    ['{E39E0805-79BF-431E-A453-735E1C28C9F7}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Period: LongWord;
    function Get_Steepness: LongWord;
    function Get_Name: UnicodeString;
    function Get_Value: UnicodeString;
    function Get_Direction: IXMLDirection;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Period(Value: LongWord);
    procedure Set_Steepness(Value: LongWord);
    procedure Set_Name(Value: UnicodeString);
    procedure Set_Value(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Period: LongWord read Get_Period write Set_Period;
    property Steepness: LongWord read Get_Steepness write Set_Steepness;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: UnicodeString read Get_Value write Set_Value;
    property Direction: IXMLDirection read Get_Direction;
  end;

{ IXMLSwellList }

  IXMLSwellList = interface(IXMLNodeCollection)
    ['{8417684A-E223-4501-8583-76F67EC69693}']
    { Methods & Properties }
    function Add: IXMLSwell;
    function Insert(const Index: Integer): IXMLSwell;

    function Get_Item(Index: Integer): IXMLSwell;
    property Items[Index: Integer]: IXMLSwell read Get_Item; default;
  end;

{ IXMLSeas }

  IXMLSeas = interface(IXMLNode)
    ['{4E8014FD-BB4A-45CA-BC79-4F58502DA59D}']
    { Property Accessors }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLNonNegativeIntegerList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    { Methods & Properties }
    property Type_: UnicodeString read Get_Type_ write Set_Type_;
    property Units: UnicodeString read Get_Units write Set_Units;
    property Categoricaltable: UnicodeString read Get_Categoricaltable write Set_Categoricaltable;
    property Conversiontable: UnicodeString read Get_Conversiontable write Set_Conversiontable;
    property Name: UnicodeString read Get_Name write Set_Name;
    property Value: IXMLNonNegativeIntegerList read Get_Value;
  end;

{ IXMLSeasList }

  IXMLSeasList = interface(IXMLNodeCollection)
    ['{C2C81026-7BE7-4A43-A431-B83F37D4B4AD}']
    { Methods & Properties }
    function Add: IXMLSeas;
    function Insert(const Index: Integer): IXMLSeas;

    function Get_Item(Index: Integer): IXMLSeas;
    property Items[Index: Integer]: IXMLSeas read Get_Item; default;
  end;

{ IXMLNonNegativeIntegerList }

  IXMLNonNegativeIntegerList = interface(IXMLNodeCollection)
    ['{A5DF5D2E-B247-4AC2-BE1B-9758D06C3C49}']
    { Methods & Properties }
    function Add(const Value: LongWord): IXMLNode;
    function Insert(const Index: Integer; const Value: LongWord): IXMLNode;

    function Get_Item(Index: Integer): LongWord;
    property Items[Index: Integer]: LongWord read Get_Item; default;
  end;

{ IXMLDateTimeList }

  IXMLDateTimeList = interface(IXMLNodeCollection)
    ['{61B62890-013A-4535-99B3-ECACC39D9D20}']
    { Methods & Properties }
    function Add(const Value: UnicodeString): IXMLNode;
    function Insert(const Index: Integer; const Value: UnicodeString): IXMLNode;

    function Get_Item(Index: Integer): UnicodeString;
    property Items[Index: Integer]: UnicodeString read Get_Item; default;
  end;

{ IXMLAnyURIList }

  IXMLAnyURIList = interface(IXMLNodeCollection)
    ['{A2A0B2BF-E82C-4774-B6A1-AD2AB7A679E1}']
    { Methods & Properties }
    function Add(const Value: UnicodeString): IXMLNode;
    function Insert(const Index: Integer; const Value: UnicodeString): IXMLNode;

    function Get_Item(Index: Integer): UnicodeString;
    property Items[Index: Integer]: UnicodeString read Get_Item; default;
  end;


{ IXMLString_List }

  IXMLString_List = interface(IXMLNodeCollection)
    ['{24F8442B-E713-42BC-A4AA-D63E3065F460}']
    { Methods & Properties }
    function Add(const Value: UnicodeString): IXMLNode;
    function Insert(const Index: Integer; const Value: UnicodeString): IXMLNode;

    function Get_Item(Index: Integer): UnicodeString;
    property Items[Index: Integer]: UnicodeString read Get_Item; default;
  end;

{ Forward Decls }

  TXMLDwml = class;
  TXMLHeadType = class;
  TXMLProductType = class;
  TXMLCreationdateType = class;
  TXMLSourceType = class;
  TXMLProductioncenterType = class;
  TXMLDataType = class;
  TXMLDataTypeList = class;
  TXMLLocationType = class;
  TXMLLocationTypeList = class;
  TXMLPointType = class;
  TXMLNwszoneType = class;
  TXMLAreaType = class;
  TXMLCircleType = class;
  TXMLRadiusType = class;
  TXMLRectangleType = class;
  TXMLCityType = class;
  TXMLHeightType = class;
  TXMLLevelType = class;
  TXMLLayerType = class;
  TXMLMoreWeatherInformationType = class;
  TXMLMoreWeatherInformationTypeList = class;
  TXMLTimelayoutElementType = class;
  TXMLTimelayoutElementTypeList = class;
  TXMLStartvalidtimeType = class;
  TXMLStartvalidtimeTypeList = class;
  TXMLParametersType = class;
  TXMLParametersTypeList = class;
  TXMLCategoriesType = class;
  TXMLCategoriesTypeList = class;
  TXMLValueListType = class;
  TXMLValueListTypeList = class;
  TXMLTemperature = class;
  TXMLTemperatureList = class;
  TXMLTempValType = class;
  TXMLTempValTypeList = class;
  TXMLValueWithUncertainty = class;
  TXMLValueWithUncertaintyList = class;
  TXMLUncertaintyType = class;
  TXMLError = class;
  TXMLPrecipitation = class;
  TXMLPrecipitationList = class;
  TXMLDecimalValType = class;
  TXMLDecimalValTypeList = class;
  TXMLProbabilityofprecipitation = class;
  TXMLProbabilityofprecipitationList = class;
  TXMLPercentageValType = class;
  TXMLPercentageValTypeList = class;
  TXMLFireweather = class;
  TXMLFireweatherList = class;
  TXMLConvectivehazard = class;
  TXMLConvectivehazardList = class;
  TXMLOutlook = class;
  TXMLSeverecomponent = class;
  TXMLSeverecomponentList = class;
  TXMLValue = class;
  TXMLValueList = class;
  TXMLClimateanomaly = class;
  TXMLClimateanomalyList = class;
  TXMLAnomalyType = class;
  TXMLAnomalyTypeList = class;
  TXMLWindspeed = class;
  TXMLWindspeedList = class;
  TXMLWspdValType = class;
  TXMLWspdValTypeList = class;
  TXMLDirection = class;
  TXMLDirectionList = class;
  TXMLWdirValType = class;
  TXMLWdirValTypeList = class;
  TXMLCloudamount = class;
  TXMLCloudamountList = class;
  TXMLHumidity = class;
  TXMLHumidityList = class;
  TXMLWeather = class;
  TXMLWeatherList = class;
  TXMLWeatherconditions = class;
  TXMLWeatherconditionsList = class;
  TXMLConditionsicon = class;
  TXMLConditionsiconList = class;
  TXMLHazards = class;
  TXMLHazardsList = class;
  TXMLHazardconditions = class;
  TXMLHazardconditionsList = class;
  TXMLHazard = class;
  TXMLWordedForecast = class;
  TXMLPressure = class;
  TXMLPressureList = class;
  TXMLProbabilisticCondition = class;
  TXMLProbabilisticConditionList = class;
  TXMLValueForRangeType = class;
  TXMLValueForRangeTypeList = class;
  TXMLWaterstate = class;
  TXMLWaterstateList = class;
  TXMLWaves = class;
  TXMLWavesList = class;
  TXMLSwell = class;
  TXMLSwellList = class;
  TXMLSeas = class;
  TXMLSeasList = class;
  TXMLNonNegativeIntegerList = class;
  TXMLDateTimeList = class;
  TXMLAnyURIList = class;
  TXMLString_List = class;

{ TXMLDwml }

  TXMLDwml = class(TXMLNode, IXMLDwml)
  private
    FData: IXMLDataTypeList;
  protected
    { IXMLDwml }
    function Get_Version: UnicodeString;
    function Get_Head: IXMLHeadType;
    function Get_Data: IXMLDataTypeList;
    function Get_MinResolution: UnicodeString;
    function Get_LatLonList: UnicodeString;
    function Get_CityNameList: UnicodeString;
    procedure Set_Version(Value: UnicodeString);
    procedure Set_MinResolution(Value: UnicodeString);
    procedure Set_LatLonList(Value: UnicodeString);
    procedure Set_CityNameList(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLHeadType }

  TXMLHeadType = class(TXMLNode, IXMLHeadType)
  protected
    { IXMLHeadType }
    function Get_Product: IXMLProductType;
    function Get_Source: IXMLSourceType;
  public
    procedure AfterConstruction; override;
  end;

{ TXMLProductType }

  TXMLProductType = class(TXMLNode, IXMLProductType)
  protected
    { IXMLProductType }
    function Get_Concisename: UnicodeString;
    function Get_Operationalmode: UnicodeString;
    function Get_SrsName: UnicodeString;
    function Get_Title: UnicodeString;
    function Get_Field: UnicodeString;
    function Get_Category: UnicodeString;
    function Get_Creationdate: IXMLCreationdateType;
    procedure Set_Concisename(Value: UnicodeString);
    procedure Set_Operationalmode(Value: UnicodeString);
    procedure Set_SrsName(Value: UnicodeString);
    procedure Set_Title(Value: UnicodeString);
    procedure Set_Field(Value: UnicodeString);
    procedure Set_Category(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLCreationdateType }

  TXMLCreationdateType = class(TXMLNode, IXMLCreationdateType)
  protected
    { IXMLCreationdateType }
    function Get_Refreshfrequency: UnicodeString;
    procedure Set_Refreshfrequency(Value: UnicodeString);
  end;

{ TXMLSourceType }

  TXMLSourceType = class(TXMLNode, IXMLSourceType)
  protected
    { IXMLSourceType }
    function Get_Moreinformation: UnicodeString;
    function Get_Productioncenter: IXMLProductioncenterType;
    function Get_Disclaimer: UnicodeString;
    function Get_Credit: UnicodeString;
    function Get_Creditlogo: UnicodeString;
    function Get_Feedback: UnicodeString;
    procedure Set_Moreinformation(Value: UnicodeString);
    procedure Set_Disclaimer(Value: UnicodeString);
    procedure Set_Credit(Value: UnicodeString);
    procedure Set_Creditlogo(Value: UnicodeString);
    procedure Set_Feedback(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLProductioncenterType }

  TXMLProductioncenterType = class(TXMLNode, IXMLProductioncenterType)
  protected
    { IXMLProductioncenterType }
    function Get_Subcenter: UnicodeString;
    procedure Set_Subcenter(Value: UnicodeString);
  end;

{ TXMLDataType }

  TXMLDataType = class(TXMLNode, IXMLDataType)
  private
    FLocation: IXMLLocationTypeList;
    FMoreWeatherInformation: IXMLMoreWeatherInformationTypeList;
    FTimelayout: IXMLTimelayoutElementTypeList;
    FParameters: IXMLParametersTypeList;
  protected
    { IXMLDataType }
    function Get_Type_: UnicodeString;
    function Get_Location: IXMLLocationTypeList;
    function Get_MoreWeatherInformation: IXMLMoreWeatherInformationTypeList;
    function Get_Timelayout: IXMLTimelayoutElementTypeList;
    function Get_Parameters: IXMLParametersTypeList;
    procedure Set_Type_(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLDataTypeList }

  TXMLDataTypeList = class(TXMLNodeCollection, IXMLDataTypeList)
  protected
    { IXMLDataTypeList }
    function Add: IXMLDataType;
    function Insert(const Index: Integer): IXMLDataType;

    function Get_Item(Index: Integer): IXMLDataType;
  end;

{ TXMLLocationType }

  TXMLLocationType = class(TXMLNode, IXMLLocationType)
  protected
    { IXMLLocationType }
    function Get_Locationkey: UnicodeString;
    function Get_Description: UnicodeString;
    function Get_Point: IXMLPointType;
    function Get_Nwszone: IXMLNwszoneType;
    function Get_Area: IXMLAreaType;
    function Get_City: IXMLCityType;
    function Get_Areadescription: UnicodeString;
    function Get_Height: IXMLHeightType;
    function Get_Level: IXMLLevelType;
    function Get_Layer: IXMLLayerType;
    procedure Set_Locationkey(Value: UnicodeString);
    procedure Set_Description(Value: UnicodeString);
    procedure Set_Areadescription(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLLocationTypeList }

  TXMLLocationTypeList = class(TXMLNodeCollection, IXMLLocationTypeList)
  protected
    { IXMLLocationTypeList }
    function Add: IXMLLocationType;
    function Insert(const Index: Integer): IXMLLocationType;

    function Get_Item(Index: Integer): IXMLLocationType;
  end;

{ TXMLPointType }

  TXMLPointType = class(TXMLNode, IXMLPointType)
  protected
    { IXMLPointType }
    function Get_Latitude: UnicodeString;
    function Get_Longitude: UnicodeString;
    function Get_Summarization: UnicodeString;
    procedure Set_Latitude(Value: UnicodeString);
    procedure Set_Longitude(Value: UnicodeString);
    procedure Set_Summarization(Value: UnicodeString);
  end;

{ TXMLNwszoneType }

  TXMLNwszoneType = class(TXMLNode, IXMLNwszoneType)
  protected
    { IXMLNwszoneType }
    function Get_State: UnicodeString;
    function Get_Summarization: UnicodeString;
    procedure Set_State(Value: UnicodeString);
    procedure Set_Summarization(Value: UnicodeString);
  end;

{ TXMLAreaType }

  TXMLAreaType = class(TXMLNode, IXMLAreaType)
  protected
    { IXMLAreaType }
    function Get_Areatype: UnicodeString;
    function Get_Circle: IXMLCircleType;
    function Get_Rectangle: IXMLRectangleType;
    procedure Set_Areatype(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLCircleType }

  TXMLCircleType = class(TXMLNode, IXMLCircleType)
  protected
    { IXMLCircleType }
    function Get_Summarization: UnicodeString;
    function Get_Point: IXMLPointType;
    function Get_Radius: IXMLRadiusType;
    procedure Set_Summarization(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLRadiusType }

  TXMLRadiusType = class(TXMLNode, IXMLRadiusType)
  protected
    { IXMLRadiusType }
    function Get_Radiusunits: UnicodeString;
    procedure Set_Radiusunits(Value: UnicodeString);
  end;

{ TXMLRectangleType }

  TXMLRectangleType = class(TXMLNodeCollection, IXMLRectangleType)
  protected
    { IXMLRectangleType }
    function Get_Summarization: UnicodeString;
    function Get_Point(Index: Integer): IXMLPointType;
    procedure Set_Summarization(Value: UnicodeString);
    function Add: IXMLPointType;
    function Insert(const Index: Integer): IXMLPointType;
  public
    procedure AfterConstruction; override;
  end;

{ TXMLCityType }

  TXMLCityType = class(TXMLNode, IXMLCityType)
  protected
    { IXMLCityType }
    function Get_State: UnicodeString;
    function Get_Summarization: UnicodeString;
    procedure Set_State(Value: UnicodeString);
    procedure Set_Summarization(Value: UnicodeString);
  end;

{ TXMLHeightType }

  TXMLHeightType = class(TXMLNode, IXMLHeightType)
  protected
    { IXMLHeightType }
    function Get_Datum: UnicodeString;
    function Get_Heightunits: UnicodeString;
    procedure Set_Datum(Value: UnicodeString);
    procedure Set_Heightunits(Value: UnicodeString);
  end;

{ TXMLLevelType }

  TXMLLevelType = class(TXMLNode, IXMLLevelType)
  protected
    { IXMLLevelType }
    function Get_Verticalcoordinate: UnicodeString;
    procedure Set_Verticalcoordinate(Value: UnicodeString);
  end;

{ TXMLLayerType }

  TXMLLayerType = class(TXMLNode, IXMLLayerType)
  protected
    { IXMLLayerType }
    function Get_Verticalcoordinate: UnicodeString;
    procedure Set_Verticalcoordinate(Value: UnicodeString);
  end;

{ TXMLMoreWeatherInformationType }

  TXMLMoreWeatherInformationType = class(TXMLNode, IXMLMoreWeatherInformationType)
  protected
    { IXMLMoreWeatherInformationType }
    function Get_Applicablelocation: UnicodeString;
    procedure Set_Applicablelocation(Value: UnicodeString);
  end;

{ TXMLMoreWeatherInformationTypeList }

  TXMLMoreWeatherInformationTypeList = class(TXMLNodeCollection, IXMLMoreWeatherInformationTypeList)
  protected
    { IXMLMoreWeatherInformationTypeList }
    function Add: IXMLMoreWeatherInformationType;
    function Insert(const Index: Integer): IXMLMoreWeatherInformationType;

    function Get_Item(Index: Integer): IXMLMoreWeatherInformationType;
  end;

{ TXMLTimelayoutElementType }

  TXMLTimelayoutElementType = class(TXMLNode, IXMLTimelayoutElementType)
  private
    FStartvalidtime: IXMLStartvalidtimeTypeList;
    FEndvalidtime: IXMLDateTimeList;
  protected
    { IXMLTimelayoutElementType }
    function Get_Timecoordinate: UnicodeString;
    function Get_Summarization: UnicodeString;
    function Get_Layoutkey: UnicodeString;
    function Get_Startvalidtime: IXMLStartvalidtimeTypeList;
    function Get_Endvalidtime: IXMLDateTimeList;
    procedure Set_Timecoordinate(Value: UnicodeString);
    procedure Set_Summarization(Value: UnicodeString);
    procedure Set_Layoutkey(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLTimelayoutElementTypeList }

  TXMLTimelayoutElementTypeList = class(TXMLNodeCollection, IXMLTimelayoutElementTypeList)
  protected
    { IXMLTimelayoutElementTypeList }
    function Add: IXMLTimelayoutElementType;
    function Insert(const Index: Integer): IXMLTimelayoutElementType;

    function Get_Item(Index: Integer): IXMLTimelayoutElementType;
  end;

{ TXMLStartvalidtimeType }

  TXMLStartvalidtimeType = class(TXMLNode, IXMLStartvalidtimeType)
  protected
    { IXMLStartvalidtimeType }
    function Get_Periodname: UnicodeString;
    procedure Set_Periodname(Value: UnicodeString);
  end;

{ TXMLStartvalidtimeTypeList }

  TXMLStartvalidtimeTypeList = class(TXMLNodeCollection, IXMLStartvalidtimeTypeList)
  protected
    { IXMLStartvalidtimeTypeList }
    function Add: IXMLStartvalidtimeType;
    function Insert(const Index: Integer): IXMLStartvalidtimeType;

    function Get_Item(Index: Integer): IXMLStartvalidtimeType;
  end;

{ TXMLParametersType }

  TXMLParametersType = class(TXMLNode, IXMLParametersType)
  private
    FCategories: IXMLCategoriesTypeList;
    FTemperature: IXMLTemperatureList;
    FPrecipitation: IXMLPrecipitationList;
    FProbabilityofprecipitation: IXMLProbabilityofprecipitationList;
    FFireweather: IXMLFireweatherList;
    FConvectivehazard: IXMLConvectivehazardList;
    FClimateanomaly: IXMLClimateanomalyList;
    FWindspeed: IXMLWindspeedList;
    FDirection: IXMLDirectionList;
    FCloudamount: IXMLCloudamountList;
    FHumidity: IXMLHumidityList;
    FWeather: IXMLWeatherList;
    FConditionsicon: IXMLConditionsiconList;
    FHazards: IXMLHazardsList;
    FPressure: IXMLPressureList;
    FProbabilisticCondition: IXMLProbabilisticConditionList;
    FWaterstate: IXMLWaterstateList;
  protected
    { IXMLParametersType }
    function Get_Applicablelocation: UnicodeString;
    function Get_Categories: IXMLCategoriesTypeList;
    function Get_Temperature: IXMLTemperatureList;
    function Get_Precipitation: IXMLPrecipitationList;
    function Get_Probabilityofprecipitation: IXMLProbabilityofprecipitationList;
    function Get_Fireweather: IXMLFireweatherList;
    function Get_Convectivehazard: IXMLConvectivehazardList;
    function Get_Climateanomaly: IXMLClimateanomalyList;
    function Get_Windspeed: IXMLWindspeedList;
    function Get_Direction: IXMLDirectionList;
    function Get_Cloudamount: IXMLCloudamountList;
    function Get_Humidity: IXMLHumidityList;
    function Get_Weather: IXMLWeatherList;
    function Get_Conditionsicon: IXMLConditionsiconList;
    function Get_Hazards: IXMLHazardsList;
    function Get_WordedForecast: IXMLWordedForecast;
    function Get_Pressure: IXMLPressureList;
    function Get_ProbabilisticCondition: IXMLProbabilisticConditionList;
    function Get_Waterstate: IXMLWaterstateList;
    procedure Set_Applicablelocation(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLParametersTypeList }

  TXMLParametersTypeList = class(TXMLNodeCollection, IXMLParametersTypeList)
  protected
    { IXMLParametersTypeList }
    function Add: IXMLParametersType;
    function Insert(const Index: Integer): IXMLParametersType;

    function Get_Item(Index: Integer): IXMLParametersType;
  end;

{ TXMLCategoriesType }

  TXMLCategoriesType = class(TXMLNode, IXMLCategoriesType)
  protected
    { IXMLCategoriesType }
    function Get_Type_: UnicodeString;
    function Get_Probabilitytype: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Categorieskey: UnicodeString;
    function Get_ValueList: IXMLValueListType;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Probabilitytype(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
    procedure Set_Categorieskey(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLCategoriesTypeList }

  TXMLCategoriesTypeList = class(TXMLNodeCollection, IXMLCategoriesTypeList)
  protected
    { IXMLCategoriesTypeList }
    function Add: IXMLCategoriesType;
    function Insert(const Index: Integer): IXMLCategoriesType;

    function Get_Item(Index: Integer): IXMLCategoriesType;
  end;

{ TXMLValueListType }

  TXMLValueListType = class(TXMLNode, IXMLValueListType)
  protected
    { IXMLValueListType }
    function Get_Median: UnicodeString;
    function Get_ConfidenceInterval50: UnicodeString;
    function Get_ConfidenceInterval80: UnicodeString;
    function Get_Skew80: UnicodeString;
    procedure Set_Median(Value: UnicodeString);
    procedure Set_ConfidenceInterval50(Value: UnicodeString);
    procedure Set_ConfidenceInterval80(Value: UnicodeString);
    procedure Set_Skew80(Value: UnicodeString);
  end;

{ TXMLValueListTypeList }

  TXMLValueListTypeList = class(TXMLNodeCollection, IXMLValueListTypeList)
  protected
    { IXMLValueListTypeList }
    function Add: IXMLValueListType;
    function Insert(const Index: Integer): IXMLValueListType;

    function Get_Item(Index: Integer): IXMLValueListType;
  end;

{ TXMLTemperature }

  TXMLTemperature = class(TXMLNode, IXMLTemperature)
  private
    FValue: IXMLTempValTypeList;
    FValueList: IXMLValueListTypeList;
    FValueWithUncertainty: IXMLValueWithUncertaintyList;
  protected
    { IXMLTemperature }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_LikelihoodUnits: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Applicablecategories: UnicodeString;
    function Get_Probabilitytype: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLTempValTypeList;
    function Get_ValueList: IXMLValueListTypeList;
    function Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_LikelihoodUnits(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Applicablecategories(Value: UnicodeString);
    procedure Set_Probabilitytype(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLTemperatureList }

  TXMLTemperatureList = class(TXMLNodeCollection, IXMLTemperatureList)
  protected
    { IXMLTemperatureList }
    function Add: IXMLTemperature;
    function Insert(const Index: Integer): IXMLTemperature;

    function Get_Item(Index: Integer): IXMLTemperature;
  end;

{ TXMLTempValType }

  TXMLTempValType = class(TXMLNode, IXMLTempValType)
  protected
    { IXMLTempValType }
    function Get_Upperrange: Integer;
    function Get_Lowerrange: Integer;
    function Get_Type_: UnicodeString;
    procedure Set_Upperrange(Value: Integer);
    procedure Set_Lowerrange(Value: Integer);
    procedure Set_Type_(Value: UnicodeString);
  end;

{ TXMLTempValTypeList }

  TXMLTempValTypeList = class(TXMLNodeCollection, IXMLTempValTypeList)
  protected
    { IXMLTempValTypeList }
    function Add: IXMLTempValType;
    function Insert(const Index: Integer): IXMLTempValType;

    function Get_Item(Index: Integer): IXMLTempValType;
  end;

{ TXMLValueWithUncertainty }

  TXMLValueWithUncertainty = class(TXMLNode, IXMLValueWithUncertainty)
  protected
    { IXMLValueWithUncertainty }
    function Get_Type_: UnicodeString;
    function Get_Value: IXMLTempValType;
    function Get_Uncertainty: IXMLUncertaintyType;
    function Get_NumberWithEquality: UnicodeString;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_NumberWithEquality(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLValueWithUncertaintyList }

  TXMLValueWithUncertaintyList = class(TXMLNodeCollection, IXMLValueWithUncertaintyList)
  protected
    { IXMLValueWithUncertaintyList }
    function Add: IXMLValueWithUncertainty;
    function Insert(const Index: Integer): IXMLValueWithUncertainty;

    function Get_Item(Index: Integer): IXMLValueWithUncertainty;
  end;

{ TXMLUncertaintyType }

  TXMLUncertaintyType = class(TXMLNode, IXMLUncertaintyType)
  protected
    { IXMLUncertaintyType }
    function Get_Type_: UnicodeString;
    function Get_Error: IXMLError;
    procedure Set_Type_(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLError }

  TXMLError = class(TXMLNode, IXMLError)
  protected
    { IXMLError }
    function Get_Qualifier: UnicodeString;
    procedure Set_Qualifier(Value: UnicodeString);
  end;

{ TXMLPrecipitation }

  TXMLPrecipitation = class(TXMLNode, IXMLPrecipitation)
  private
    FValue: IXMLDecimalValTypeList;
    FValueList: IXMLValueListTypeList;
    FValueWithUncertainty: IXMLValueWithUncertaintyList;
  protected
    { IXMLPrecipitation }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_LikelihoodUnits: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Probabilitytype: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLDecimalValTypeList;
    function Get_ValueList: IXMLValueListTypeList;
    function Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_LikelihoodUnits(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Probabilitytype(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLPrecipitationList }

  TXMLPrecipitationList = class(TXMLNodeCollection, IXMLPrecipitationList)
  protected
    { IXMLPrecipitationList }
    function Add: IXMLPrecipitation;
    function Insert(const Index: Integer): IXMLPrecipitation;

    function Get_Item(Index: Integer): IXMLPrecipitation;
  end;

{ TXMLDecimalValType }

  TXMLDecimalValType = class(TXMLNode, IXMLDecimalValType)
  protected
    { IXMLDecimalValType }
    function Get_Upperrange: LongWord;
    function Get_Lowerrange: LongWord;
    function Get_Type_: UnicodeString;
    procedure Set_Upperrange(Value: LongWord);
    procedure Set_Lowerrange(Value: LongWord);
    procedure Set_Type_(Value: UnicodeString);
  end;

{ TXMLDecimalValTypeList }

  TXMLDecimalValTypeList = class(TXMLNodeCollection, IXMLDecimalValTypeList)
  protected
    { IXMLDecimalValTypeList }
    function Add: IXMLDecimalValType;
    function Insert(const Index: Integer): IXMLDecimalValType;

    function Get_Item(Index: Integer): IXMLDecimalValType;
  end;

{ TXMLProbabilityofprecipitation }

  TXMLProbabilityofprecipitation = class(TXMLNode, IXMLProbabilityofprecipitation)
  private
    FValue: IXMLPercentageValTypeList;
    FValueList: IXMLValueListTypeList;
  protected
    { IXMLProbabilityofprecipitation }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_LikelihoodUnits: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Applicablecategories: UnicodeString;
    function Get_Probabilitytype: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLPercentageValTypeList;
    function Get_ValueList: IXMLValueListTypeList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_LikelihoodUnits(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Applicablecategories(Value: UnicodeString);
    procedure Set_Probabilitytype(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLProbabilityofprecipitationList }

  TXMLProbabilityofprecipitationList = class(TXMLNodeCollection, IXMLProbabilityofprecipitationList)
  protected
    { IXMLProbabilityofprecipitationList }
    function Add: IXMLProbabilityofprecipitation;
    function Insert(const Index: Integer): IXMLProbabilityofprecipitation;

    function Get_Item(Index: Integer): IXMLProbabilityofprecipitation;
  end;

{ TXMLPercentageValType }

  TXMLPercentageValType = class(TXMLNode, IXMLPercentageValType)
  protected
    { IXMLPercentageValType }
    function Get_Upperrange: LongWord;
    function Get_Lowerrange: LongWord;
    function Get_Type_: UnicodeString;
    procedure Set_Upperrange(Value: LongWord);
    procedure Set_Lowerrange(Value: LongWord);
    procedure Set_Type_(Value: UnicodeString);
  end;

{ TXMLPercentageValTypeList }

  TXMLPercentageValTypeList = class(TXMLNodeCollection, IXMLPercentageValTypeList)
  protected
    { IXMLPercentageValTypeList }
    function Add: IXMLPercentageValType;
    function Insert(const Index: Integer): IXMLPercentageValType;

    function Get_Item(Index: Integer): IXMLPercentageValType;
  end;

{ TXMLFireweather }

  TXMLFireweather = class(TXMLNode, IXMLFireweather)
  private
    FValue: IXMLValueList;
  protected
    { IXMLFireweather }
    function Get_Type_: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLValueList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLFireweatherList }

  TXMLFireweatherList = class(TXMLNodeCollection, IXMLFireweatherList)
  protected
    { IXMLFireweatherList }
    function Add: IXMLFireweather;
    function Insert(const Index: Integer): IXMLFireweather;

    function Get_Item(Index: Integer): IXMLFireweather;
  end;

{ TXMLConvectivehazard }

  TXMLConvectivehazard = class(TXMLNode, IXMLConvectivehazard)
  private
    FSeverecomponent: IXMLSeverecomponentList;
  protected
    { IXMLConvectivehazard }
    function Get_Outlook: IXMLOutlook;
    function Get_Severecomponent: IXMLSeverecomponentList;
  public
    procedure AfterConstruction; override;
  end;

{ TXMLConvectivehazardList }

  TXMLConvectivehazardList = class(TXMLNodeCollection, IXMLConvectivehazardList)
  protected
    { IXMLConvectivehazardList }
    function Add: IXMLConvectivehazard;
    function Insert(const Index: Integer): IXMLConvectivehazard;

    function Get_Item(Index: Integer): IXMLConvectivehazard;
  end;

{ TXMLOutlook }

  TXMLOutlook = class(TXMLNode, IXMLOutlook)
  private
    FValue: IXMLValueList;
  protected
    { IXMLOutlook }
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLValueList;
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLSeverecomponent }

  TXMLSeverecomponent = class(TXMLNode, IXMLSeverecomponent)
  private
    FValue: IXMLValueList;
  protected
    { IXMLSeverecomponent }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLValueList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLSeverecomponentList }

  TXMLSeverecomponentList = class(TXMLNodeCollection, IXMLSeverecomponentList)
  protected
    { IXMLSeverecomponentList }
    function Add: IXMLSeverecomponent;
    function Insert(const Index: Integer): IXMLSeverecomponent;

    function Get_Item(Index: Integer): IXMLSeverecomponent;
  end;

{ TXMLValue }

  TXMLValue = class(TXMLNode, IXMLValue)
  protected
    { IXMLValue }
    function Get_Upperrange: LongWord;
    function Get_Lowerrange: LongWord;
    procedure Set_Upperrange(Value: LongWord);
    procedure Set_Lowerrange(Value: LongWord);
  end;

{ TXMLValueList }

  TXMLValueList = class(TXMLNodeCollection, IXMLValueList)
  protected
    { IXMLValueList }
    function Add: IXMLValue;
    function Insert(const Index: Integer): IXMLValue;

    function Get_Item(Index: Integer): IXMLValue;
  end;

{ TXMLClimateanomaly }

  TXMLClimateanomaly = class(TXMLNode, IXMLClimateanomaly)
  private
    FWeekly: IXMLAnomalyTypeList;
    FMonthly: IXMLAnomalyTypeList;
    FSeasonal: IXMLAnomalyTypeList;
  protected
    { IXMLClimateanomaly }
    function Get_Weekly: IXMLAnomalyTypeList;
    function Get_Monthly: IXMLAnomalyTypeList;
    function Get_Seasonal: IXMLAnomalyTypeList;
  public
    procedure AfterConstruction; override;
  end;

{ TXMLClimateanomalyList }

  TXMLClimateanomalyList = class(TXMLNodeCollection, IXMLClimateanomalyList)
  protected
    { IXMLClimateanomalyList }
    function Add: IXMLClimateanomaly;
    function Insert(const Index: Integer): IXMLClimateanomaly;

    function Get_Item(Index: Integer): IXMLClimateanomaly;
  end;

{ TXMLAnomalyType }

  TXMLAnomalyType = class(TXMLNode, IXMLAnomalyType)
  private
    FValue: IXMLValueList;
  protected
    { IXMLAnomalyType }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLValueList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLAnomalyTypeList }

  TXMLAnomalyTypeList = class(TXMLNodeCollection, IXMLAnomalyTypeList)
  protected
    { IXMLAnomalyTypeList }
    function Add: IXMLAnomalyType;
    function Insert(const Index: Integer): IXMLAnomalyType;

    function Get_Item(Index: Integer): IXMLAnomalyType;
  end;

{ TXMLWindspeed }

  TXMLWindspeed = class(TXMLNode, IXMLWindspeed)
  private
    FValue: IXMLWspdValTypeList;
    FValueWithUncertainty: IXMLValueWithUncertaintyList;
  protected
    { IXMLWindspeed }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLWspdValTypeList;
    function Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLWindspeedList }

  TXMLWindspeedList = class(TXMLNodeCollection, IXMLWindspeedList)
  protected
    { IXMLWindspeedList }
    function Add: IXMLWindspeed;
    function Insert(const Index: Integer): IXMLWindspeed;

    function Get_Item(Index: Integer): IXMLWindspeed;
  end;

{ TXMLWspdValType }

  TXMLWspdValType = class(TXMLNode, IXMLWspdValType)
  protected
    { IXMLWspdValType }
    function Get_Upperrange: LongWord;
    function Get_Lowerrange: LongWord;
    function Get_Type_: UnicodeString;
    procedure Set_Upperrange(Value: LongWord);
    procedure Set_Lowerrange(Value: LongWord);
    procedure Set_Type_(Value: UnicodeString);
  end;

{ TXMLWspdValTypeList }

  TXMLWspdValTypeList = class(TXMLNodeCollection, IXMLWspdValTypeList)
  protected
    { IXMLWspdValTypeList }
    function Add: IXMLWspdValType;
    function Insert(const Index: Integer): IXMLWspdValType;

    function Get_Item(Index: Integer): IXMLWspdValType;
  end;

{ TXMLDirection }

  TXMLDirection = class(TXMLNode, IXMLDirection)
  private
    FValue: IXMLWdirValTypeList;
    FValueWithUncertainty: IXMLValueWithUncertaintyList;
  protected
    { IXMLDirection }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLWdirValTypeList;
    function Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLDirectionList }

  TXMLDirectionList = class(TXMLNodeCollection, IXMLDirectionList)
  protected
    { IXMLDirectionList }
    function Add: IXMLDirection;
    function Insert(const Index: Integer): IXMLDirection;

    function Get_Item(Index: Integer): IXMLDirection;
  end;

{ TXMLWdirValType }

  TXMLWdirValType = class(TXMLNode, IXMLWdirValType)
  protected
    { IXMLWdirValType }
    function Get_Upperrange: LongWord;
    function Get_Lowerrange: LongWord;
    function Get_Type_: UnicodeString;
    procedure Set_Upperrange(Value: LongWord);
    procedure Set_Lowerrange(Value: LongWord);
    procedure Set_Type_(Value: UnicodeString);
  end;

{ TXMLWdirValTypeList }

  TXMLWdirValTypeList = class(TXMLNodeCollection, IXMLWdirValTypeList)
  protected
    { IXMLWdirValTypeList }
    function Add: IXMLWdirValType;
    function Insert(const Index: Integer): IXMLWdirValType;

    function Get_Item(Index: Integer): IXMLWdirValType;
  end;

{ TXMLCloudamount }

  TXMLCloudamount = class(TXMLNode, IXMLCloudamount)
  private
    FValue: IXMLPercentageValTypeList;
    FValueWithUncertainty: IXMLValueWithUncertaintyList;
  protected
    { IXMLCloudamount }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLPercentageValTypeList;
    function Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLCloudamountList }

  TXMLCloudamountList = class(TXMLNodeCollection, IXMLCloudamountList)
  protected
    { IXMLCloudamountList }
    function Add: IXMLCloudamount;
    function Insert(const Index: Integer): IXMLCloudamount;

    function Get_Item(Index: Integer): IXMLCloudamount;
  end;

{ TXMLHumidity }

  TXMLHumidity = class(TXMLNode, IXMLHumidity)
  private
    FValue: IXMLValueList;
  protected
    { IXMLHumidity }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLValueList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLHumidityList }

  TXMLHumidityList = class(TXMLNodeCollection, IXMLHumidityList)
  protected
    { IXMLHumidityList }
    function Add: IXMLHumidity;
    function Insert(const Index: Integer): IXMLHumidity;

    function Get_Item(Index: Integer): IXMLHumidity;
  end;

{ TXMLWeather }

  TXMLWeather = class(TXMLNode, IXMLWeather)
  private
    FName: IXMLString_List;
    FWeatherconditions: IXMLWeatherconditionsList;
  protected
    { IXMLWeather }
    function Get_Timelayout: UnicodeString;
    function Get_Name: IXMLString_List;
    function Get_Weatherconditions: IXMLWeatherconditionsList;
    procedure Set_Timelayout(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLWeatherList }

  TXMLWeatherList = class(TXMLNodeCollection, IXMLWeatherList)
  protected
    { IXMLWeatherList }
    function Add: IXMLWeather;
    function Insert(const Index: Integer): IXMLWeather;

    function Get_Item(Index: Integer): IXMLWeather;
  end;

{ TXMLWeatherconditions }

  TXMLWeatherconditions = class(TXMLNodeCollection, IXMLWeatherconditions)
  protected
    { IXMLWeatherconditions }
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Weathersummary: UnicodeString;
    function Get_Value(Index: Integer): IXMLValue;
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Weathersummary(Value: UnicodeString);
    function Add: IXMLValue;
    function Insert(const Index: Integer): IXMLValue;
  public
    procedure AfterConstruction; override;
  end;

{ TXMLWeatherconditionsList }

  TXMLWeatherconditionsList = class(TXMLNodeCollection, IXMLWeatherconditionsList)
  protected
    { IXMLWeatherconditionsList }
    function Add: IXMLWeatherconditions;
    function Insert(const Index: Integer): IXMLWeatherconditions;

    function Get_Item(Index: Integer): IXMLWeatherconditions;
  end;

{ TXMLConditionsicon }

  TXMLConditionsicon = class(TXMLNode, IXMLConditionsicon)
  private
    FIconlink: IXMLAnyURIList;
  protected
    { IXMLConditionsicon }
    function Get_Timelayout: UnicodeString;
    function Get_Type_: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Iconlink: IXMLAnyURIList;
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLConditionsiconList }

  TXMLConditionsiconList = class(TXMLNodeCollection, IXMLConditionsiconList)
  protected
    { IXMLConditionsiconList }
    function Add: IXMLConditionsicon;
    function Insert(const Index: Integer): IXMLConditionsicon;

    function Get_Item(Index: Integer): IXMLConditionsicon;
  end;

{ TXMLHazards }

  TXMLHazards = class(TXMLNode, IXMLHazards)
  private
    FName: IXMLString_List;
    FHazardconditions: IXMLHazardconditionsList;
  protected
    { IXMLHazards }
    function Get_Timelayout: UnicodeString;
    function Get_Name: IXMLString_List;
    function Get_Hazardconditions: IXMLHazardconditionsList;
    procedure Set_Timelayout(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLHazardsList }

  TXMLHazardsList = class(TXMLNodeCollection, IXMLHazardsList)
  protected
    { IXMLHazardsList }
    function Add: IXMLHazards;
    function Insert(const Index: Integer): IXMLHazards;

    function Get_Item(Index: Integer): IXMLHazards;
  end;

{ TXMLHazardconditions }

  TXMLHazardconditions = class(TXMLNodeCollection, IXMLHazardconditions)
  protected
    { IXMLHazardconditions }
    function Get_Hazard(Index: Integer): IXMLHazard;
    function Add: IXMLHazard;
    function Insert(const Index: Integer): IXMLHazard;
  public
    procedure AfterConstruction; override;
  end;

{ TXMLHazardconditionsList }

  TXMLHazardconditionsList = class(TXMLNodeCollection, IXMLHazardconditionsList)
  protected
    { IXMLHazardconditionsList }
    function Add: IXMLHazardconditions;
    function Insert(const Index: Integer): IXMLHazardconditions;

    function Get_Item(Index: Integer): IXMLHazardconditions;
  end;

{ TXMLHazard }

  TXMLHazard = class(TXMLNode, IXMLHazard)
  protected
    { IXMLHazard }
    function Get_HazardCode: UnicodeString;
    function Get_Phenomena: UnicodeString;
    function Get_Significance: UnicodeString;
    function Get_HazardType: UnicodeString;
    function Get_EventTrackingNumber: Integer;
    function Get_Headline: UnicodeString;
    function Get_HazardTextURL: UnicodeString;
    function Get_HazardIcon: UnicodeString;
    procedure Set_HazardCode(Value: UnicodeString);
    procedure Set_Phenomena(Value: UnicodeString);
    procedure Set_Significance(Value: UnicodeString);
    procedure Set_HazardType(Value: UnicodeString);
    procedure Set_EventTrackingNumber(Value: Integer);
    procedure Set_Headline(Value: UnicodeString);
    procedure Set_HazardTextURL(Value: UnicodeString);
    procedure Set_HazardIcon(Value: UnicodeString);
  end;

{ TXMLWordedForecast }

  TXMLWordedForecast = class(TXMLNode, IXMLWordedForecast)
  private
    FText: IXMLString_List;
  protected
    { IXMLWordedForecast }
    function Get_Timelayout: UnicodeString;
    function Get_DataSource: UnicodeString;
    function Get_WordGenerator: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Text: IXMLString_List;
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_DataSource(Value: UnicodeString);
    procedure Set_WordGenerator(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLPressure }

  TXMLPressure = class(TXMLNode, IXMLPressure)
  private
    FValue: IXMLDecimalValTypeList;
  protected
    { IXMLPressure }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLDecimalValTypeList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLPressureList }

  TXMLPressureList = class(TXMLNodeCollection, IXMLPressureList)
  protected
    { IXMLPressureList }
    function Add: IXMLPressure;
    function Insert(const Index: Integer): IXMLPressure;

    function Get_Item(Index: Integer): IXMLPressure;
  end;

{ TXMLProbabilisticCondition }

  TXMLProbabilisticCondition = class(TXMLNode, IXMLProbabilisticCondition)
  private
    FValue: IXMLPercentageValTypeList;
    FValueForRange: IXMLValueForRangeTypeList;
  protected
    { IXMLProbabilisticCondition }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_LikelihoodUnits: UnicodeString;
    function Get_Timelayout: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Applicablecategories: UnicodeString;
    function Get_Probabilitytype: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLPercentageValTypeList;
    function Get_ValueForRange: IXMLValueForRangeTypeList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_LikelihoodUnits(Value: UnicodeString);
    procedure Set_Timelayout(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Applicablecategories(Value: UnicodeString);
    procedure Set_Probabilitytype(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLProbabilisticConditionList }

  TXMLProbabilisticConditionList = class(TXMLNodeCollection, IXMLProbabilisticConditionList)
  protected
    { IXMLProbabilisticConditionList }
    function Add: IXMLProbabilisticCondition;
    function Insert(const Index: Integer): IXMLProbabilisticCondition;

    function Get_Item(Index: Integer): IXMLProbabilisticCondition;
  end;

{ TXMLValueForRangeType }

  TXMLValueForRangeType = class(TXMLNode, IXMLValueForRangeType)
  private
    FValue: IXMLPercentageValTypeList;
  protected
    { IXMLValueForRangeType }
    function Get_Value: IXMLPercentageValTypeList;
    function Get_Gt: UnicodeString;
    function Get_Ge: UnicodeString;
    function Get_Lt: UnicodeString;
    function Get_Le: UnicodeString;
    function Get_Eq: UnicodeString;
    procedure Set_Gt(Value: UnicodeString);
    procedure Set_Ge(Value: UnicodeString);
    procedure Set_Lt(Value: UnicodeString);
    procedure Set_Le(Value: UnicodeString);
    procedure Set_Eq(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLValueForRangeTypeList }

  TXMLValueForRangeTypeList = class(TXMLNodeCollection, IXMLValueForRangeTypeList)
  protected
    { IXMLValueForRangeTypeList }
    function Add: IXMLValueForRangeType;
    function Insert(const Index: Integer): IXMLValueForRangeType;

    function Get_Item(Index: Integer): IXMLValueForRangeType;
  end;

{ TXMLWaterstate }

  TXMLWaterstate = class(TXMLNode, IXMLWaterstate)
  private
    FWaves: IXMLWavesList;
    FSwell: IXMLSwellList;
    FSeas: IXMLSeasList;
    FIcecoverage: IXMLNonNegativeIntegerList;
  protected
    { IXMLWaterstate }
    function Get_Timelayout: UnicodeString;
    function Get_Waves: IXMLWavesList;
    function Get_Swell: IXMLSwellList;
    function Get_Seas: IXMLSeasList;
    function Get_Icecoverage: IXMLNonNegativeIntegerList;
    procedure Set_Timelayout(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLWaterstateList }

  TXMLWaterstateList = class(TXMLNodeCollection, IXMLWaterstateList)
  protected
    { IXMLWaterstateList }
    function Add: IXMLWaterstate;
    function Insert(const Index: Integer): IXMLWaterstate;

    function Get_Item(Index: Integer): IXMLWaterstate;
  end;

{ TXMLWaves }

  TXMLWaves = class(TXMLNode, IXMLWaves)
  private
    FValue: IXMLNonNegativeIntegerList;
  protected
    { IXMLWaves }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Period: LongWord;
    function Get_Steepness: LongWord;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLNonNegativeIntegerList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Period(Value: LongWord);
    procedure Set_Steepness(Value: LongWord);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLWavesList }

  TXMLWavesList = class(TXMLNodeCollection, IXMLWavesList)
  protected
    { IXMLWavesList }
    function Add: IXMLWaves;
    function Insert(const Index: Integer): IXMLWaves;

    function Get_Item(Index: Integer): IXMLWaves;
  end;

{ TXMLSwell }

  TXMLSwell = class(TXMLNode, IXMLSwell)
  protected
    { IXMLSwell }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Period: LongWord;
    function Get_Steepness: LongWord;
    function Get_Name: UnicodeString;
    function Get_Value: UnicodeString;
    function Get_Direction: IXMLDirection;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Period(Value: LongWord);
    procedure Set_Steepness(Value: LongWord);
    procedure Set_Name(Value: UnicodeString);
    procedure Set_Value(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLSwellList }

  TXMLSwellList = class(TXMLNodeCollection, IXMLSwellList)
  protected
    { IXMLSwellList }
    function Add: IXMLSwell;
    function Insert(const Index: Integer): IXMLSwell;

    function Get_Item(Index: Integer): IXMLSwell;
  end;

{ TXMLSeas }

  TXMLSeas = class(TXMLNode, IXMLSeas)
  private
    FValue: IXMLNonNegativeIntegerList;
  protected
    { IXMLSeas }
    function Get_Type_: UnicodeString;
    function Get_Units: UnicodeString;
    function Get_Categoricaltable: UnicodeString;
    function Get_Conversiontable: UnicodeString;
    function Get_Name: UnicodeString;
    function Get_Value: IXMLNonNegativeIntegerList;
    procedure Set_Type_(Value: UnicodeString);
    procedure Set_Units(Value: UnicodeString);
    procedure Set_Categoricaltable(Value: UnicodeString);
    procedure Set_Conversiontable(Value: UnicodeString);
    procedure Set_Name(Value: UnicodeString);
  public
    procedure AfterConstruction; override;
  end;

{ TXMLSeasList }

  TXMLSeasList = class(TXMLNodeCollection, IXMLSeasList)
  protected
    { IXMLSeasList }
    function Add: IXMLSeas;
    function Insert(const Index: Integer): IXMLSeas;

    function Get_Item(Index: Integer): IXMLSeas;
  end;

{ TXMLNonNegativeIntegerList }

  TXMLNonNegativeIntegerList = class(TXMLNodeCollection, IXMLNonNegativeIntegerList)
  protected
    { IXMLNonNegativeIntegerList }
    function Add(const Value: LongWord): IXMLNode;
    function Insert(const Index: Integer; const Value: LongWord): IXMLNode;

    function Get_Item(Index: Integer): LongWord;
  end;

{ TXMLDateTimeList }

  TXMLDateTimeList = class(TXMLNodeCollection, IXMLDateTimeList)
  protected
    { IXMLDateTimeList }
    function Add(const Value: UnicodeString): IXMLNode;
    function Insert(const Index: Integer; const Value: UnicodeString): IXMLNode;

    function Get_Item(Index: Integer): UnicodeString;
  end;

{ TXMLAnyURIList }

  TXMLAnyURIList = class(TXMLNodeCollection, IXMLAnyURIList)
  protected
    { IXMLAnyURIList }
    function Add(const Value: UnicodeString): IXMLNode;
    function Insert(const Index: Integer; const Value: UnicodeString): IXMLNode;

    function Get_Item(Index: Integer): UnicodeString;
  end;

{ TXMLString_List }

  TXMLString_List = class(TXMLNodeCollection, IXMLString_List)
  protected
    { IXMLString_List }
    function Add(const Value: UnicodeString): IXMLNode;
    function Insert(const Index: Integer; const Value: UnicodeString): IXMLNode;

    function Get_Item(Index: Integer): UnicodeString;
  end;

{ Global Functions }

function Getdwml(Doc: IXMLDocument): IXMLDwml;
function Loaddwml(const FileName: string): IXMLDwml;
function Newdwml: IXMLDwml;

const
  TargetNamespace = '';

implementation

{ Global Functions }

function Getdwml(Doc: IXMLDocument): IXMLDwml;
begin
  Result := Doc.GetDocBinding('dwml', TXMLDwml, TargetNamespace) as IXMLDwml;
end;

function Loaddwml(const FileName: string): IXMLDwml;
begin
  Result := LoadXMLDocument(FileName).GetDocBinding('dwml', TXMLDwml, TargetNamespace) as IXMLDwml;
end;

function Newdwml: IXMLDwml;
begin
  Result := NewXMLDocument.GetDocBinding('dwml', TXMLDwml, TargetNamespace) as IXMLDwml;
end;

{ TXMLDwml }

procedure TXMLDwml.AfterConstruction;
begin
  RegisterChildNode('head', TXMLHeadType);
  RegisterChildNode('data', TXMLDataType);
  FData := CreateCollection(TXMLDataTypeList, IXMLDataType, 'data') as IXMLDataTypeList;
  inherited;
end;

function TXMLDwml.Get_Version: UnicodeString;
begin
  Result := AttributeNodes['version'].Text;
end;

procedure TXMLDwml.Set_Version(Value: UnicodeString);
begin
  SetAttribute('version', Value);
end;

function TXMLDwml.Get_Head: IXMLHeadType;
begin
  Result := ChildNodes['head'] as IXMLHeadType;
end;

function TXMLDwml.Get_Data: IXMLDataTypeList;
begin
  Result := FData;
end;

function TXMLDwml.Get_MinResolution: UnicodeString;
begin
  Result := ChildNodes['minResolution'].Text;
end;

procedure TXMLDwml.Set_MinResolution(Value: UnicodeString);
begin
  ChildNodes['minResolution'].NodeValue := Value;
end;

function TXMLDwml.Get_LatLonList: UnicodeString;
begin
  Result := ChildNodes['latLonList'].Text;
end;

procedure TXMLDwml.Set_LatLonList(Value: UnicodeString);
begin
  ChildNodes['latLonList'].NodeValue := Value;
end;

function TXMLDwml.Get_CityNameList: UnicodeString;
begin
  Result := ChildNodes['cityNameList'].Text;
end;

procedure TXMLDwml.Set_CityNameList(Value: UnicodeString);
begin
  ChildNodes['cityNameList'].NodeValue := Value;
end;

{ TXMLHeadType }

procedure TXMLHeadType.AfterConstruction;
begin
  RegisterChildNode('product', TXMLProductType);
  RegisterChildNode('source', TXMLSourceType);
  inherited;
end;

function TXMLHeadType.Get_Product: IXMLProductType;
begin
  Result := ChildNodes['product'] as IXMLProductType;
end;

function TXMLHeadType.Get_Source: IXMLSourceType;
begin
  Result := ChildNodes['source'] as IXMLSourceType;
end;

{ TXMLProductType }

procedure TXMLProductType.AfterConstruction;
begin
  RegisterChildNode('creation-date', TXMLCreationdateType);
  inherited;
end;

function TXMLProductType.Get_Concisename: UnicodeString;
begin
  Result := AttributeNodes['concise-name'].Text;
end;

procedure TXMLProductType.Set_Concisename(Value: UnicodeString);
begin
  SetAttribute('concise-name', Value);
end;

function TXMLProductType.Get_Operationalmode: UnicodeString;
begin
  Result := AttributeNodes['operational-mode'].Text;
end;

procedure TXMLProductType.Set_Operationalmode(Value: UnicodeString);
begin
  SetAttribute('operational-mode', Value);
end;

function TXMLProductType.Get_SrsName: UnicodeString;
begin
  Result := AttributeNodes['srsName'].Text;
end;

procedure TXMLProductType.Set_SrsName(Value: UnicodeString);
begin
  SetAttribute('srsName', Value);
end;

function TXMLProductType.Get_Title: UnicodeString;
begin
  Result := ChildNodes['title'].Text;
end;

procedure TXMLProductType.Set_Title(Value: UnicodeString);
begin
  ChildNodes['title'].NodeValue := Value;
end;

function TXMLProductType.Get_Field: UnicodeString;
begin
  Result := ChildNodes['field'].Text;
end;

procedure TXMLProductType.Set_Field(Value: UnicodeString);
begin
  ChildNodes['field'].NodeValue := Value;
end;

function TXMLProductType.Get_Category: UnicodeString;
begin
  Result := ChildNodes['category'].Text;
end;

procedure TXMLProductType.Set_Category(Value: UnicodeString);
begin
  ChildNodes['category'].NodeValue := Value;
end;

function TXMLProductType.Get_Creationdate: IXMLCreationdateType;
begin
  Result := ChildNodes['creation-date'] as IXMLCreationdateType;
end;

{ TXMLCreationdateType }

function TXMLCreationdateType.Get_Refreshfrequency: UnicodeString;
begin
  Result := AttributeNodes['refresh-frequency'].Text;
end;

procedure TXMLCreationdateType.Set_Refreshfrequency(Value: UnicodeString);
begin
  SetAttribute('refresh-frequency', Value);
end;

{ TXMLSourceType }

procedure TXMLSourceType.AfterConstruction;
begin
  RegisterChildNode('production-center', TXMLProductioncenterType);
  inherited;
end;

function TXMLSourceType.Get_Moreinformation: UnicodeString;
begin
  Result := ChildNodes['more-information'].Text;
end;

procedure TXMLSourceType.Set_Moreinformation(Value: UnicodeString);
begin
  ChildNodes['more-information'].NodeValue := Value;
end;

function TXMLSourceType.Get_Productioncenter: IXMLProductioncenterType;
begin
  Result := ChildNodes['production-center'] as IXMLProductioncenterType;
end;

function TXMLSourceType.Get_Disclaimer: UnicodeString;
begin
  Result := ChildNodes['disclaimer'].Text;
end;

procedure TXMLSourceType.Set_Disclaimer(Value: UnicodeString);
begin
  ChildNodes['disclaimer'].NodeValue := Value;
end;

function TXMLSourceType.Get_Credit: UnicodeString;
begin
  Result := ChildNodes['credit'].Text;
end;

procedure TXMLSourceType.Set_Credit(Value: UnicodeString);
begin
  ChildNodes['credit'].NodeValue := Value;
end;

function TXMLSourceType.Get_Creditlogo: UnicodeString;
begin
  Result := ChildNodes['credit-logo'].Text;
end;

procedure TXMLSourceType.Set_Creditlogo(Value: UnicodeString);
begin
  ChildNodes['credit-logo'].NodeValue := Value;
end;

function TXMLSourceType.Get_Feedback: UnicodeString;
begin
  Result := ChildNodes['feedback'].Text;
end;

procedure TXMLSourceType.Set_Feedback(Value: UnicodeString);
begin
  ChildNodes['feedback'].NodeValue := Value;
end;

{ TXMLProductioncenterType }

function TXMLProductioncenterType.Get_Subcenter: UnicodeString;
begin
  Result := ChildNodes['sub-center'].Text;
end;

procedure TXMLProductioncenterType.Set_Subcenter(Value: UnicodeString);
begin
  ChildNodes['sub-center'].NodeValue := Value;
end;

{ TXMLDataType }

procedure TXMLDataType.AfterConstruction;
begin
  RegisterChildNode('location', TXMLLocationType);
  RegisterChildNode('moreWeatherInformation', TXMLMoreWeatherInformationType);
  RegisterChildNode('time-layout', TXMLTimelayoutElementType);
  RegisterChildNode('parameters', TXMLParametersType);
  FLocation := CreateCollection(TXMLLocationTypeList, IXMLLocationType, 'location') as IXMLLocationTypeList;
  FMoreWeatherInformation := CreateCollection(TXMLMoreWeatherInformationTypeList, IXMLMoreWeatherInformationType, 'moreWeatherInformation') as IXMLMoreWeatherInformationTypeList;
  FTimelayout := CreateCollection(TXMLTimelayoutElementTypeList, IXMLTimelayoutElementType, 'time-layout') as IXMLTimelayoutElementTypeList;
  FParameters := CreateCollection(TXMLParametersTypeList, IXMLParametersType, 'parameters') as IXMLParametersTypeList;
  inherited;
end;

function TXMLDataType.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLDataType.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLDataType.Get_Location: IXMLLocationTypeList;
begin
  Result := FLocation;
end;

function TXMLDataType.Get_MoreWeatherInformation: IXMLMoreWeatherInformationTypeList;
begin
  Result := FMoreWeatherInformation;
end;

function TXMLDataType.Get_Timelayout: IXMLTimelayoutElementTypeList;
begin
  Result := FTimelayout;
end;

function TXMLDataType.Get_Parameters: IXMLParametersTypeList;
begin
  Result := FParameters;
end;

{ TXMLDataTypeList }

function TXMLDataTypeList.Add: IXMLDataType;
begin
  Result := AddItem(-1) as IXMLDataType;
end;

function TXMLDataTypeList.Insert(const Index: Integer): IXMLDataType;
begin
  Result := AddItem(Index) as IXMLDataType;
end;

function TXMLDataTypeList.Get_Item(Index: Integer): IXMLDataType;
begin
  Result := List[Index] as IXMLDataType;
end;

{ TXMLLocationType }

procedure TXMLLocationType.AfterConstruction;
begin
  RegisterChildNode('point', TXMLPointType);
  RegisterChildNode('nws-zone', TXMLNwszoneType);
  RegisterChildNode('area', TXMLAreaType);
  RegisterChildNode('city', TXMLCityType);
  RegisterChildNode('height', TXMLHeightType);
  RegisterChildNode('level', TXMLLevelType);
  RegisterChildNode('layer', TXMLLayerType);
  inherited;
end;

function TXMLLocationType.Get_Locationkey: UnicodeString;
begin
  Result := ChildNodes['location-key'].Text;
end;

procedure TXMLLocationType.Set_Locationkey(Value: UnicodeString);
begin
  ChildNodes['location-key'].NodeValue := Value;
end;

function TXMLLocationType.Get_Description: UnicodeString;
begin
  Result := ChildNodes['description'].Text;
end;

procedure TXMLLocationType.Set_Description(Value: UnicodeString);
begin
  ChildNodes['description'].NodeValue := Value;
end;

function TXMLLocationType.Get_Point: IXMLPointType;
begin
  Result := ChildNodes['point'] as IXMLPointType;
end;

function TXMLLocationType.Get_Nwszone: IXMLNwszoneType;
begin
  Result := ChildNodes['nws-zone'] as IXMLNwszoneType;
end;

function TXMLLocationType.Get_Area: IXMLAreaType;
begin
  Result := ChildNodes['area'] as IXMLAreaType;
end;

function TXMLLocationType.Get_City: IXMLCityType;
begin
  Result := ChildNodes['city'] as IXMLCityType;
end;

function TXMLLocationType.Get_Areadescription: UnicodeString;
begin
  Result := ChildNodes['area-description'].Text;
end;

procedure TXMLLocationType.Set_Areadescription(Value: UnicodeString);
begin
  ChildNodes['area-description'].NodeValue := Value;
end;

function TXMLLocationType.Get_Height: IXMLHeightType;
begin
  Result := ChildNodes['height'] as IXMLHeightType;
end;

function TXMLLocationType.Get_Level: IXMLLevelType;
begin
  Result := ChildNodes['level'] as IXMLLevelType;
end;

function TXMLLocationType.Get_Layer: IXMLLayerType;
begin
  Result := ChildNodes['layer'] as IXMLLayerType;
end;

{ TXMLLocationTypeList }

function TXMLLocationTypeList.Add: IXMLLocationType;
begin
  Result := AddItem(-1) as IXMLLocationType;
end;

function TXMLLocationTypeList.Insert(const Index: Integer): IXMLLocationType;
begin
  Result := AddItem(Index) as IXMLLocationType;
end;

function TXMLLocationTypeList.Get_Item(Index: Integer): IXMLLocationType;
begin
  Result := List[Index] as IXMLLocationType;
end;

{ TXMLPointType }

function TXMLPointType.Get_Latitude: UnicodeString;
begin
  Result := AttributeNodes['latitude'].Text;
end;

procedure TXMLPointType.Set_Latitude(Value: UnicodeString);
begin
  SetAttribute('latitude', Value);
end;

function TXMLPointType.Get_Longitude: UnicodeString;
begin
  Result := AttributeNodes['longitude'].Text;
end;

procedure TXMLPointType.Set_Longitude(Value: UnicodeString);
begin
  SetAttribute('longitude', Value);
end;

function TXMLPointType.Get_Summarization: UnicodeString;
begin
  Result := AttributeNodes['summarization'].Text;
end;

procedure TXMLPointType.Set_Summarization(Value: UnicodeString);
begin
  SetAttribute('summarization', Value);
end;

{ TXMLNwszoneType }

function TXMLNwszoneType.Get_State: UnicodeString;
begin
  Result := AttributeNodes['state'].Text;
end;

procedure TXMLNwszoneType.Set_State(Value: UnicodeString);
begin
  SetAttribute('state', Value);
end;

function TXMLNwszoneType.Get_Summarization: UnicodeString;
begin
  Result := AttributeNodes['summarization'].Text;
end;

procedure TXMLNwszoneType.Set_Summarization(Value: UnicodeString);
begin
  SetAttribute('summarization', Value);
end;

{ TXMLAreaType }

procedure TXMLAreaType.AfterConstruction;
begin
  RegisterChildNode('circle', TXMLCircleType);
  RegisterChildNode('rectangle', TXMLRectangleType);
  inherited;
end;

function TXMLAreaType.Get_Areatype: UnicodeString;
begin
  Result := AttributeNodes['area-type'].Text;
end;

procedure TXMLAreaType.Set_Areatype(Value: UnicodeString);
begin
  SetAttribute('area-type', Value);
end;

function TXMLAreaType.Get_Circle: IXMLCircleType;
begin
  Result := ChildNodes['circle'] as IXMLCircleType;
end;

function TXMLAreaType.Get_Rectangle: IXMLRectangleType;
begin
  Result := ChildNodes['rectangle'] as IXMLRectangleType;
end;

{ TXMLCircleType }

procedure TXMLCircleType.AfterConstruction;
begin
  RegisterChildNode('point', TXMLPointType);
  RegisterChildNode('radius', TXMLRadiusType);
  inherited;
end;

function TXMLCircleType.Get_Summarization: UnicodeString;
begin
  Result := AttributeNodes['summarization'].Text;
end;

procedure TXMLCircleType.Set_Summarization(Value: UnicodeString);
begin
  SetAttribute('summarization', Value);
end;

function TXMLCircleType.Get_Point: IXMLPointType;
begin
  Result := ChildNodes['point'] as IXMLPointType;
end;

function TXMLCircleType.Get_Radius: IXMLRadiusType;
begin
  Result := ChildNodes['radius'] as IXMLRadiusType;
end;

{ TXMLRadiusType }

function TXMLRadiusType.Get_Radiusunits: UnicodeString;
begin
  Result := AttributeNodes['radius-units'].Text;
end;

procedure TXMLRadiusType.Set_Radiusunits(Value: UnicodeString);
begin
  SetAttribute('radius-units', Value);
end;

{ TXMLRectangleType }

procedure TXMLRectangleType.AfterConstruction;
begin
  RegisterChildNode('point', TXMLPointType);
  ItemTag := 'point';
  ItemInterface := IXMLPointType;
  inherited;
end;

function TXMLRectangleType.Get_Summarization: UnicodeString;
begin
  Result := AttributeNodes['summarization'].Text;
end;

procedure TXMLRectangleType.Set_Summarization(Value: UnicodeString);
begin
  SetAttribute('summarization', Value);
end;

function TXMLRectangleType.Get_Point(Index: Integer): IXMLPointType;
begin
  Result := List[Index] as IXMLPointType;
end;

function TXMLRectangleType.Add: IXMLPointType;
begin
  Result := AddItem(-1) as IXMLPointType;
end;

function TXMLRectangleType.Insert(const Index: Integer): IXMLPointType;
begin
  Result := AddItem(Index) as IXMLPointType;
end;

{ TXMLCityType }

function TXMLCityType.Get_State: UnicodeString;
begin
  Result := AttributeNodes['state'].Text;
end;

procedure TXMLCityType.Set_State(Value: UnicodeString);
begin
  SetAttribute('state', Value);
end;

function TXMLCityType.Get_Summarization: UnicodeString;
begin
  Result := AttributeNodes['summarization'].Text;
end;

procedure TXMLCityType.Set_Summarization(Value: UnicodeString);
begin
  SetAttribute('summarization', Value);
end;

{ TXMLHeightType }

function TXMLHeightType.Get_Datum: UnicodeString;
begin
  Result := AttributeNodes['datum'].Text;
end;

procedure TXMLHeightType.Set_Datum(Value: UnicodeString);
begin
  SetAttribute('datum', Value);
end;

function TXMLHeightType.Get_Heightunits: UnicodeString;
begin
  Result := AttributeNodes['height-units'].Text;
end;

procedure TXMLHeightType.Set_Heightunits(Value: UnicodeString);
begin
  SetAttribute('height-units', Value);
end;

{ TXMLLevelType }

function TXMLLevelType.Get_Verticalcoordinate: UnicodeString;
begin
  Result := AttributeNodes['vertical-coordinate'].Text;
end;

procedure TXMLLevelType.Set_Verticalcoordinate(Value: UnicodeString);
begin
  SetAttribute('vertical-coordinate', Value);
end;

{ TXMLLayerType }

function TXMLLayerType.Get_Verticalcoordinate: UnicodeString;
begin
  Result := AttributeNodes['vertical-coordinate'].Text;
end;

procedure TXMLLayerType.Set_Verticalcoordinate(Value: UnicodeString);
begin
  SetAttribute('vertical-coordinate', Value);
end;

{ TXMLMoreWeatherInformationType }

function TXMLMoreWeatherInformationType.Get_Applicablelocation: UnicodeString;
begin
  Result := AttributeNodes['applicable-location'].Text;
end;

procedure TXMLMoreWeatherInformationType.Set_Applicablelocation(Value: UnicodeString);
begin
  SetAttribute('applicable-location', Value);
end;

{ TXMLMoreWeatherInformationTypeList }

function TXMLMoreWeatherInformationTypeList.Add: IXMLMoreWeatherInformationType;
begin
  Result := AddItem(-1) as IXMLMoreWeatherInformationType;
end;

function TXMLMoreWeatherInformationTypeList.Insert(const Index: Integer): IXMLMoreWeatherInformationType;
begin
  Result := AddItem(Index) as IXMLMoreWeatherInformationType;
end;

function TXMLMoreWeatherInformationTypeList.Get_Item(Index: Integer): IXMLMoreWeatherInformationType;
begin
  Result := List[Index] as IXMLMoreWeatherInformationType;
end;

{ TXMLTimelayoutElementType }

procedure TXMLTimelayoutElementType.AfterConstruction;
begin
  RegisterChildNode('start-valid-time', TXMLStartvalidtimeType);
  FStartvalidtime := CreateCollection(TXMLStartvalidtimeTypeList, IXMLStartvalidtimeType, 'start-valid-time') as IXMLStartvalidtimeTypeList;
  FEndvalidtime := CreateCollection(TXMLDateTimeList, IXMLNode, 'end-valid-time') as IXMLDateTimeList;
  inherited;
end;

function TXMLTimelayoutElementType.Get_Timecoordinate: UnicodeString;
begin
  Result := AttributeNodes['time-coordinate'].Text;
end;

procedure TXMLTimelayoutElementType.Set_Timecoordinate(Value: UnicodeString);
begin
  SetAttribute('time-coordinate', Value);
end;

function TXMLTimelayoutElementType.Get_Summarization: UnicodeString;
begin
  Result := AttributeNodes['summarization'].Text;
end;

procedure TXMLTimelayoutElementType.Set_Summarization(Value: UnicodeString);
begin
  SetAttribute('summarization', Value);
end;

function TXMLTimelayoutElementType.Get_Layoutkey: UnicodeString;
begin
  Result := ChildNodes['layout-key'].Text;
end;

procedure TXMLTimelayoutElementType.Set_Layoutkey(Value: UnicodeString);
begin
  ChildNodes['layout-key'].NodeValue := Value;
end;

function TXMLTimelayoutElementType.Get_Startvalidtime: IXMLStartvalidtimeTypeList;
begin
  Result := FStartvalidtime;
end;

function TXMLTimelayoutElementType.Get_Endvalidtime: IXMLDateTimeList;
begin
  Result := FEndvalidtime;
end;

{ TXMLTimelayoutElementTypeList }

function TXMLTimelayoutElementTypeList.Add: IXMLTimelayoutElementType;
begin
  Result := AddItem(-1) as IXMLTimelayoutElementType;
end;

function TXMLTimelayoutElementTypeList.Insert(const Index: Integer): IXMLTimelayoutElementType;
begin
  Result := AddItem(Index) as IXMLTimelayoutElementType;
end;

function TXMLTimelayoutElementTypeList.Get_Item(Index: Integer): IXMLTimelayoutElementType;
begin
  Result := List[Index] as IXMLTimelayoutElementType;
end;

{ TXMLStartvalidtimeType }

function TXMLStartvalidtimeType.Get_Periodname: UnicodeString;
begin
  Result := AttributeNodes['period-name'].Text;
end;

procedure TXMLStartvalidtimeType.Set_Periodname(Value: UnicodeString);
begin
  SetAttribute('period-name', Value);
end;

{ TXMLStartvalidtimeTypeList }

function TXMLStartvalidtimeTypeList.Add: IXMLStartvalidtimeType;
begin
  Result := AddItem(-1) as IXMLStartvalidtimeType;
end;

function TXMLStartvalidtimeTypeList.Insert(const Index: Integer): IXMLStartvalidtimeType;
begin
  Result := AddItem(Index) as IXMLStartvalidtimeType;
end;

function TXMLStartvalidtimeTypeList.Get_Item(Index: Integer): IXMLStartvalidtimeType;
begin
  Result := List[Index] as IXMLStartvalidtimeType;
end;

{ TXMLParametersType }

procedure TXMLParametersType.AfterConstruction;
begin
  RegisterChildNode('categories', TXMLCategoriesType);
  RegisterChildNode('temperature', TXMLTemperature);
  RegisterChildNode('precipitation', TXMLPrecipitation);
  RegisterChildNode('probability-of-precipitation', TXMLProbabilityofprecipitation);
  RegisterChildNode('fire-weather', TXMLFireweather);
  RegisterChildNode('convective-hazard', TXMLConvectivehazard);
  RegisterChildNode('climate-anomaly', TXMLClimateanomaly);
  RegisterChildNode('wind-speed', TXMLWindspeed);
  RegisterChildNode('direction', TXMLDirection);
  RegisterChildNode('cloud-amount', TXMLCloudamount);
  RegisterChildNode('humidity', TXMLHumidity);
  RegisterChildNode('weather', TXMLWeather);
  RegisterChildNode('conditions-icon', TXMLConditionsicon);
  RegisterChildNode('hazards', TXMLHazards);
  RegisterChildNode('wordedForecast', TXMLWordedForecast);
  RegisterChildNode('pressure', TXMLPressure);
  RegisterChildNode('probabilisticCondition', TXMLProbabilisticCondition);
  RegisterChildNode('water-state', TXMLWaterstate);
  FCategories := CreateCollection(TXMLCategoriesTypeList, IXMLCategoriesType, 'categories') as IXMLCategoriesTypeList;
  FTemperature := CreateCollection(TXMLTemperatureList, IXMLTemperature, 'temperature') as IXMLTemperatureList;
  FPrecipitation := CreateCollection(TXMLPrecipitationList, IXMLPrecipitation, 'precipitation') as IXMLPrecipitationList;
  FProbabilityofprecipitation := CreateCollection(TXMLProbabilityofprecipitationList, IXMLProbabilityofprecipitation, 'probability-of-precipitation') as IXMLProbabilityofprecipitationList;
  FFireweather := CreateCollection(TXMLFireweatherList, IXMLFireweather, 'fire-weather') as IXMLFireweatherList;
  FConvectivehazard := CreateCollection(TXMLConvectivehazardList, IXMLConvectivehazard, 'convective-hazard') as IXMLConvectivehazardList;
  FClimateanomaly := CreateCollection(TXMLClimateanomalyList, IXMLClimateanomaly, 'climate-anomaly') as IXMLClimateanomalyList;
  FWindspeed := CreateCollection(TXMLWindspeedList, IXMLWindspeed, 'wind-speed') as IXMLWindspeedList;
  FDirection := CreateCollection(TXMLDirectionList, IXMLDirection, 'direction') as IXMLDirectionList;
  FCloudamount := CreateCollection(TXMLCloudamountList, IXMLCloudamount, 'cloud-amount') as IXMLCloudamountList;
  FHumidity := CreateCollection(TXMLHumidityList, IXMLHumidity, 'humidity') as IXMLHumidityList;
  FWeather := CreateCollection(TXMLWeatherList, IXMLWeather, 'weather') as IXMLWeatherList;
  FConditionsicon := CreateCollection(TXMLConditionsiconList, IXMLConditionsicon, 'conditions-icon') as IXMLConditionsiconList;
  FHazards := CreateCollection(TXMLHazardsList, IXMLHazards, 'hazards') as IXMLHazardsList;
  FPressure := CreateCollection(TXMLPressureList, IXMLPressure, 'pressure') as IXMLPressureList;
  FProbabilisticCondition := CreateCollection(TXMLProbabilisticConditionList, IXMLProbabilisticCondition, 'probabilisticCondition') as IXMLProbabilisticConditionList;
  FWaterstate := CreateCollection(TXMLWaterstateList, IXMLWaterstate, 'water-state') as IXMLWaterstateList;
  inherited;
end;

function TXMLParametersType.Get_Applicablelocation: UnicodeString;
begin
  Result := AttributeNodes['applicable-location'].Text;
end;

procedure TXMLParametersType.Set_Applicablelocation(Value: UnicodeString);
begin
  SetAttribute('applicable-location', Value);
end;

function TXMLParametersType.Get_Categories: IXMLCategoriesTypeList;
begin
  Result := FCategories;
end;

function TXMLParametersType.Get_Temperature: IXMLTemperatureList;
begin
  Result := FTemperature;
end;

function TXMLParametersType.Get_Precipitation: IXMLPrecipitationList;
begin
  Result := FPrecipitation;
end;

function TXMLParametersType.Get_Probabilityofprecipitation: IXMLProbabilityofprecipitationList;
begin
  Result := FProbabilityofprecipitation;
end;

function TXMLParametersType.Get_Fireweather: IXMLFireweatherList;
begin
  Result := FFireweather;
end;

function TXMLParametersType.Get_Convectivehazard: IXMLConvectivehazardList;
begin
  Result := FConvectivehazard;
end;

function TXMLParametersType.Get_Climateanomaly: IXMLClimateanomalyList;
begin
  Result := FClimateanomaly;
end;

function TXMLParametersType.Get_Windspeed: IXMLWindspeedList;
begin
  Result := FWindspeed;
end;

function TXMLParametersType.Get_Direction: IXMLDirectionList;
begin
  Result := FDirection;
end;

function TXMLParametersType.Get_Cloudamount: IXMLCloudamountList;
begin
  Result := FCloudamount;
end;

function TXMLParametersType.Get_Humidity: IXMLHumidityList;
begin
  Result := FHumidity;
end;

function TXMLParametersType.Get_Weather: IXMLWeatherList;
begin
  Result := FWeather;
end;

function TXMLParametersType.Get_Conditionsicon: IXMLConditionsiconList;
begin
  Result := FConditionsicon;
end;

function TXMLParametersType.Get_Hazards: IXMLHazardsList;
begin
  Result := FHazards;
end;

function TXMLParametersType.Get_WordedForecast: IXMLWordedForecast;
begin
  Result := ChildNodes['wordedForecast'] as IXMLWordedForecast;
end;

function TXMLParametersType.Get_Pressure: IXMLPressureList;
begin
  Result := FPressure;
end;

function TXMLParametersType.Get_ProbabilisticCondition: IXMLProbabilisticConditionList;
begin
  Result := FProbabilisticCondition;
end;

function TXMLParametersType.Get_Waterstate: IXMLWaterstateList;
begin
  Result := FWaterstate;
end;

{ TXMLParametersTypeList }

function TXMLParametersTypeList.Add: IXMLParametersType;
begin
  Result := AddItem(-1) as IXMLParametersType;
end;

function TXMLParametersTypeList.Insert(const Index: Integer): IXMLParametersType;
begin
  Result := AddItem(Index) as IXMLParametersType;
end;

function TXMLParametersTypeList.Get_Item(Index: Integer): IXMLParametersType;
begin
  Result := List[Index] as IXMLParametersType;
end;

{ TXMLCategoriesType }

procedure TXMLCategoriesType.AfterConstruction;
begin
  RegisterChildNode('valueList', TXMLValueListType);
  inherited;
end;

function TXMLCategoriesType.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLCategoriesType.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLCategoriesType.Get_Probabilitytype: UnicodeString;
begin
  Result := AttributeNodes['probability-type'].Text;
end;

procedure TXMLCategoriesType.Set_Probabilitytype(Value: UnicodeString);
begin
  SetAttribute('probability-type', Value);
end;

function TXMLCategoriesType.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLCategoriesType.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLCategoriesType.Get_Categorieskey: UnicodeString;
begin
  Result := ChildNodes['categories-key'].Text;
end;

procedure TXMLCategoriesType.Set_Categorieskey(Value: UnicodeString);
begin
  ChildNodes['categories-key'].NodeValue := Value;
end;

function TXMLCategoriesType.Get_ValueList: IXMLValueListType;
begin
  Result := ChildNodes['valueList'] as IXMLValueListType;
end;

{ TXMLCategoriesTypeList }

function TXMLCategoriesTypeList.Add: IXMLCategoriesType;
begin
  Result := AddItem(-1) as IXMLCategoriesType;
end;

function TXMLCategoriesTypeList.Insert(const Index: Integer): IXMLCategoriesType;
begin
  Result := AddItem(Index) as IXMLCategoriesType;
end;

function TXMLCategoriesTypeList.Get_Item(Index: Integer): IXMLCategoriesType;
begin
  Result := List[Index] as IXMLCategoriesType;
end;

{ TXMLValueListType }

function TXMLValueListType.Get_Median: UnicodeString;
begin
  Result := AttributeNodes['median'].Text;
end;

procedure TXMLValueListType.Set_Median(Value: UnicodeString);
begin
  SetAttribute('median', Value);
end;

function TXMLValueListType.Get_ConfidenceInterval50: UnicodeString;
begin
  Result := AttributeNodes['confidenceInterval50'].Text;
end;

procedure TXMLValueListType.Set_ConfidenceInterval50(Value: UnicodeString);
begin
  SetAttribute('confidenceInterval50', Value);
end;

function TXMLValueListType.Get_ConfidenceInterval80: UnicodeString;
begin
  Result := AttributeNodes['confidenceInterval80'].Text;
end;

procedure TXMLValueListType.Set_ConfidenceInterval80(Value: UnicodeString);
begin
  SetAttribute('confidenceInterval80', Value);
end;

function TXMLValueListType.Get_Skew80: UnicodeString;
begin
  Result := AttributeNodes['skew80'].Text;
end;

procedure TXMLValueListType.Set_Skew80(Value: UnicodeString);
begin
  SetAttribute('skew80', Value);
end;

{ TXMLValueListTypeList }

function TXMLValueListTypeList.Add: IXMLValueListType;
begin
  Result := AddItem(-1) as IXMLValueListType;
end;

function TXMLValueListTypeList.Insert(const Index: Integer): IXMLValueListType;
begin
  Result := AddItem(Index) as IXMLValueListType;
end;

function TXMLValueListTypeList.Get_Item(Index: Integer): IXMLValueListType;
begin
  Result := List[Index] as IXMLValueListType;
end;

{ TXMLTemperature }

procedure TXMLTemperature.AfterConstruction;
begin
  RegisterChildNode('value', TXMLTempValType);
  RegisterChildNode('valueList', TXMLValueListType);
  RegisterChildNode('valueWithUncertainty', TXMLValueWithUncertainty);
  FValue := CreateCollection(TXMLTempValTypeList, IXMLTempValType, 'value') as IXMLTempValTypeList;
  FValueList := CreateCollection(TXMLValueListTypeList, IXMLValueListType, 'valueList') as IXMLValueListTypeList;
  FValueWithUncertainty := CreateCollection(TXMLValueWithUncertaintyList, IXMLValueWithUncertainty, 'valueWithUncertainty') as IXMLValueWithUncertaintyList;
  inherited;
end;

function TXMLTemperature.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLTemperature.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLTemperature.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLTemperature.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLTemperature.Get_LikelihoodUnits: UnicodeString;
begin
  Result := AttributeNodes['likelihoodUnits'].Text;
end;

procedure TXMLTemperature.Set_LikelihoodUnits(Value: UnicodeString);
begin
  SetAttribute('likelihoodUnits', Value);
end;

function TXMLTemperature.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLTemperature.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLTemperature.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLTemperature.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLTemperature.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLTemperature.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLTemperature.Get_Applicablecategories: UnicodeString;
begin
  Result := AttributeNodes['applicable-categories'].Text;
end;

procedure TXMLTemperature.Set_Applicablecategories(Value: UnicodeString);
begin
  SetAttribute('applicable-categories', Value);
end;

function TXMLTemperature.Get_Probabilitytype: UnicodeString;
begin
  Result := AttributeNodes['probability-type'].Text;
end;

procedure TXMLTemperature.Set_Probabilitytype(Value: UnicodeString);
begin
  SetAttribute('probability-type', Value);
end;

function TXMLTemperature.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLTemperature.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLTemperature.Get_Value: IXMLTempValTypeList;
begin
  Result := FValue;
end;

function TXMLTemperature.Get_ValueList: IXMLValueListTypeList;
begin
  Result := FValueList;
end;

function TXMLTemperature.Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
begin
  Result := FValueWithUncertainty;
end;

{ TXMLTemperatureList }

function TXMLTemperatureList.Add: IXMLTemperature;
begin
  Result := AddItem(-1) as IXMLTemperature;
end;

function TXMLTemperatureList.Insert(const Index: Integer): IXMLTemperature;
begin
  Result := AddItem(Index) as IXMLTemperature;
end;

function TXMLTemperatureList.Get_Item(Index: Integer): IXMLTemperature;
begin
  Result := List[Index] as IXMLTemperature;
end;

{ TXMLTempValType }

function TXMLTempValType.Get_Upperrange: Integer;
begin
  Result := AttributeNodes['upper-range'].NodeValue;
end;

procedure TXMLTempValType.Set_Upperrange(Value: Integer);
begin
  SetAttribute('upper-range', Value);
end;

function TXMLTempValType.Get_Lowerrange: Integer;
begin
  Result := AttributeNodes['lower-range'].NodeValue;
end;

procedure TXMLTempValType.Set_Lowerrange(Value: Integer);
begin
  SetAttribute('lower-range', Value);
end;

function TXMLTempValType.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLTempValType.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

{ TXMLTempValTypeList }

function TXMLTempValTypeList.Add: IXMLTempValType;
begin
  Result := AddItem(-1) as IXMLTempValType;
end;

function TXMLTempValTypeList.Insert(const Index: Integer): IXMLTempValType;
begin
  Result := AddItem(Index) as IXMLTempValType;
end;

function TXMLTempValTypeList.Get_Item(Index: Integer): IXMLTempValType;
begin
  Result := List[Index] as IXMLTempValType;
end;

{ TXMLValueWithUncertainty }

procedure TXMLValueWithUncertainty.AfterConstruction;
begin
  RegisterChildNode('value', TXMLTempValType);
  RegisterChildNode('uncertainty', TXMLUncertaintyType);
  inherited;
end;

function TXMLValueWithUncertainty.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLValueWithUncertainty.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLValueWithUncertainty.Get_Value: IXMLTempValType;
begin
  Result := ChildNodes['value'] as IXMLTempValType;
end;

function TXMLValueWithUncertainty.Get_Uncertainty: IXMLUncertaintyType;
begin
  Result := ChildNodes['uncertainty'] as IXMLUncertaintyType;
end;

function TXMLValueWithUncertainty.Get_NumberWithEquality: UnicodeString;
begin
  Result := ChildNodes['numberWithEquality'].Text;
end;

procedure TXMLValueWithUncertainty.Set_NumberWithEquality(Value: UnicodeString);
begin
  ChildNodes['numberWithEquality'].NodeValue := Value;
end;

{ TXMLValueWithUncertaintyList }

function TXMLValueWithUncertaintyList.Add: IXMLValueWithUncertainty;
begin
  Result := AddItem(-1) as IXMLValueWithUncertainty;
end;

function TXMLValueWithUncertaintyList.Insert(const Index: Integer): IXMLValueWithUncertainty;
begin
  Result := AddItem(Index) as IXMLValueWithUncertainty;
end;

function TXMLValueWithUncertaintyList.Get_Item(Index: Integer): IXMLValueWithUncertainty;
begin
  Result := List[Index] as IXMLValueWithUncertainty;
end;

{ TXMLUncertaintyType }

procedure TXMLUncertaintyType.AfterConstruction;
begin
  RegisterChildNode('error', TXMLError);
  inherited;
end;

function TXMLUncertaintyType.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLUncertaintyType.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLUncertaintyType.Get_Error: IXMLError;
begin
  Result := ChildNodes['error'] as IXMLError;
end;

{ TXMLError }

function TXMLError.Get_Qualifier: UnicodeString;
begin
  Result := AttributeNodes['qualifier'].Text;
end;

procedure TXMLError.Set_Qualifier(Value: UnicodeString);
begin
  SetAttribute('qualifier', Value);
end;

{ TXMLPrecipitation }

procedure TXMLPrecipitation.AfterConstruction;
begin
  RegisterChildNode('value', TXMLDecimalValType);
  RegisterChildNode('valueList', TXMLValueListType);
  RegisterChildNode('valueWithUncertainty', TXMLValueWithUncertainty);
  FValue := CreateCollection(TXMLDecimalValTypeList, IXMLDecimalValType, 'value') as IXMLDecimalValTypeList;
  FValueList := CreateCollection(TXMLValueListTypeList, IXMLValueListType, 'valueList') as IXMLValueListTypeList;
  FValueWithUncertainty := CreateCollection(TXMLValueWithUncertaintyList, IXMLValueWithUncertainty, 'valueWithUncertainty') as IXMLValueWithUncertaintyList;
  inherited;
end;

function TXMLPrecipitation.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLPrecipitation.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLPrecipitation.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLPrecipitation.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLPrecipitation.Get_LikelihoodUnits: UnicodeString;
begin
  Result := AttributeNodes['likelihoodUnits'].Text;
end;

procedure TXMLPrecipitation.Set_LikelihoodUnits(Value: UnicodeString);
begin
  SetAttribute('likelihoodUnits', Value);
end;

function TXMLPrecipitation.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLPrecipitation.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLPrecipitation.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLPrecipitation.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLPrecipitation.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLPrecipitation.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLPrecipitation.Get_Probabilitytype: UnicodeString;
begin
  Result := AttributeNodes['probability-type'].Text;
end;

procedure TXMLPrecipitation.Set_Probabilitytype(Value: UnicodeString);
begin
  SetAttribute('probability-type', Value);
end;

function TXMLPrecipitation.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLPrecipitation.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLPrecipitation.Get_Value: IXMLDecimalValTypeList;
begin
  Result := FValue;
end;

function TXMLPrecipitation.Get_ValueList: IXMLValueListTypeList;
begin
  Result := FValueList;
end;

function TXMLPrecipitation.Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
begin
  Result := FValueWithUncertainty;
end;

{ TXMLPrecipitationList }

function TXMLPrecipitationList.Add: IXMLPrecipitation;
begin
  Result := AddItem(-1) as IXMLPrecipitation;
end;

function TXMLPrecipitationList.Insert(const Index: Integer): IXMLPrecipitation;
begin
  Result := AddItem(Index) as IXMLPrecipitation;
end;

function TXMLPrecipitationList.Get_Item(Index: Integer): IXMLPrecipitation;
begin
  Result := List[Index] as IXMLPrecipitation;
end;

{ TXMLDecimalValType }

function TXMLDecimalValType.Get_Upperrange: LongWord;
begin
  Result := AttributeNodes['upper-range'].NodeValue;
end;

procedure TXMLDecimalValType.Set_Upperrange(Value: LongWord);
begin
  SetAttribute('upper-range', Value);
end;

function TXMLDecimalValType.Get_Lowerrange: LongWord;
begin
  Result := AttributeNodes['lower-range'].NodeValue;
end;

procedure TXMLDecimalValType.Set_Lowerrange(Value: LongWord);
begin
  SetAttribute('lower-range', Value);
end;

function TXMLDecimalValType.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLDecimalValType.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

{ TXMLDecimalValTypeList }

function TXMLDecimalValTypeList.Add: IXMLDecimalValType;
begin
  Result := AddItem(-1) as IXMLDecimalValType;
end;

function TXMLDecimalValTypeList.Insert(const Index: Integer): IXMLDecimalValType;
begin
  Result := AddItem(Index) as IXMLDecimalValType;
end;

function TXMLDecimalValTypeList.Get_Item(Index: Integer): IXMLDecimalValType;
begin
  Result := List[Index] as IXMLDecimalValType;
end;

{ TXMLProbabilityofprecipitation }

procedure TXMLProbabilityofprecipitation.AfterConstruction;
begin
  RegisterChildNode('value', TXMLPercentageValType);
  RegisterChildNode('valueList', TXMLValueListType);
  FValue := CreateCollection(TXMLPercentageValTypeList, IXMLPercentageValType, 'value') as IXMLPercentageValTypeList;
  FValueList := CreateCollection(TXMLValueListTypeList, IXMLValueListType, 'valueList') as IXMLValueListTypeList;
  inherited;
end;

function TXMLProbabilityofprecipitation.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLProbabilityofprecipitation.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLProbabilityofprecipitation.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLProbabilityofprecipitation.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLProbabilityofprecipitation.Get_LikelihoodUnits: UnicodeString;
begin
  Result := AttributeNodes['likelihoodUnits'].Text;
end;

procedure TXMLProbabilityofprecipitation.Set_LikelihoodUnits(Value: UnicodeString);
begin
  SetAttribute('likelihoodUnits', Value);
end;

function TXMLProbabilityofprecipitation.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLProbabilityofprecipitation.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLProbabilityofprecipitation.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLProbabilityofprecipitation.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLProbabilityofprecipitation.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLProbabilityofprecipitation.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLProbabilityofprecipitation.Get_Applicablecategories: UnicodeString;
begin
  Result := AttributeNodes['applicable-categories'].Text;
end;

procedure TXMLProbabilityofprecipitation.Set_Applicablecategories(Value: UnicodeString);
begin
  SetAttribute('applicable-categories', Value);
end;

function TXMLProbabilityofprecipitation.Get_Probabilitytype: UnicodeString;
begin
  Result := AttributeNodes['probability-type'].Text;
end;

procedure TXMLProbabilityofprecipitation.Set_Probabilitytype(Value: UnicodeString);
begin
  SetAttribute('probability-type', Value);
end;

function TXMLProbabilityofprecipitation.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLProbabilityofprecipitation.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLProbabilityofprecipitation.Get_Value: IXMLPercentageValTypeList;
begin
  Result := FValue;
end;

function TXMLProbabilityofprecipitation.Get_ValueList: IXMLValueListTypeList;
begin
  Result := FValueList;
end;

{ TXMLProbabilityofprecipitationList }

function TXMLProbabilityofprecipitationList.Add: IXMLProbabilityofprecipitation;
begin
  Result := AddItem(-1) as IXMLProbabilityofprecipitation;
end;

function TXMLProbabilityofprecipitationList.Insert(const Index: Integer): IXMLProbabilityofprecipitation;
begin
  Result := AddItem(Index) as IXMLProbabilityofprecipitation;
end;

function TXMLProbabilityofprecipitationList.Get_Item(Index: Integer): IXMLProbabilityofprecipitation;
begin
  Result := List[Index] as IXMLProbabilityofprecipitation;
end;

{ TXMLPercentageValType }

function TXMLPercentageValType.Get_Upperrange: LongWord;
begin
  Result := AttributeNodes['upper-range'].NodeValue;
end;

procedure TXMLPercentageValType.Set_Upperrange(Value: LongWord);
begin
  SetAttribute('upper-range', Value);
end;

function TXMLPercentageValType.Get_Lowerrange: LongWord;
begin
  Result := AttributeNodes['lower-range'].NodeValue;
end;

procedure TXMLPercentageValType.Set_Lowerrange(Value: LongWord);
begin
  SetAttribute('lower-range', Value);
end;

function TXMLPercentageValType.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLPercentageValType.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

{ TXMLPercentageValTypeList }

function TXMLPercentageValTypeList.Add: IXMLPercentageValType;
begin
  Result := AddItem(-1) as IXMLPercentageValType;
end;

function TXMLPercentageValTypeList.Insert(const Index: Integer): IXMLPercentageValType;
begin
  Result := AddItem(Index) as IXMLPercentageValType;
end;

function TXMLPercentageValTypeList.Get_Item(Index: Integer): IXMLPercentageValType;
begin
  Result := List[Index] as IXMLPercentageValType;
end;

{ TXMLFireweather }

procedure TXMLFireweather.AfterConstruction;
begin
  FValue := CreateCollection(TXMLValueList, IXMLNode, 'value') as IXMLValueList;
  inherited;
end;

function TXMLFireweather.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLFireweather.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLFireweather.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLFireweather.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLFireweather.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLFireweather.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLFireweather.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLFireweather.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLFireweather.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLFireweather.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLFireweather.Get_Value: IXMLValueList;
begin
  Result := FValue;
end;

{ TXMLFireweatherList }

function TXMLFireweatherList.Add: IXMLFireweather;
begin
  Result := AddItem(-1) as IXMLFireweather;
end;

function TXMLFireweatherList.Insert(const Index: Integer): IXMLFireweather;
begin
  Result := AddItem(Index) as IXMLFireweather;
end;

function TXMLFireweatherList.Get_Item(Index: Integer): IXMLFireweather;
begin
  Result := List[Index] as IXMLFireweather;
end;

{ TXMLConvectivehazard }

procedure TXMLConvectivehazard.AfterConstruction;
begin
  RegisterChildNode('outlook', TXMLOutlook);
  RegisterChildNode('severe-component', TXMLSeverecomponent);
  FSeverecomponent := CreateCollection(TXMLSeverecomponentList, IXMLSeverecomponent, 'severe-component') as IXMLSeverecomponentList;
  inherited;
end;

function TXMLConvectivehazard.Get_Outlook: IXMLOutlook;
begin
  Result := ChildNodes['outlook'] as IXMLOutlook;
end;

function TXMLConvectivehazard.Get_Severecomponent: IXMLSeverecomponentList;
begin
  Result := FSeverecomponent;
end;

{ TXMLConvectivehazardList }

function TXMLConvectivehazardList.Add: IXMLConvectivehazard;
begin
  Result := AddItem(-1) as IXMLConvectivehazard;
end;

function TXMLConvectivehazardList.Insert(const Index: Integer): IXMLConvectivehazard;
begin
  Result := AddItem(Index) as IXMLConvectivehazard;
end;

function TXMLConvectivehazardList.Get_Item(Index: Integer): IXMLConvectivehazard;
begin
  Result := List[Index] as IXMLConvectivehazard;
end;

{ TXMLOutlook }

procedure TXMLOutlook.AfterConstruction;
begin
  FValue := CreateCollection(TXMLValueList, IXMLNode, 'value') as IXMLValueList;
  inherited;
end;

function TXMLOutlook.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLOutlook.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLOutlook.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLOutlook.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLOutlook.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLOutlook.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLOutlook.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLOutlook.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLOutlook.Get_Value: IXMLValueList;
begin
  Result := FValue;
end;

{ TXMLSeverecomponent }

procedure TXMLSeverecomponent.AfterConstruction;
begin
  RegisterChildNode('value', TXMLValue);
  FValue := CreateCollection(TXMLValueList, IXMLValue, 'value') as IXMLValueList;
  inherited;
end;

function TXMLSeverecomponent.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLSeverecomponent.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLSeverecomponent.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLSeverecomponent.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLSeverecomponent.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLSeverecomponent.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLSeverecomponent.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLSeverecomponent.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLSeverecomponent.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLSeverecomponent.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLSeverecomponent.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLSeverecomponent.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLSeverecomponent.Get_Value: IXMLValueList;
begin
  Result := FValue;
end;

{ TXMLSeverecomponentList }

function TXMLSeverecomponentList.Add: IXMLSeverecomponent;
begin
  Result := AddItem(-1) as IXMLSeverecomponent;
end;

function TXMLSeverecomponentList.Insert(const Index: Integer): IXMLSeverecomponent;
begin
  Result := AddItem(Index) as IXMLSeverecomponent;
end;

function TXMLSeverecomponentList.Get_Item(Index: Integer): IXMLSeverecomponent;
begin
  Result := List[Index] as IXMLSeverecomponent;
end;

{ TXMLValue }

function TXMLValue.Get_Upperrange: LongWord;
begin
  Result := AttributeNodes['upper-range'].NodeValue;
end;

procedure TXMLValue.Set_Upperrange(Value: LongWord);
begin
  SetAttribute('upper-range', Value);
end;

function TXMLValue.Get_Lowerrange: LongWord;
begin
  Result := AttributeNodes['lower-range'].NodeValue;
end;

procedure TXMLValue.Set_Lowerrange(Value: LongWord);
begin
  SetAttribute('lower-range', Value);
end;

{ TXMLValueList }

function TXMLValueList.Add: IXMLValue;
begin
  Result := AddItem(-1) as IXMLValue;
end;

function TXMLValueList.Insert(const Index: Integer): IXMLValue;
begin
  Result := AddItem(Index) as IXMLValue;
end;

function TXMLValueList.Get_Item(Index: Integer): IXMLValue;
begin
  Result := List[Index] as IXMLValue;
end;

{ TXMLClimateanomaly }

procedure TXMLClimateanomaly.AfterConstruction;
begin
  RegisterChildNode('weekly', TXMLAnomalyType);
  RegisterChildNode('monthly', TXMLAnomalyType);
  RegisterChildNode('seasonal', TXMLAnomalyType);
  FWeekly := CreateCollection(TXMLAnomalyTypeList, IXMLAnomalyType, 'weekly') as IXMLAnomalyTypeList;
  FMonthly := CreateCollection(TXMLAnomalyTypeList, IXMLAnomalyType, 'monthly') as IXMLAnomalyTypeList;
  FSeasonal := CreateCollection(TXMLAnomalyTypeList, IXMLAnomalyType, 'seasonal') as IXMLAnomalyTypeList;
  inherited;
end;

function TXMLClimateanomaly.Get_Weekly: IXMLAnomalyTypeList;
begin
  Result := FWeekly;
end;

function TXMLClimateanomaly.Get_Monthly: IXMLAnomalyTypeList;
begin
  Result := FMonthly;
end;

function TXMLClimateanomaly.Get_Seasonal: IXMLAnomalyTypeList;
begin
  Result := FSeasonal;
end;

{ TXMLClimateanomalyList }

function TXMLClimateanomalyList.Add: IXMLClimateanomaly;
begin
  Result := AddItem(-1) as IXMLClimateanomaly;
end;

function TXMLClimateanomalyList.Insert(const Index: Integer): IXMLClimateanomaly;
begin
  Result := AddItem(Index) as IXMLClimateanomaly;
end;

function TXMLClimateanomalyList.Get_Item(Index: Integer): IXMLClimateanomaly;
begin
  Result := List[Index] as IXMLClimateanomaly;
end;

{ TXMLAnomalyType }

procedure TXMLAnomalyType.AfterConstruction;
begin
  RegisterChildNode('value', TXMLValue);
  FValue := CreateCollection(TXMLValueList, IXMLValue, 'value') as IXMLValueList;
  inherited;
end;

function TXMLAnomalyType.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLAnomalyType.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLAnomalyType.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLAnomalyType.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLAnomalyType.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLAnomalyType.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLAnomalyType.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLAnomalyType.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLAnomalyType.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLAnomalyType.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLAnomalyType.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLAnomalyType.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLAnomalyType.Get_Value: IXMLValueList;
begin
  Result := FValue;
end;

{ TXMLAnomalyTypeList }

function TXMLAnomalyTypeList.Add: IXMLAnomalyType;
begin
  Result := AddItem(-1) as IXMLAnomalyType;
end;

function TXMLAnomalyTypeList.Insert(const Index: Integer): IXMLAnomalyType;
begin
  Result := AddItem(Index) as IXMLAnomalyType;
end;

function TXMLAnomalyTypeList.Get_Item(Index: Integer): IXMLAnomalyType;
begin
  Result := List[Index] as IXMLAnomalyType;
end;

{ TXMLWindspeed }

procedure TXMLWindspeed.AfterConstruction;
begin
  RegisterChildNode('value', TXMLWspdValType);
  RegisterChildNode('valueWithUncertainty', TXMLValueWithUncertainty);
  FValue := CreateCollection(TXMLWspdValTypeList, IXMLWspdValType, 'value') as IXMLWspdValTypeList;
  FValueWithUncertainty := CreateCollection(TXMLValueWithUncertaintyList, IXMLValueWithUncertainty, 'valueWithUncertainty') as IXMLValueWithUncertaintyList;
  inherited;
end;

function TXMLWindspeed.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLWindspeed.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLWindspeed.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLWindspeed.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLWindspeed.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLWindspeed.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLWindspeed.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLWindspeed.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLWindspeed.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLWindspeed.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLWindspeed.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLWindspeed.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLWindspeed.Get_Value: IXMLWspdValTypeList;
begin
  Result := FValue;
end;

function TXMLWindspeed.Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
begin
  Result := FValueWithUncertainty;
end;

{ TXMLWindspeedList }

function TXMLWindspeedList.Add: IXMLWindspeed;
begin
  Result := AddItem(-1) as IXMLWindspeed;
end;

function TXMLWindspeedList.Insert(const Index: Integer): IXMLWindspeed;
begin
  Result := AddItem(Index) as IXMLWindspeed;
end;

function TXMLWindspeedList.Get_Item(Index: Integer): IXMLWindspeed;
begin
  Result := List[Index] as IXMLWindspeed;
end;

{ TXMLWspdValType }

function TXMLWspdValType.Get_Upperrange: LongWord;
begin
  Result := AttributeNodes['upper-range'].NodeValue;
end;

procedure TXMLWspdValType.Set_Upperrange(Value: LongWord);
begin
  SetAttribute('upper-range', Value);
end;

function TXMLWspdValType.Get_Lowerrange: LongWord;
begin
  Result := AttributeNodes['lower-range'].NodeValue;
end;

procedure TXMLWspdValType.Set_Lowerrange(Value: LongWord);
begin
  SetAttribute('lower-range', Value);
end;

function TXMLWspdValType.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLWspdValType.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

{ TXMLWspdValTypeList }

function TXMLWspdValTypeList.Add: IXMLWspdValType;
begin
  Result := AddItem(-1) as IXMLWspdValType;
end;

function TXMLWspdValTypeList.Insert(const Index: Integer): IXMLWspdValType;
begin
  Result := AddItem(Index) as IXMLWspdValType;
end;

function TXMLWspdValTypeList.Get_Item(Index: Integer): IXMLWspdValType;
begin
  Result := List[Index] as IXMLWspdValType;
end;

{ TXMLDirection }

procedure TXMLDirection.AfterConstruction;
begin
  RegisterChildNode('value', TXMLWdirValType);
  RegisterChildNode('valueWithUncertainty', TXMLValueWithUncertainty);
  FValue := CreateCollection(TXMLWdirValTypeList, IXMLWdirValType, 'value') as IXMLWdirValTypeList;
  FValueWithUncertainty := CreateCollection(TXMLValueWithUncertaintyList, IXMLValueWithUncertainty, 'valueWithUncertainty') as IXMLValueWithUncertaintyList;
  inherited;
end;

function TXMLDirection.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLDirection.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLDirection.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLDirection.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLDirection.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLDirection.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLDirection.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLDirection.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLDirection.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLDirection.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLDirection.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLDirection.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLDirection.Get_Value: IXMLWdirValTypeList;
begin
  Result := FValue;
end;

function TXMLDirection.Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
begin
  Result := FValueWithUncertainty;
end;

{ TXMLDirectionList }

function TXMLDirectionList.Add: IXMLDirection;
begin
  Result := AddItem(-1) as IXMLDirection;
end;

function TXMLDirectionList.Insert(const Index: Integer): IXMLDirection;
begin
  Result := AddItem(Index) as IXMLDirection;
end;

function TXMLDirectionList.Get_Item(Index: Integer): IXMLDirection;
begin
  Result := List[Index] as IXMLDirection;
end;

{ TXMLWdirValType }

function TXMLWdirValType.Get_Upperrange: LongWord;
begin
  Result := AttributeNodes['upper-range'].NodeValue;
end;

procedure TXMLWdirValType.Set_Upperrange(Value: LongWord);
begin
  SetAttribute('upper-range', Value);
end;

function TXMLWdirValType.Get_Lowerrange: LongWord;
begin
  Result := AttributeNodes['lower-range'].NodeValue;
end;

procedure TXMLWdirValType.Set_Lowerrange(Value: LongWord);
begin
  SetAttribute('lower-range', Value);
end;

function TXMLWdirValType.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLWdirValType.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

{ TXMLWdirValTypeList }

function TXMLWdirValTypeList.Add: IXMLWdirValType;
begin
  Result := AddItem(-1) as IXMLWdirValType;
end;

function TXMLWdirValTypeList.Insert(const Index: Integer): IXMLWdirValType;
begin
  Result := AddItem(Index) as IXMLWdirValType;
end;

function TXMLWdirValTypeList.Get_Item(Index: Integer): IXMLWdirValType;
begin
  Result := List[Index] as IXMLWdirValType;
end;

{ TXMLCloudamount }

procedure TXMLCloudamount.AfterConstruction;
begin
  RegisterChildNode('value', TXMLPercentageValType);
  RegisterChildNode('valueWithUncertainty', TXMLValueWithUncertainty);
  FValue := CreateCollection(TXMLPercentageValTypeList, IXMLPercentageValType, 'value') as IXMLPercentageValTypeList;
  FValueWithUncertainty := CreateCollection(TXMLValueWithUncertaintyList, IXMLValueWithUncertainty, 'valueWithUncertainty') as IXMLValueWithUncertaintyList;
  inherited;
end;

function TXMLCloudamount.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLCloudamount.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLCloudamount.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLCloudamount.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLCloudamount.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLCloudamount.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLCloudamount.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLCloudamount.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLCloudamount.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLCloudamount.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLCloudamount.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLCloudamount.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLCloudamount.Get_Value: IXMLPercentageValTypeList;
begin
  Result := FValue;
end;

function TXMLCloudamount.Get_ValueWithUncertainty: IXMLValueWithUncertaintyList;
begin
  Result := FValueWithUncertainty;
end;

{ TXMLCloudamountList }

function TXMLCloudamountList.Add: IXMLCloudamount;
begin
  Result := AddItem(-1) as IXMLCloudamount;
end;

function TXMLCloudamountList.Insert(const Index: Integer): IXMLCloudamount;
begin
  Result := AddItem(Index) as IXMLCloudamount;
end;

function TXMLCloudamountList.Get_Item(Index: Integer): IXMLCloudamount;
begin
  Result := List[Index] as IXMLCloudamount;
end;

{ TXMLHumidity }

procedure TXMLHumidity.AfterConstruction;
begin
  RegisterChildNode('value', TXMLValue);
  FValue := CreateCollection(TXMLValueList, IXMLValue, 'value') as IXMLValueList;
  inherited;
end;

function TXMLHumidity.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLHumidity.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLHumidity.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLHumidity.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLHumidity.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLHumidity.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLHumidity.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLHumidity.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLHumidity.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLHumidity.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLHumidity.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLHumidity.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLHumidity.Get_Value: IXMLValueList;
begin
  Result := FValue;
end;

{ TXMLHumidityList }

function TXMLHumidityList.Add: IXMLHumidity;
begin
  Result := AddItem(-1) as IXMLHumidity;
end;

function TXMLHumidityList.Insert(const Index: Integer): IXMLHumidity;
begin
  Result := AddItem(Index) as IXMLHumidity;
end;

function TXMLHumidityList.Get_Item(Index: Integer): IXMLHumidity;
begin
  Result := List[Index] as IXMLHumidity;
end;

{ TXMLWeather }

procedure TXMLWeather.AfterConstruction;
begin
  RegisterChildNode('weather-conditions', TXMLWeatherconditions);
  FName := CreateCollection(TXMLString_List, IXMLNode, 'name') as IXMLString_List;
  FWeatherconditions := CreateCollection(TXMLWeatherconditionsList, IXMLWeatherconditions, 'weather-conditions') as IXMLWeatherconditionsList;
  inherited;
end;

function TXMLWeather.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLWeather.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLWeather.Get_Name: IXMLString_List;
begin
  Result := FName;
end;

function TXMLWeather.Get_Weatherconditions: IXMLWeatherconditionsList;
begin
  Result := FWeatherconditions;
end;

{ TXMLWeatherList }

function TXMLWeatherList.Add: IXMLWeather;
begin
  Result := AddItem(-1) as IXMLWeather;
end;

function TXMLWeatherList.Insert(const Index: Integer): IXMLWeather;
begin
  Result := AddItem(Index) as IXMLWeather;
end;

function TXMLWeatherList.Get_Item(Index: Integer): IXMLWeather;
begin
  Result := List[Index] as IXMLWeather;
end;

{ TXMLWeatherconditions }

procedure TXMLWeatherconditions.AfterConstruction;
begin
  RegisterChildNode('value', TXMLValue);
  ItemTag := 'value';
  ItemInterface := IXMLValue;
  inherited;
end;

function TXMLWeatherconditions.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLWeatherconditions.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLWeatherconditions.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLWeatherconditions.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLWeatherconditions.Get_Weathersummary: UnicodeString;
begin
  Result := AttributeNodes['weather-summary'].Text;
end;

procedure TXMLWeatherconditions.Set_Weathersummary(Value: UnicodeString);
begin
  SetAttribute('weather-summary', Value);
end;

function TXMLWeatherconditions.Get_Value(Index: Integer): IXMLValue;
begin
  Result := List[Index] as IXMLValue;
end;

function TXMLWeatherconditions.Add: IXMLValue;
begin
  Result := AddItem(-1) as IXMLValue;
end;

function TXMLWeatherconditions.Insert(const Index: Integer): IXMLValue;
begin
  Result := AddItem(Index) as IXMLValue;
end;

{ TXMLWeatherconditionsList }

function TXMLWeatherconditionsList.Add: IXMLWeatherconditions;
begin
  Result := AddItem(-1) as IXMLWeatherconditions;
end;

function TXMLWeatherconditionsList.Insert(const Index: Integer): IXMLWeatherconditions;
begin
  Result := AddItem(Index) as IXMLWeatherconditions;
end;

function TXMLWeatherconditionsList.Get_Item(Index: Integer): IXMLWeatherconditions;
begin
  Result := List[Index] as IXMLWeatherconditions;
end;

{ TXMLConditionsicon }

procedure TXMLConditionsicon.AfterConstruction;
begin
  FIconlink := CreateCollection(TXMLAnyURIList, IXMLNode, 'icon-link') as IXMLAnyURIList;
  inherited;
end;

function TXMLConditionsicon.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLConditionsicon.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLConditionsicon.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLConditionsicon.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLConditionsicon.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLConditionsicon.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLConditionsicon.Get_Iconlink: IXMLAnyURIList;
begin
  Result := FIconlink;
end;

{ TXMLConditionsiconList }

function TXMLConditionsiconList.Add: IXMLConditionsicon;
begin
  Result := AddItem(-1) as IXMLConditionsicon;
end;

function TXMLConditionsiconList.Insert(const Index: Integer): IXMLConditionsicon;
begin
  Result := AddItem(Index) as IXMLConditionsicon;
end;

function TXMLConditionsiconList.Get_Item(Index: Integer): IXMLConditionsicon;
begin
  Result := List[Index] as IXMLConditionsicon;
end;

{ TXMLHazards }

procedure TXMLHazards.AfterConstruction;
begin
  RegisterChildNode('hazard-conditions', TXMLHazardconditions);
  FName := CreateCollection(TXMLString_List, IXMLNode, 'name') as IXMLString_List;
  FHazardconditions := CreateCollection(TXMLHazardconditionsList, IXMLHazardconditions, 'hazard-conditions') as IXMLHazardconditionsList;
  inherited;
end;

function TXMLHazards.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLHazards.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLHazards.Get_Name: IXMLString_List;
begin
  Result := FName;
end;

function TXMLHazards.Get_Hazardconditions: IXMLHazardconditionsList;
begin
  Result := FHazardconditions;
end;

{ TXMLHazardsList }

function TXMLHazardsList.Add: IXMLHazards;
begin
  Result := AddItem(-1) as IXMLHazards;
end;

function TXMLHazardsList.Insert(const Index: Integer): IXMLHazards;
begin
  Result := AddItem(Index) as IXMLHazards;
end;

function TXMLHazardsList.Get_Item(Index: Integer): IXMLHazards;
begin
  Result := List[Index] as IXMLHazards;
end;

{ TXMLHazardconditions }

procedure TXMLHazardconditions.AfterConstruction;
begin
  RegisterChildNode('hazard', TXMLHazard);
  ItemTag := 'hazard';
  ItemInterface := IXMLHazard;
  inherited;
end;

function TXMLHazardconditions.Get_Hazard(Index: Integer): IXMLHazard;
begin
  Result := List[Index] as IXMLHazard;
end;

function TXMLHazardconditions.Add: IXMLHazard;
begin
  Result := AddItem(-1) as IXMLHazard;
end;

function TXMLHazardconditions.Insert(const Index: Integer): IXMLHazard;
begin
  Result := AddItem(Index) as IXMLHazard;
end;

{ TXMLHazardconditionsList }

function TXMLHazardconditionsList.Add: IXMLHazardconditions;
begin
  Result := AddItem(-1) as IXMLHazardconditions;
end;

function TXMLHazardconditionsList.Insert(const Index: Integer): IXMLHazardconditions;
begin
  Result := AddItem(Index) as IXMLHazardconditions;
end;

function TXMLHazardconditionsList.Get_Item(Index: Integer): IXMLHazardconditions;
begin
  Result := List[Index] as IXMLHazardconditions;
end;

{ TXMLHazard }

function TXMLHazard.Get_HazardCode: UnicodeString;
begin
  Result := AttributeNodes['hazardCode'].Text;
end;

procedure TXMLHazard.Set_HazardCode(Value: UnicodeString);
begin
  SetAttribute('hazardCode', Value);
end;

function TXMLHazard.Get_Phenomena: UnicodeString;
begin
  Result := AttributeNodes['phenomena'].Text;
end;

procedure TXMLHazard.Set_Phenomena(Value: UnicodeString);
begin
  SetAttribute('phenomena', Value);
end;

function TXMLHazard.Get_Significance: UnicodeString;
begin
  Result := AttributeNodes['significance'].Text;
end;

procedure TXMLHazard.Set_Significance(Value: UnicodeString);
begin
  SetAttribute('significance', Value);
end;

function TXMLHazard.Get_HazardType: UnicodeString;
begin
  Result := AttributeNodes['hazardType'].Text;
end;

procedure TXMLHazard.Set_HazardType(Value: UnicodeString);
begin
  SetAttribute('hazardType', Value);
end;

function TXMLHazard.Get_EventTrackingNumber: Integer;
begin
  Result := AttributeNodes['eventTrackingNumber'].NodeValue;
end;

procedure TXMLHazard.Set_EventTrackingNumber(Value: Integer);
begin
  SetAttribute('eventTrackingNumber', Value);
end;

function TXMLHazard.Get_Headline: UnicodeString;
begin
  Result := AttributeNodes['headline'].Text;
end;

procedure TXMLHazard.Set_Headline(Value: UnicodeString);
begin
  SetAttribute('headline', Value);
end;

function TXMLHazard.Get_HazardTextURL: UnicodeString;
begin
  Result := ChildNodes['hazardTextURL'].Text;
end;

procedure TXMLHazard.Set_HazardTextURL(Value: UnicodeString);
begin
  ChildNodes['hazardTextURL'].NodeValue := Value;
end;

function TXMLHazard.Get_HazardIcon: UnicodeString;
begin
  Result := ChildNodes['hazardIcon'].Text;
end;

procedure TXMLHazard.Set_HazardIcon(Value: UnicodeString);
begin
  ChildNodes['hazardIcon'].NodeValue := Value;
end;

{ TXMLWordedForecast }

procedure TXMLWordedForecast.AfterConstruction;
begin
  FText := CreateCollection(TXMLString_List, IXMLNode, 'text') as IXMLString_List;
  inherited;
end;

function TXMLWordedForecast.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLWordedForecast.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLWordedForecast.Get_DataSource: UnicodeString;
begin
  Result := AttributeNodes['dataSource'].Text;
end;

procedure TXMLWordedForecast.Set_DataSource(Value: UnicodeString);
begin
  SetAttribute('dataSource', Value);
end;

function TXMLWordedForecast.Get_WordGenerator: UnicodeString;
begin
  Result := AttributeNodes['wordGenerator'].Text;
end;

procedure TXMLWordedForecast.Set_WordGenerator(Value: UnicodeString);
begin
  SetAttribute('wordGenerator', Value);
end;

function TXMLWordedForecast.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLWordedForecast.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLWordedForecast.Get_Text: IXMLString_List;
begin
  Result := FText;
end;

{ TXMLPressure }

procedure TXMLPressure.AfterConstruction;
begin
  RegisterChildNode('value', TXMLDecimalValType);
  FValue := CreateCollection(TXMLDecimalValTypeList, IXMLDecimalValType, 'value') as IXMLDecimalValTypeList;
  inherited;
end;

function TXMLPressure.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLPressure.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLPressure.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLPressure.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLPressure.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLPressure.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLPressure.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLPressure.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLPressure.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLPressure.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLPressure.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLPressure.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLPressure.Get_Value: IXMLDecimalValTypeList;
begin
  Result := FValue;
end;

{ TXMLPressureList }

function TXMLPressureList.Add: IXMLPressure;
begin
  Result := AddItem(-1) as IXMLPressure;
end;

function TXMLPressureList.Insert(const Index: Integer): IXMLPressure;
begin
  Result := AddItem(Index) as IXMLPressure;
end;

function TXMLPressureList.Get_Item(Index: Integer): IXMLPressure;
begin
  Result := List[Index] as IXMLPressure;
end;

{ TXMLProbabilisticCondition }

procedure TXMLProbabilisticCondition.AfterConstruction;
begin
  RegisterChildNode('value', TXMLPercentageValType);
  RegisterChildNode('valueForRange', TXMLValueForRangeType);
  FValue := CreateCollection(TXMLPercentageValTypeList, IXMLPercentageValType, 'value') as IXMLPercentageValTypeList;
  FValueForRange := CreateCollection(TXMLValueForRangeTypeList, IXMLValueForRangeType, 'valueForRange') as IXMLValueForRangeTypeList;
  inherited;
end;

function TXMLProbabilisticCondition.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLProbabilisticCondition.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLProbabilisticCondition.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLProbabilisticCondition.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLProbabilisticCondition.Get_LikelihoodUnits: UnicodeString;
begin
  Result := AttributeNodes['likelihoodUnits'].Text;
end;

procedure TXMLProbabilisticCondition.Set_LikelihoodUnits(Value: UnicodeString);
begin
  SetAttribute('likelihoodUnits', Value);
end;

function TXMLProbabilisticCondition.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLProbabilisticCondition.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLProbabilisticCondition.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLProbabilisticCondition.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLProbabilisticCondition.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLProbabilisticCondition.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLProbabilisticCondition.Get_Applicablecategories: UnicodeString;
begin
  Result := AttributeNodes['applicable-categories'].Text;
end;

procedure TXMLProbabilisticCondition.Set_Applicablecategories(Value: UnicodeString);
begin
  SetAttribute('applicable-categories', Value);
end;

function TXMLProbabilisticCondition.Get_Probabilitytype: UnicodeString;
begin
  Result := AttributeNodes['probability-type'].Text;
end;

procedure TXMLProbabilisticCondition.Set_Probabilitytype(Value: UnicodeString);
begin
  SetAttribute('probability-type', Value);
end;

function TXMLProbabilisticCondition.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLProbabilisticCondition.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLProbabilisticCondition.Get_Value: IXMLPercentageValTypeList;
begin
  Result := FValue;
end;

function TXMLProbabilisticCondition.Get_ValueForRange: IXMLValueForRangeTypeList;
begin
  Result := FValueForRange;
end;

{ TXMLProbabilisticConditionList }

function TXMLProbabilisticConditionList.Add: IXMLProbabilisticCondition;
begin
  Result := AddItem(-1) as IXMLProbabilisticCondition;
end;

function TXMLProbabilisticConditionList.Insert(const Index: Integer): IXMLProbabilisticCondition;
begin
  Result := AddItem(Index) as IXMLProbabilisticCondition;
end;

function TXMLProbabilisticConditionList.Get_Item(Index: Integer): IXMLProbabilisticCondition;
begin
  Result := List[Index] as IXMLProbabilisticCondition;
end;

{ TXMLValueForRangeType }

procedure TXMLValueForRangeType.AfterConstruction;
begin
  RegisterChildNode('value', TXMLPercentageValType);
  FValue := CreateCollection(TXMLPercentageValTypeList, IXMLPercentageValType, 'value') as IXMLPercentageValTypeList;
  inherited;
end;

function TXMLValueForRangeType.Get_Value: IXMLPercentageValTypeList;
begin
  Result := FValue;
end;

function TXMLValueForRangeType.Get_Gt: UnicodeString;
begin
  Result := ChildNodes['gt'].Text;
end;

procedure TXMLValueForRangeType.Set_Gt(Value: UnicodeString);
begin
  ChildNodes['gt'].NodeValue := Value;
end;

function TXMLValueForRangeType.Get_Ge: UnicodeString;
begin
  Result := ChildNodes['ge'].Text;
end;

procedure TXMLValueForRangeType.Set_Ge(Value: UnicodeString);
begin
  ChildNodes['ge'].NodeValue := Value;
end;

function TXMLValueForRangeType.Get_Lt: UnicodeString;
begin
  Result := ChildNodes['lt'].Text;
end;

procedure TXMLValueForRangeType.Set_Lt(Value: UnicodeString);
begin
  ChildNodes['lt'].NodeValue := Value;
end;

function TXMLValueForRangeType.Get_Le: UnicodeString;
begin
  Result := ChildNodes['le'].Text;
end;

procedure TXMLValueForRangeType.Set_Le(Value: UnicodeString);
begin
  ChildNodes['le'].NodeValue := Value;
end;

function TXMLValueForRangeType.Get_Eq: UnicodeString;
begin
  Result := ChildNodes['eq'].Text;
end;

procedure TXMLValueForRangeType.Set_Eq(Value: UnicodeString);
begin
  ChildNodes['eq'].NodeValue := Value;
end;

{ TXMLValueForRangeTypeList }

function TXMLValueForRangeTypeList.Add: IXMLValueForRangeType;
begin
  Result := AddItem(-1) as IXMLValueForRangeType;
end;

function TXMLValueForRangeTypeList.Insert(const Index: Integer): IXMLValueForRangeType;
begin
  Result := AddItem(Index) as IXMLValueForRangeType;
end;

function TXMLValueForRangeTypeList.Get_Item(Index: Integer): IXMLValueForRangeType;
begin
  Result := List[Index] as IXMLValueForRangeType;
end;

{ TXMLWaterstate }

procedure TXMLWaterstate.AfterConstruction;
begin
  RegisterChildNode('waves', TXMLWaves);
  RegisterChildNode('swell', TXMLSwell);
  RegisterChildNode('seas', TXMLSeas);
  FWaves := CreateCollection(TXMLWavesList, IXMLWaves, 'waves') as IXMLWavesList;
  FSwell := CreateCollection(TXMLSwellList, IXMLSwell, 'swell') as IXMLSwellList;
  FSeas := CreateCollection(TXMLSeasList, IXMLSeas, 'seas') as IXMLSeasList;
  FIcecoverage := CreateCollection(TXMLNonNegativeIntegerList, IXMLNode, 'ice-coverage') as IXMLNonNegativeIntegerList;
  inherited;
end;

function TXMLWaterstate.Get_Timelayout: UnicodeString;
begin
  Result := AttributeNodes['time-layout'].Text;
end;

procedure TXMLWaterstate.Set_Timelayout(Value: UnicodeString);
begin
  SetAttribute('time-layout', Value);
end;

function TXMLWaterstate.Get_Waves: IXMLWavesList;
begin
  Result := FWaves;
end;

function TXMLWaterstate.Get_Swell: IXMLSwellList;
begin
  Result := FSwell;
end;

function TXMLWaterstate.Get_Seas: IXMLSeasList;
begin
  Result := FSeas;
end;

function TXMLWaterstate.Get_Icecoverage: IXMLNonNegativeIntegerList;
begin
  Result := FIcecoverage;
end;

{ TXMLWaterstateList }

function TXMLWaterstateList.Add: IXMLWaterstate;
begin
  Result := AddItem(-1) as IXMLWaterstate;
end;

function TXMLWaterstateList.Insert(const Index: Integer): IXMLWaterstate;
begin
  Result := AddItem(Index) as IXMLWaterstate;
end;

function TXMLWaterstateList.Get_Item(Index: Integer): IXMLWaterstate;
begin
  Result := List[Index] as IXMLWaterstate;
end;

{ TXMLWaves }

procedure TXMLWaves.AfterConstruction;
begin
  FValue := CreateCollection(TXMLNonNegativeIntegerList, IXMLNode, 'value') as IXMLNonNegativeIntegerList;
  inherited;
end;

function TXMLWaves.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLWaves.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLWaves.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLWaves.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLWaves.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLWaves.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLWaves.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLWaves.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLWaves.Get_Period: LongWord;
begin
  Result := AttributeNodes['period'].NodeValue;
end;

procedure TXMLWaves.Set_Period(Value: LongWord);
begin
  SetAttribute('period', Value);
end;

function TXMLWaves.Get_Steepness: LongWord;
begin
  Result := AttributeNodes['steepness'].NodeValue;
end;

procedure TXMLWaves.Set_Steepness(Value: LongWord);
begin
  SetAttribute('steepness', Value);
end;

function TXMLWaves.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLWaves.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLWaves.Get_Value: IXMLNonNegativeIntegerList;
begin
  Result := FValue;
end;

{ TXMLWavesList }

function TXMLWavesList.Add: IXMLWaves;
begin
  Result := AddItem(-1) as IXMLWaves;
end;

function TXMLWavesList.Insert(const Index: Integer): IXMLWaves;
begin
  Result := AddItem(Index) as IXMLWaves;
end;

function TXMLWavesList.Get_Item(Index: Integer): IXMLWaves;
begin
  Result := List[Index] as IXMLWaves;
end;

{ TXMLSwell }

procedure TXMLSwell.AfterConstruction;
begin
  RegisterChildNode('direction', TXMLDirection);
  inherited;
end;

function TXMLSwell.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLSwell.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLSwell.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLSwell.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLSwell.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLSwell.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLSwell.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLSwell.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLSwell.Get_Period: LongWord;
begin
  Result := AttributeNodes['period'].NodeValue;
end;

procedure TXMLSwell.Set_Period(Value: LongWord);
begin
  SetAttribute('period', Value);
end;

function TXMLSwell.Get_Steepness: LongWord;
begin
  Result := AttributeNodes['steepness'].NodeValue;
end;

procedure TXMLSwell.Set_Steepness(Value: LongWord);
begin
  SetAttribute('steepness', Value);
end;

function TXMLSwell.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLSwell.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLSwell.Get_Value: UnicodeString;
begin
  Result := ChildNodes['value'].Text;
end;

procedure TXMLSwell.Set_Value(Value: UnicodeString);
begin
  ChildNodes['value'].NodeValue := Value;
end;

function TXMLSwell.Get_Direction: IXMLDirection;
begin
  Result := ChildNodes['direction'] as IXMLDirection;
end;

{ TXMLSwellList }

function TXMLSwellList.Add: IXMLSwell;
begin
  Result := AddItem(-1) as IXMLSwell;
end;

function TXMLSwellList.Insert(const Index: Integer): IXMLSwell;
begin
  Result := AddItem(Index) as IXMLSwell;
end;

function TXMLSwellList.Get_Item(Index: Integer): IXMLSwell;
begin
  Result := List[Index] as IXMLSwell;
end;

{ TXMLSeas }

procedure TXMLSeas.AfterConstruction;
begin
  FValue := CreateCollection(TXMLNonNegativeIntegerList, IXMLNode, 'value') as IXMLNonNegativeIntegerList;
  inherited;
end;

function TXMLSeas.Get_Type_: UnicodeString;
begin
  Result := AttributeNodes['type'].Text;
end;

procedure TXMLSeas.Set_Type_(Value: UnicodeString);
begin
  SetAttribute('type', Value);
end;

function TXMLSeas.Get_Units: UnicodeString;
begin
  Result := AttributeNodes['units'].Text;
end;

procedure TXMLSeas.Set_Units(Value: UnicodeString);
begin
  SetAttribute('units', Value);
end;

function TXMLSeas.Get_Categoricaltable: UnicodeString;
begin
  Result := AttributeNodes['categorical-table'].Text;
end;

procedure TXMLSeas.Set_Categoricaltable(Value: UnicodeString);
begin
  SetAttribute('categorical-table', Value);
end;

function TXMLSeas.Get_Conversiontable: UnicodeString;
begin
  Result := AttributeNodes['conversion-table'].Text;
end;

procedure TXMLSeas.Set_Conversiontable(Value: UnicodeString);
begin
  SetAttribute('conversion-table', Value);
end;

function TXMLSeas.Get_Name: UnicodeString;
begin
  Result := ChildNodes['name'].Text;
end;

procedure TXMLSeas.Set_Name(Value: UnicodeString);
begin
  ChildNodes['name'].NodeValue := Value;
end;

function TXMLSeas.Get_Value: IXMLNonNegativeIntegerList;
begin
  Result := FValue;
end;

{ TXMLSeasList }

function TXMLSeasList.Add: IXMLSeas;
begin
  Result := AddItem(-1) as IXMLSeas;
end;

function TXMLSeasList.Insert(const Index: Integer): IXMLSeas;
begin
  Result := AddItem(Index) as IXMLSeas;
end;

function TXMLSeasList.Get_Item(Index: Integer): IXMLSeas;
begin
  Result := List[Index] as IXMLSeas;
end;

{ TXMLNonNegativeIntegerList }

function TXMLNonNegativeIntegerList.Add(const Value: LongWord): IXMLNode;
begin
  Result := AddItem(-1);
  Result.NodeValue := Value;
end;

function TXMLNonNegativeIntegerList.Insert(const Index: Integer; const Value: LongWord): IXMLNode;
begin
  Result := AddItem(Index);
  Result.NodeValue := Value;
end;

function TXMLNonNegativeIntegerList.Get_Item(Index: Integer): LongWord;
begin
  Result := List[Index].NodeValue;
end;

{ TXMLDateTimeList }

function TXMLDateTimeList.Add(const Value: UnicodeString): IXMLNode;
begin
  Result := AddItem(-1);
  Result.NodeValue := Value;
end;

function TXMLDateTimeList.Insert(const Index: Integer; const Value: UnicodeString): IXMLNode;
begin
  Result := AddItem(Index);
  Result.NodeValue := Value;
end;

function TXMLDateTimeList.Get_Item(Index: Integer): UnicodeString;
begin
  Result := List[Index].NodeValue;
end;

{ TXMLAnyURIList }

function TXMLAnyURIList.Add(const Value: UnicodeString): IXMLNode;
begin
  Result := AddItem(-1);
  Result.NodeValue := Value;
end;

function TXMLAnyURIList.Insert(const Index: Integer; const Value: UnicodeString): IXMLNode;
begin
  Result := AddItem(Index);
  Result.NodeValue := Value;
end;

function TXMLAnyURIList.Get_Item(Index: Integer): UnicodeString;
begin
  Result := List[Index].NodeValue;
end;

{ TXMLString_List }

function TXMLString_List.Add(const Value: UnicodeString): IXMLNode;
begin
  Result := AddItem(-1);
  Result.NodeValue := Value;
end;

function TXMLString_List.Insert(const Index: Integer; const Value: UnicodeString): IXMLNode;
begin
  Result := AddItem(Index);
  Result.NodeValue := Value;
end;

function TXMLString_List.Get_Item(Index: Integer): UnicodeString;
begin
  Result := List[Index].NodeValue;
end;

end.