ews javascript api

IEwsHttpWebResponse

{ throw new Error("EwsUtilities.ts - static FormatHttpResponseHeaders : Not implemented."); };
   EwsUtilities.FormatLogMessage = function (entryKind, logEntry) { throw new Error("EwsUtilities.ts - static FormatLogMessage : Not implemented."); };
   EwsUtilities.FormatLogMessageWithXmlContent = function (entryKind, memoryStream) { throw new Error("EwsUtilities.ts - static FormatLogMessageWithXmlContent : Not implemented."); };
   EwsUtilities.GetEnumeratedObjectAt = function (objects, index) { throw new Error("EwsUtilities.ts - static GetEnumeratedObjectAt : Not implemented."); };
   EwsUtilities.GetEnumeratedObjectCount = function (objects) { throw new Error("EwsUtilities.ts - static GetEnumeratedObjectCount : Not implemented."); };
   //static GetEnumSchemaName(enumType: System.Type, enumName: string): string{ throw new Error("EwsUtilities.ts - static GetEnumSchemaName : Not implemented.");}
   //static GetEnumVersion(enumType: System.Type, enumName: string): ExchangeVersion{ throw new Error("EwsUtilities.ts - static GetEnumVersion : Not implemented.");}
   //static GetItemTypeFromXmlElementName(xmlElementName: string): System.Type{ throw new Error("EwsUtilities.ts - static GetItemTypeFromXmlElementName : Not implemented.");}
   EwsUtilities.GetNamespaceFromUri = function (namespaceUri) {
       switch (namespaceUri) {
           case this.EwsErrorsNamespace:
               return XmlNamespace_1.XmlNamespace.Errors;
           case this.EwsTypesNamespace:
               return XmlNamespace_1.XmlNamespace.Types;
           case this.EwsMessagesNamespace:
               return XmlNamespace_1.XmlNamespace.Messages;
           case this.EwsSoapNamespace:
               return XmlNamespace_1.XmlNamespace.Soap;
           case this.EwsSoap12Namespace:
               return XmlNamespace_1.XmlNamespace.Soap12;
           case this.EwsXmlSchemaInstanceNamespace:
               return XmlNamespace_1.XmlNamespace.XmlSchemaInstance;
           case this.PassportSoapFaultNamespace:
               return XmlNamespace_1.XmlNamespace.PassportSoapFault;
           case this.WSTrustFebruary2005Namespace:
               return XmlNamespace_1.XmlNamespace.WSTrustFebruary2005;
           case this.WSAddressingNamespace:
               return XmlNamespace_1.XmlNamespace.WSAddressing;
           default:
               return XmlNamespace_1.XmlNamespace.NotSpecified;
       }
   };
   EwsUtilities.GetNamespacePrefix = function (xmlNamespace) {
       switch (xmlNamespace) {
           case XmlNamespace_1.XmlNamespace.Types:
               return EwsUtilities.EwsTypesNamespacePrefix;
           case XmlNamespace_1.XmlNamespace.Messages:
               return EwsUtilities.EwsMessagesNamespacePrefix;
           case XmlNamespace_1.XmlNamespace.Errors:
               return EwsUtilities.EwsErrorsNamespacePrefix;
           case XmlNamespace_1.XmlNamespace.Soap:
           case XmlNamespace_1.XmlNamespace.Soap12:
               return EwsUtilities.EwsSoapNamespacePrefix;
           case XmlNamespace_1.XmlNamespace.XmlSchemaInstance:
               return EwsUtilities.EwsXmlSchemaInstanceNamespacePrefix;
           case XmlNamespace_1.XmlNamespace.PassportSoapFault:
               return EwsUtilities.PassportSoapFaultNamespacePrefix;
           case XmlNamespace_1.XmlNamespace.WSTrustFebruary2005:
               return EwsUtilities.WSTrustFebruary2005NamespacePrefix;
           case XmlNamespace_1.XmlNamespace.WSAddressing:
               return EwsUtilities.WSAddressingNamespacePrefix;
           case XmlNamespace_1.XmlNamespace.Autodiscover:
               return EwsUtilities.AutodiscoverSoapNamespacePrefix;
           default:
               return "";
       }
   };
   EwsUtilities.GetNamespaceUri = function (xmlNamespace) {
       switch (xmlNamespace) {
           case XmlNamespace_1.XmlNamespace.Types:
               return EwsUtilities.EwsTypesNamespace;
           case XmlNamespace_1.XmlNamespace.Messages:
               return EwsUtilities.EwsMessagesNamespace;
           case XmlNamespace_1.XmlNamespace.Errors:
               return EwsUtilities.EwsErrorsNamespace;
           case XmlNamespace_1.XmlNamespace.Soap:
               return EwsUtilities.EwsSoapNamespace;
           case XmlNamespace_1.XmlNamespace.Soap12:
               return EwsUtilities.EwsSoap12Namespace;
           case XmlNamespace_1.XmlNamespace.XmlSchemaInstance:
               return EwsUtilities.EwsXmlSchemaInstanceNamespace;
           case XmlNamespace_1.XmlNamespace.PassportSoapFault:
               return EwsUtilities.PassportSoapFaultNamespace;
           case XmlNamespace_1.XmlNamespace.WSTrustFebruary2005:
               return EwsUtilities.WSTrustFebruary2005Namespace;
           case XmlNamespace_1.XmlNamespace.WSAddressing:
               return EwsUtilities.WSAddressingNamespace;
           case XmlNamespace_1.XmlNamespace.Autodiscover:
               return EwsUtilities.AutodiscoverSoapNamespace;
           default:
               return "";
       }
   };
   EwsUtilities.GetPrintableTypeName = function (type

instance

{
       var typename = typeof type;
       if (typename.indexOf("object") >= 0) {
           try {
               typename = type.__proto__.constructor.name;
           }
           catch (error) {
               typename += " - Error getting name";
           }
       }
       return typename;
       //         if (type.IsGenericType)
       //             {
       //                 // Convert generic type to printable form (e.g. List<Item>)
       //                 string genericPrefix = type.Name.Substring(0, type.Name.IndexOf('`'));
       //                 StringBuilder nameBuilder = new StringBuilder(genericPrefix);
       // 
       //                 // Note: building array of generic parameters is done recursively. Each parameter could be any type.
       //                 string[] genericArgs = type.GetGenericArguments().ToList<Type>().ConvertAll<string>(t => GetPrintableTypeName(t)).ToArray<string>();
       // 
       //                 nameBuilder.Append("<");
       //                 nameBuilder.Append(string.Join(",", genericArgs));
       //                 nameBuilder.Append(">");
       //                 return nameBuilder.ToString();
       //             }
       //             else if (type.IsArray)
       //             {
       //                 // Convert array type to printable form.
       //                 string arrayPrefix = type.Name.Substring(0, type.Name.IndexOf('['));
       //                 StringBuilder nameBuilder = new StringBuilder(EwsUtilities.GetSimplifiedTypeName(arrayPrefix));
       //                 for (int rank = 0; rank < type.GetArrayRank(); rank++)
       //                 {
       //                     nameBuilder.Append("[]");
       //                 }
       //                 return nameBuilder.ToString();
       //             }
       //             else
       //             {
       //                 return EwsUtilities.GetSimplifiedTypeName(type.Name);
       //             }
   };
   //static GetSimplifiedTypeName(typeName: string): string{ throw new Error("EwsUtilities.ts - static GetSimplifiedTypeName : Not implemented.");}
   EwsUtilities.IsLocalTimeZone = function (timeZone) { return DateTime_2.TimeZoneInfo.IsLocalTimeZone(timeZone); };
   //static Parse(value: string): any{ throw new Error("EwsUtilities.ts - static Parse : Not implemented.");}
   EwsUtilities.ParseEnum = function (value, ewsenum) { throw new Error("EwsUtilities.ts - static Parse : Not implemented."); };
   EwsUtilities.ParseAsUnbiasedDatetimescopedToServicetimeZone = function (dateString, service) {
       // Convert the element's value to a DateTime with no adjustment.
       var tempDate = DateTime_2.DateTime.Parse(dateString + "Z");
       // Set the kind according to the service's time zone
       if (service.TimeZone == DateTime_2.TimeZoneInfo.Utc) {
           return new DateTime_2.DateTime(tempDate.TotalMilliSeconds, DateTime_2.DateTimeKind.Utc);
       }
       else if (EwsUtilities.IsLocalTimeZone(service.TimeZone)) {
           return new DateTime_2.DateTime(tempDate.TotalMilliSeconds, DateTime_2.DateTimeKind.Local);
       }
       else {
           return new DateTime_2.DateTime(tempDate.TotalMilliSeconds, DateTime_2.DateTimeKind.Unspecified);
       }
   };
   EwsUtilities.ParseEnumValueList = function (list, value, separators, enumType) {
       // EwsLogging.Assert(
       //         typeof(T).IsEnum,
       //         "EwsUtilities.ParseEnumValueList",
       //         "T is not an enum type.");
       var enumValues = value.split(separators);
       for (var _i = 0; _i < enumValues.length; _i++) {
           var enumValue = enumValues[_i];
           var enumValueParsed = enumType[enumValue];
           if (typeof enumValueParsed !== 'undefined')
               list.push(enumValueParsed);
       }
   };
   //static SerializeEnum(value: any): string{ throw new Error("EwsUtilities.ts - static SerializeEnum : Not implemented.");}
   //static SystemToEwsDayOfTheWeek(dayOfWeek: System.DayOfWeek): DayOfTheWeek{ throw new Error("EwsUtilities.ts - static SystemToEwsDayOfTheWeek : Not implemented.");}
   EwsUtilities.TimeSpanToXSDuration = function (timeSpan) {
       // Optional '-' offset
       var offsetStr = (timeSpan.TotalSeconds < 0) ? "-" : ExtensionMethods_1.StringHelper.Empty;
       // The TimeSpan structure does not have a Year or Month 
       // property, therefore we wouldn't be able to return an xs:duration
       // string from a TimeSpan that included the nY or nM components.
       return ExtensionMethods_1.StringHelper.Format("{0}P{1}DT{2}H{3}M{4}S", offsetStr, Math.abs(timeSpan.days()), Math.abs(timeSpan.hours()), Math.abs(timeSpan.minutes()), Math.abs(timeSpan.seconds()) + "." + Math.abs(timeSpan.milliseconds()));
   };
   EwsUtilities.numPad = function (num, length) {
       var str = num.toString();
       while (str.length < length)
           str += "0";
       return str;
   };
   EwsUtilities.TimeSpanToXSTime = function (timeSpan) {
       return ExtensionMethods_1.StringHelper.Format("{0}:{1}:{2}", this.numPad(timeSpan.hours(), 2), this.numPad(timeSpan.minutes(), 2), this.numPad(timeSpan.seconds(), 2));
   };
   EwsUtilities.XSDurationToTimeSpan = function (xsDuration) {
       var regex = /(-)?P([0-9]+)Y?([0-9]+)M?([0-9]+)D?T([0-9]+)H?([0-9]+)M?([0-9]+\.[0-9]+)?S?/;
       if (xsDuration.match(regex) === null) {
           throw new Error(Strings_1.Strings.XsDurationCouldNotBeParsed); //ArgumentException
       }
       return new DateTime_1.TimeSpan(xsDuration); //using moment, it recognize the format.
   };
   //static TrueForAll(collection: System.Collections.Generic.IEnumerable<T>, predicate: any): boolean{ throw new Error("EwsUtilities.ts - static TrueForAll : Not implemented.");}
   EwsUtilities.ValidateClassVersion = function (service, minimumServerVersion, className) { throw new Error("EwsUtilities.ts - static ValidateClassVersion : Not implemented."); };
   EwsUtilities.ValidateDomainNameAllowNull = function (domainName, paramName) {
       //todo: validate domain names per ews managed api
       //if (domainName != null) {
       //    Regex regex = new Regex(DomainRegex);
       //    if (!regex.IsMatch(domainName)) {
       //        throw new ArgumentException(string.Format(Strings.InvalidDomainName, domainName), paramName);
       //    }
       //}
   };
   EwsUtilities.ValidateEnumVersionValue = function (enumType, enumValue, requestVersion) {
       var enumVersion = this.GetExchangeVersionFromEnumDelegate(enumType, enumValue);
       if (requestVersion < enumVersion) {
           throw new ServiceVersionException_1.ServiceVersionException(ExtensionMethods_1.StringHelper.Format(Strings_1.Strings.EnumValueIncompatibleWithRequestVersion, enumValue, 
           //WellKnownFolderName[folderEnum],
           EnumToExchangeVersionMappingHelper_1.EnumToExchangeVersionMappingHelper[enumType], ExchangeVersion_1.ExchangeVersion[enumVersion]));
       }
       //////EwsUtilities.ValidateEnumVersionValue(this.FolderName, version); - alternate validation using next line
       //////todo: move to ewsutilities - done
       ////export class ExchangeVersionValidator {
       ////    static ValidateWellKnownFolderName(folderEnum: WellKnownFolderName, requestedVersion: ExchangeVersion): void {
       ////        var enumVersion = ExchangeVersion.Exchange2007_SP1;
       ////        if (folderEnum <= 15) enumVersion = ExchangeVersion.Exchange2007_SP1;
       ////        else if (folderEnum >= 16 && folderEnum <= 26) enumVersion = ExchangeVersion.Exchange2010_SP1;
       ////        else if (folderEnum >= 27 && folderEnum <= 34) enumVersion = ExchangeVersion.Exchange2013;
       ////        else enumVersion = ExchangeVersion.Exchange2013;
       ////        if (requestedVersion < enumVersion) {
       ////            throw new ServiceVersionException(
       ////                string.Format(
       ////                    Strings.EnumValueIncompatibleWithRequestVersion,
       ////                    WellKnownFolderName[folderEnum],
       ////                    "WellKnownFolderName",
       ////                    ExchangeVersion[enumVersion]));
       ////        }
       ////    }
       ////}
   };
   EwsUtilities.ValidateMethodVersion = function (service, minimumServerVersion, methodName) {
       if (service.RequestedServerVersion < minimumServerVersion) {
           throw new ServiceVersionException_1.ServiceVersionException(ExtensionMethods_1.StringHelper.Format(Strings_1.Strings.MethodIncompatibleWithRequestVersion, methodName, minimumServerVersion));
       }
   };
   EwsUtilities.ValidateNonBlankStringParam = function (param, paramName) { throw new Error("EwsUtilities.ts - static ValidateNonBlankStringParam : Not implemented."); };
   EwsUtilities.ValidateNonBlankStringParamAllowNull = function (param, paramName) {
       if (param != null) {
       }
   };
   EwsUtilities.ValidateParam = function (param, paramName) {
       var isValid = false;
       if (typeof (param) == "string") {
           isValid = !ExtensionMethods_1.StringHelper.IsNullOrEmpty(param);
       }
       else {
           isValid = param != null && typeof (param) !== 'undefined';
       }
       if (!isValid) {
           throw new Error("parameter null exception: " + paramName); // ArgumentNullException(paramName);
       }
       EwsUtilities.ValidateParamAllowNull(param, paramName);
   };
   EwsUtilities.ValidateParamAllowNull = function (param, paramName) {
       return;
       throw new Error("//todo: fix circular with service object");
       var selfValidate = param;
       if (selfValidate.Validate) {
           try {
               selfValidate.Validate();
           }
           catch (e) {
               throw new Error(" validation failed for parameter:" + paramName + ". Error: " + JSON.stringify(e));
           }
       }
       var ewsObject = param;
       //        if (ewsObject instanceof ServiceObject) {
       //            if (ewsObject.IsNew) {
       //                throw new Error("object does not have Id, parameter:" + paramName);// ArgumentException(Strings.ObjectDoesNotHaveId, paramName);
       //            }
       //        }
   };
   EwsUtilities.ValidateParamCollection = function (collection, paramName) { return; throw new Error("EwsUtilities.ts - static ValidateParamCollection : Not implemented."); };
   EwsUtilities.ValidatePropertyVersion = function (service, minimumServerVersion, propertyName) { throw new Error("EwsUtilities.ts - static ValidatePropertyVersion : Not implemented."); };
   EwsUtilities.ValidateServiceObjectVersion = function (serviceObject, requestVersion) { throw new Error("EwsUtilities.ts - static ValidateServiceObjectVersion : Not implemented."); };
   //#region constants in c# - typescript static
   EwsUtilities.XSFalse = "false";
   EwsUtilities.XSTrue = "true";
   EwsUtilities.EwsTypesNamespacePrefix = "t";
   EwsUtilities.EwsMessagesNamespacePrefix = "m";
   EwsUtilities.EwsErrorsNamespacePrefix = "e";
   EwsUtilities.EwsSoapNamespacePrefix = "soap";
   EwsUtilities.EwsXmlSchemaInstanceNamespacePrefix = "xsi";
   EwsUtilities.PassportSoapFaultNamespacePrefix = "psf";
   EwsUtilities.WSTrustFebruary2005NamespacePrefix = "wst";
   EwsUtilities.WSAddressingNamespacePrefix = "wsa";
   EwsUtilities.AutodiscoverSoapNamespacePrefix = "a";
   EwsUtilities.WSSecurityUtilityNamespacePrefix = "wsu";
   EwsUtilities.WSSecuritySecExtNamespacePrefix = "wsse";
   EwsUtilities.EwsTypesNamespace = "http://schemas.microsoft.com/exchange/services/2006/types";
   EwsUtilities.EwsMessagesNamespace = "http://schemas.microsoft.com/exchange/services/2006/messages";
   EwsUtilities.EwsErrorsNamespace = "http://schemas.microsoft.com/exchange/services/2006/errors";
   EwsUtilities.EwsSoapNamespace = "http://schemas.xmlsoap.org/soap/envelope/";
   EwsUtilities.EwsSoap12Namespace = "http://www.w3.org/2003/05/soap-envelope";
   EwsUtilities.EwsXmlSchemaInstanceNamespace = "http://www.w3.org/2001/XMLSchema-instance";
   EwsUtilities.PassportSoapFaultNamespace = "http://schemas.microsoft.com/Passport/SoapServices/SOAPFault";
   EwsUtilities.WSTrustFebruary2005Namespace = "http://schemas.xmlsoap.org/ws/2005/02/trust";
   EwsUtilities.WSAddressingNamespace = "http://www.w3.org/2005/08/addressing";
   EwsUtilities.AutodiscoverSoapNamespace = "http://schemas.microsoft.com/exchange/2010/Autodiscover";
   EwsUtilities.WSSecurityUtilityNamespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd";
   EwsUtilities.WSSecuritySecExtNamespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
   /// <summary>
   /// Regular expression for legal domain names.
   /// </summary>
   EwsUtilities.DomainRegex = "^[-a-zA-Z0-9_.]+$";
   // private static serviceObjectInfo: LazyMember<ServiceObjectInfo> = new LazyMember<ServiceObjectInfo>(
   //     () => {
   //         //return new ServiceObjectInfo();
   //     });
   //private static buildVersion: LazyMember<T>;
   EwsUtilities.enumVersionDictionaries = new LazyMember_1.LazyMember(function () {
       var e2evmh = EnumToExchangeVersionMappingHelper_1.EnumToExchangeVersionMappingHelper;
       var dict = {};
       dict[e2evmh[e2evmh.WellKnownFolderName]] = EwsUtilities.BuildEnumDict(e2evmh.WellKnownFolderName);
       dict[e2evmh[e2evmh.ItemTraversal]] = EwsUtilities.BuildEnumDict(e2evmh.ItemTraversal);
       dict[e2evmh[e2evmh.ConversationQueryTraversal]] = EwsUtilities.BuildEnumDict(e2evmh.ConversationQueryTraversal);
       dict[e2evmh[e2evmh.FileAsMapping]] = EwsUtilities.BuildEnumDict(e2evmh.FileAsMapping);
       dict[e2evmh[e2evmh.EventType]] = EwsUtilities.BuildEnumDict(e2evmh.EventType);
       dict[e2evmh[e2evmh.MeetingRequestsDeliveryScope]] = EwsUtilities.BuildEnumDict(e2evmh.MeetingRequestsDeliveryScope);
       dict[e2evmh[e2evmh.ViewFilter]] = EwsUtilities.BuildEnumDict(e2evmh.ViewFilter);
       dict[e2evmh[e2evmh.MailboxType]] = EwsUtilities.BuildEnumDict(e2evmh.MailboxType);
       return dict;
   });
   return EwsUtilities;
})();
exports.EwsUtilities = EwsUtilities;