@jaricardodev/ews-javascript-api/src/js/Core/ExchangeService.ts

EWS Managed api in JavaScript

import { AddDelegateRequest } from "./Requests/AddDelegateRequest";
import { AffectedTaskOccurrence } from "../Enumerations/AffectedTaskOccurrence";
import { AlternateIdBase } from "../Misc/IdConversion/AlternateIdBase";
import { ApplyConversationActionRequest } from "./Requests/ApplyConversationActionRequest";
import { Appointment } from "./ServiceObjects/Items/Appointment";
import { ArchiveItemRequest } from "./Requests/ArchiveItemRequest";
import { ArchiveItemResponse } from "./Responses/ArchiveItemResponse";
import { ArgumentException, ArgumentOutOfRangeException, ArgumentNullException } from "../Exceptions/ArgumentException";
import { ArrayHelper, StringHelper, UriHelper } from "../ExtensionMethods";
import { Attachment } from "../ComplexProperties/Attachment";
import { AttendeeInfo } from "../Misc/Availability/AttendeeInfo";
import { AutodiscoverErrorCode } from "../Enumerations/AutodiscoverErrorCode";
import { AutodiscoverLocalException } from "../Exceptions/AutodiscoverLocalException";
import { AutodiscoverRedirectionUrlValidationCallback } from "../Autodiscover/AutodiscoverServiceDelegates";
import { AutodiscoverService } from "../Autodiscover/AutodiscoverService";
import { AvailabilityData } from "../Enumerations/AvailabilityData";
import { AvailabilityOptions } from "../Misc/Availability/AvailabilityOptions";
import { BodyType } from "../Enumerations/BodyType";
import { CalendarView } from "../Search/CalendarView";
import { ChangeCollection } from "../Sync/ChangeCollection";
import { ClientAccessTokenRequest } from "../ComplexProperties/ClientAccessTokenRequest";
import { ClientAccessTokenType } from "../Enumerations/ClientAccessTokenType";
import { ClientApp } from "../ComplexProperties/ClientApp";
import { ConflictResolutionMode } from "../Enumerations/ConflictResolutionMode";
import { Conversation } from "./ServiceObjects/Items/Conversation";
import { ConversationAction } from "../Misc/ConversationAction";
import { ConversationActionType } from "../Enumerations/ConversationActionType";
import { ConversationId } from "../ComplexProperties/ConversationId";
import { ConversationRequest } from "../ComplexProperties/ConversationRequest";
import { ConversationResponse } from "../ComplexProperties/ConversationResponse";
import { ConversationSortOrder } from "../Enumerations/ConversationSortOrder";
import { ConvertIdRequest } from "./Requests/ConvertIdRequest";
import { ConvertIdResponse } from "./Responses/ConvertIdResponse";
import { CopyFolderRequest } from "./Requests/CopyFolderRequest";
import { CopyItemRequest } from "./Requests/CopyItemRequest";
import { CreateAttachmentRequest } from "./Requests/CreateAttachmentRequest";
import { CreateAttachmentResponse } from "./Responses/CreateAttachmentResponse";
import { CreateFolderRequest } from "./Requests/CreateFolderRequest";
import { CreateItemRequest } from "./Requests/CreateItemRequest";
import { CreateResponseObjectRequest } from "./Requests/CreateResponseObjectRequest";
import { CreateUserConfigurationRequest } from "./Requests/CreateUserConfigurationRequest";
import { DateTime } from "../DateTime";
import { DateTimePrecision } from "../Enumerations/DateTimePrecision";
import { DelegateInformation } from "../Misc/DelegateInformation";
import { DelegateManagementResponse } from "./Responses/DelegateManagementResponse";
import { DelegateUser } from "../ComplexProperties/DelegateUser";
import { DelegateUserResponse } from "./Responses/DelegateUserResponse";
import { DeleteAttachmentRequest } from "./Requests/DeleteAttachmentRequest";
import { DeleteAttachmentResponse } from "./Responses/DeleteAttachmentResponse";
import { DeleteFolderRequest } from "./Requests/DeleteFolderRequest";
import { DeleteItemRequest } from "./Requests/DeleteItemRequest";
import { DeleteMode } from "../Enumerations/DeleteMode";
import { DeleteUserConfigurationRequest } from "./Requests/DeleteUserConfigurationRequest";
import { DisableAppRequest } from "./Requests/DisableAppRequest";
import { DisableReasonType } from "../Enumerations/DisableReasonType";
import { EmailAddress } from "../ComplexProperties/EmailAddress";
import { EmailAddressCollection } from "../ComplexProperties/EmailAddressCollection";
import { EmptyFolderRequest } from "./Requests/EmptyFolderRequest";
import { EventType } from "../Enumerations/EventType";
import { EwsLogging } from "./EwsLogging";
import { EwsUtilities } from "./EwsUtilities";
import { ExchangeVersion } from "../Enumerations/ExchangeVersion";
import { ExpandGroupRequest } from "./Requests/ExpandGroupRequest";
import { ExpandGroupResults } from "../Misc/ExpandGroupResults";
import { FindConversationRequest } from "./Requests/FindConversationRequest";
import { FindConversationResponse } from "./Responses/FindConversationResponse";
import { FindConversationResults } from "../Search/FindConversationResults";
import { FindFolderRequest } from "./Requests/FindFolderRequest";
import { FindFolderResponse } from "./Responses/FindFolderResponse";
import { FindFoldersResults } from "../Search/FindFoldersResults";
import { FindItemRequest } from "./Requests/FindItemRequest";
import { FindItemResponse } from "./Responses/FindItemResponse";
import { FindItemsResults } from "../Search/FindItemsResults";
import { Flag } from "../ComplexProperties/Flag";
import { Folder } from "./ServiceObjects/Folders/Folder";
import { FolderChange } from "../Sync/FolderChange";
import { FolderId } from "../ComplexProperties/FolderId";
import { FolderIdCollection } from "../ComplexProperties/FolderIdCollection";
import { FolderIdWrapper } from "../Misc/FolderIdWrapper";
import { FolderView } from "../Search/FolderView";
import { GetAppManifestsRequest } from "./Requests/GetAppManifestsRequest";
import { GetAppManifestsResponse } from "./Responses/GetAppManifestsResponse";
import { GetAppMarketplaceUrlRequest } from "./Requests/GetAppMarketplaceUrlRequest";
import { GetAppMarketplaceUrlResponse } from "./Responses/GetAppMarketplaceUrlResponse";
import { GetAttachmentRequest } from "./Requests/GetAttachmentRequest";
import { GetAttachmentResponse } from "./Responses/GetAttachmentResponse";
import { GetClientAccessTokenRequest } from "./Requests/GetClientAccessTokenRequest";
import { GetClientAccessTokenResponse } from "./Responses/GetClientAccessTokenResponse";
import { GetClientExtensionResponse } from "./Responses/GetClientExtensionResponse";
import { GetConversationItemsRequest } from "./Requests/GetConversationItemsRequest";
import { GetConversationItemsResponse } from "./Responses/GetConversationItemsResponse";
import { GetDelegateRequest } from "./Requests/GetDelegateRequest";
import { GetDelegateResponse } from "./Responses/GetDelegateResponse";
import { GetDiscoverySearchConfigurationRequest } from "./Requests/GetDiscoverySearchConfigurationRequest";
import { GetDiscoverySearchConfigurationResponse } from "./Responses/GetDiscoverySearchConfigurationResponse";
import { GetEncryptionConfigurationResponse } from "./Responses/GetEncryptionConfigurationResponse";
import { GetEventsRequest } from "./Requests/GetEventsRequest";
import { GetEventsResults } from "../Notifications/GetEventsResults";
import { GetFolderRequest } from "./Requests/GetFolderRequest";
import { GetFolderRequestForLoad } from "./Requests/GetFolderRequestForLoad";
import { GetFolderResponse } from "./Responses/GetFolderResponse";
import { GetHoldOnMailboxesRequest } from "./Requests/GetHoldOnMailboxesRequest";
import { GetHoldOnMailboxesResponse } from "./Responses/GetHoldOnMailboxesResponse";
import { GetInboxRulesRequest } from "./Requests/GetInboxRulesRequest";
import { GetInboxRulesResponse } from "./Responses/GetInboxRulesResponse";
import { GetItemRequest } from "./Requests/GetItemRequest";
import { GetItemRequestForLoad } from "./Requests/GetItemRequestForLoad";
import { GetItemResponse } from "./Responses/GetItemResponse";
import { GetNonIndexableItemDetailsParameters, GetNonIndexableItemStatisticsParameters } from "../MailboxSearch/NonIndexableItemParameters";
import { GetNonIndexableItemDetailsRequest } from "./Requests/GetNonIndexableItemDetailsRequest";
import { GetNonIndexableItemDetailsResponse } from "./Responses/GetNonIndexableItemDetailsResponse";
import { GetNonIndexableItemStatisticsRequest } from "./Requests/GetNonIndexableItemStatisticsRequest";
import { GetNonIndexableItemStatisticsResponse } from "./Responses/GetNonIndexableItemStatisticsResponse";
import { GetPasswordExpirationDateRequest } from "./Requests/GetPasswordExpirationDateRequest";
import { GetRoomListsRequest } from "./Requests/GetRoomListsRequest";
import { GetRoomsRequest } from "./Requests/GetRoomsRequest";
import { GetSearchableMailboxesRequest } from "./Requests/GetSearchableMailboxesRequest";
import { GetSearchableMailboxesResponse } from "./Responses/GetSearchableMailboxesResponse";
import { GetServerTimeZonesRequest } from "./Requests/GetServerTimeZonesRequest";
import { GetServerTimeZonesResponse } from "./Responses/GetServerTimeZonesResponse";
import { GetUserAvailabilityRequest } from "./Requests/GetUserAvailabilityRequest";
import { GetUserAvailabilityResults } from "../Misc/Availability/GetUserAvailabilityResults";
import { GetUserConfigurationRequest } from "./Requests/GetUserConfigurationRequest";
import { GetUserConfigurationResponse } from "./Responses/GetUserConfigurationResponse";
import { GetUserOofSettingsRequest } from "./Requests/GetUserOofSettingsRequest";
import { GetUserRetentionPolicyTagsRequest } from "./Requests/GetUserRetentionPolicyTagsRequest";
import { GetUserRetentionPolicyTagsResponse } from "./Responses/GetUserRetentionPolicyTagsResponse";
import { GetUserSettingsResponse } from "../Autodiscover/Responses/GetUserSettingsResponse";
import { GroupedFindItemsResults } from "../Search/GroupedFindItemsResults";
import { Grouping } from "../Search/Grouping";
import { Guid } from "../Guid";
import { HoldAction } from "../Enumerations/HoldAction";
import { IFileAttachmentContentHandler } from "../Interfaces/IFileAttachmentContentHandler";
import { IXHROptions } from "../Interfaces";
import { IdFormat } from "../Enumerations/IdFormat";
import { ImpersonatedUserId } from "../Misc/ImpersonatedUserId";
import { InstallAppRequest } from "./Requests/InstallAppRequest";
import { Item } from "./ServiceObjects/Items/Item";
import { ItemChange } from "../Sync/ItemChange";
import { ItemId } from "../ComplexProperties/ItemId";
import { KeyValuePair } from "../AltDictionary";
import { Mailbox } from "../ComplexProperties/Mailbox";
import { MailboxQuery } from "../MailboxSearch/MailboxQuery";
import { MailboxSearchLocation } from "../Enumerations/MailboxSearchLocation";
import { ManagementRoles } from "../Misc/ManagementRoles";
import { MarkAllItemsAsReadRequest } from "./Requests/MarkAllItemsAsReadRequest";
import { MarkAsJunkRequest } from "./Requests/MarkAsJunkRequest";
import { MarkAsJunkResponse } from "./Responses/MarkAsJunkResponse";
import { MeetingRequestsDeliveryScope } from "../Enumerations/MeetingRequestsDeliveryScope";
import { MessageDisposition } from "../Enumerations/MessageDisposition";
import { MoveCopyFolderResponse } from "./Responses/MoveCopyFolderResponse";
import { MoveCopyItemResponse } from "./Responses/MoveCopyItemResponse";
import { MoveFolderRequest } from "./Requests/MoveFolderRequest";
import { MoveItemRequest } from "./Requests/MoveItemRequest";
import { NameResolutionCollection } from "../Misc/NameResolutionCollection";
import { OofSettings } from "../ComplexProperties/Availability/OofSettings";
import { PrivilegedUserId } from "../Misc/PrivilegedUserId";
import { PropertyDefinitionBase } from "../PropertyDefinitions/PropertyDefinitionBase";
import { PropertySet } from "./PropertySet";
import { PullSubscription } from "../Notifications/PullSubscription";
import { PushSubscription } from "../Notifications/PushSubscription";
import { RemoveDelegateRequest } from "./Requests/RemoveDelegateRequest";
import { RenderingMode } from "../Enumerations/RenderingMode";
import { ResolveNameSearchLocation } from "../Enumerations/ResolveNameSearchLocation";
import { ResolveNamesRequest } from "./Requests/ResolveNamesRequest";
import { RetentionType } from "../Enumerations/RetentionType";
import { RuleCollection } from "../ComplexProperties/RuleCollection";
import { RuleOperation } from "../ComplexProperties/RuleOperation";
import { SearchFilter } from "../Search/Filters/SearchFilter";
import { SearchFolder } from "./ServiceObjects/Folders/SearchFolder";
import { SearchMailboxesParameters } from "../MailboxSearch/SearchMailboxesParameters";
import { SearchMailboxesRequest } from "./Requests/SearchMailboxesRequest";
import { SearchMailboxesResponse } from "./Responses/SearchMailboxesResponse";
import { SearchPageDirection } from "../Enumerations/SearchPageDirection";
import { SearchResultType } from "../Enumerations/SearchResultType";
import { SendCancellationsMode } from "../Enumerations/SendCancellationsMode";
import { SendInvitationsMode } from "../Enumerations/SendInvitationsMode";
import { SendInvitationsOrCancellationsMode } from "../Enumerations/SendInvitationsOrCancellationsMode";
import { SendItemRequest } from "./Requests/SendItemRequest";
import { ServiceErrorHandling } from "../Enumerations/ServiceErrorHandling";
import { ServiceLocalException } from "../Exceptions/ServiceLocalException";
import { ServiceObject } from "./ServiceObjects/ServiceObject";
import { ServiceRemoteException } from "../Exceptions/ServiceRemoteException";
import { ServiceResponse } from "./Responses/ServiceResponse";
import { ServiceResponseCollection } from "./Responses/ServiceResponseCollection";
import { ServiceValidationException } from "../Exceptions/ServiceValidationException";
import { SetHoldOnMailboxesParameters } from "../MailboxSearch/SetHoldOnMailboxesParameters";
import { SetHoldOnMailboxesRequest } from "./Requests/SetHoldOnMailboxesRequest";
import { SetHoldOnMailboxesResponse } from "./Responses/SetHoldOnMailboxesResponse";
import { SetTeamMailboxRequest } from "./Requests/SetTeamMailboxRequest";
import { SetUserOofSettingsRequest } from "./Requests/SetUserOofSettingsRequest";
import { SoapFaultDetails } from "../Misc/SoapFaultDetails";
import { SortDirection } from "../Enumerations/SortDirection";
import { StreamingSubscription } from "../Notifications/StreamingSubscription";
import { StringList } from "../ComplexProperties/StringList";
import { Strings } from "../Strings";
import { SubscribeToPullNotificationsRequest } from "./Requests/SubscribeToPullNotificationsRequest";
import { SubscribeToPushNotificationsRequest } from "./Requests/SubscribeToPushNotificationsRequest";
import { SubscribeToStreamingNotificationsRequest } from "./Requests/SubscribeToStreamingNotificationsRequest";
import { SyncFolderHierarchyRequest } from "./Requests/SyncFolderHierarchyRequest";
import { SyncFolderItemsRequest } from "./Requests/SyncFolderItemsRequest";
import { SyncFolderItemsScope } from "../Enumerations/SyncFolderItemsScope";
import { TeamMailboxLifecycleState } from "../Enumerations/TeamMailboxLifecycleState";
import { TimeWindow } from "../Misc/Availability/TimeWindow";
import { TimeZoneInfo } from "../TimeZoneInfo";
import { TraceFlags } from "../Enumerations/TraceFlags";
import { UnifiedMessaging } from "../UnifiedMessaging/UnifiedMessaging";
import { UninstallAppRequest } from "./Requests/UninstallAppRequest";
import { UnpinTeamMailboxRequest } from "./Requests/UnpinTeamMailboxRequest";
import { UnsubscribeRequest } from "./Requests/UnsubscribeRequest";
import { UpdateDelegateRequest } from "./Requests/UpdateDelegateRequest";
import { UpdateFolderRequest } from "./Requests/UpdateFolderRequest";
import { UpdateInboxRulesRequest } from "./Requests/UpdateInboxRulesRequest";
import { UpdateItemRequest } from "./Requests/UpdateItemRequest";
import { UpdateItemResponse } from "./Responses/UpdateItemResponse";
import { UpdateUserConfigurationRequest } from "./Requests/UpdateUserConfigurationRequest";
import { Uri } from "../Uri";
import { UserConfiguration } from "../Misc/UserConfiguration";
import { UserConfigurationProperties } from "../Enumerations/UserConfigurationProperties";
import { UserId } from "../ComplexProperties/UserId";
import { UserSettingName } from "../Enumerations/UserSettingName";
import { ViewBase } from "../Search/ViewBase";
import { WellKnownFolderName } from "../Enumerations/WellKnownFolderName";
import { XHRFactory } from "../XHRFactory";

import { ExchangeServiceBase } from "./ExchangeServiceBase";
/**
 * Represents a binding to the **Exchange Web Services**.
 *
 */
export class ExchangeService extends ExchangeServiceBase {

  //#region Constants
  private static TargetServerVersionHeaderName: string = "X-EWS-TargetVersion";
  //#endregion


  //#region Fields
  private url: Uri = null;
  //private preferredCulture: any = null;// System.Globalization.CultureInfo;
  private dateTimePrecision: DateTimePrecision = DateTimePrecision.Default;
  private impersonatedUserId: ImpersonatedUserId = null;
  private privilegedUserId: PrivilegedUserId = null;
  private managementRoles: ManagementRoles = null;
  private fileAttachmentContentHandler: IFileAttachmentContentHandler = null;
  private unifiedMessaging: UnifiedMessaging = null;
  private enableScpLookup: boolean = false; //false for javascript, AD Lookup not implemented 
  private renderingMode: RenderingMode = RenderingMode.Xml;
  private traceEnablePrettyPrinting: boolean = true;
  private targetServerVersion: string = null;
  private exchange2007CompatibilityMode: boolean = false;
  //#endregion


  //#region Properties

  /**
   * Gets or sets the URL of the Exchange Web Services.
   */
  get Url(): Uri {
    return this.url;
  }
  set Url(value: Uri) {
    this.url = value;
  }

  /**
   * Gets or sets the Id of the user that EWS should impersonate.
   */
  get ImpersonatedUserId(): ImpersonatedUserId {
    return this.impersonatedUserId;
  }
  set ImpersonatedUserId(value: ImpersonatedUserId) {
    this.impersonatedUserId = value;
  }

  /**
   * @internal Gets or sets the Id of the user that EWS should open his/her mailbox with privileged logon type.
   */
  get PrivilegedUserId(): PrivilegedUserId {
    return this.privilegedUserId;
  }
  set PrivilegedUserId(value: PrivilegedUserId) {
    this.privilegedUserId = value;
  }

  /**
   * [summary]
   */
  get ManagementRoles(): ManagementRoles {
    return this.managementRoles;
  }
  set ManagementRoles(value: ManagementRoles) {
    this.managementRoles = value;
  }

  // /**
  //  * Gets or sets the preferred culture for messages returned by the Exchange Web Services.
  //  */
  // get PreferredCulture(): CultureInfo {
  //   return this.preferredCulture;
  // }
  // set PreferredCulture(value: CultureInfo) {
  //   this.preferredCulture = value;
  // }

  /**
   * Gets or sets the DateTime precision for DateTime values returned from Exchange Web Services.
   */
  get DateTimePrecision(): DateTimePrecision {
    return this.dateTimePrecision;
  }
  set DateTimePrecision(value: DateTimePrecision) {
    this.dateTimePrecision = value;
  }

  /**
   * Gets or sets a file attachment content handler.
   */
  get FileAttachmentContentHandler(): IFileAttachmentContentHandler {
    return this.fileAttachmentContentHandler;
  }
  set FileAttachmentContentHandler(value: IFileAttachmentContentHandler) {
    this.fileAttachmentContentHandler = value;
  }

  /**
   * Gets the time zone this service is scoped to.
   */
  get TimeZone(): TimeZoneInfo {
    return this.timeZone;
  }

  /**
   * Provides access to the Unified Messaging functionalities.
   */
  get UnifiedMessaging(): UnifiedMessaging {
    if (this.unifiedMessaging === null) {
      this.unifiedMessaging = new UnifiedMessaging(this);
    }
    return this.unifiedMessaging;
  }

  /**
   * Gets or sets a value indicating whether the AutodiscoverUrl method should perform SCP (Service Connection Point) record lookup when determining the Autodiscover service URL.
   */
  get EnableScpLookup(): boolean {
    return this.enableScpLookup;
  }
  set EnableScpLookup(value: boolean) {
    this.enableScpLookup = value;
  }

  /**
   * @internal Gets or sets a value indicating whether Exchange2007 compatibility mode is enabled.
   * @remarks In order to support E12 servers, the Exchange2007CompatibilityMode property can be used to indicate that we should use "Exchange2007" as the server version string rather than Exchange2007_SP1.
   */
  get Exchange2007CompatibilityMode(): boolean {
    return this.exchange2007CompatibilityMode;
  }
  set Exchange2007CompatibilityMode(value: boolean) {
    this.exchange2007CompatibilityMode = value;
  }

  /**
   * @internal Gets or sets the method by which the service will serialize the request.
   */
  get RenderingMethod(): RenderingMode {
    return this.renderingMode;
  }
  set RenderingMethod(value: RenderingMode) {
    throw new Error("Rendering mode not used");
    this.renderingMode = value;
  }

  /**
   * Gets or sets a value indicating whether trace output is pretty printed.
   */
  get TraceEnablePrettyPrinting(): boolean {
    return this.traceEnablePrettyPrinting;
  }
  set TraceEnablePrettyPrinting(value: boolean) {
    this.traceEnablePrettyPrinting = value;
  }

  /**
   * @internal Gets or sets the target server version string (newer than Exchange2013).
   */
  get TargetServerVersion(): string {
    return this.targetServerVersion;
  }
  set TargetServerVersion(value: string) {
    ExchangeService.ValidateTargetVersion(value);
    this.targetServerVersion = value;
  }

  //#endregion

  //#region Response object operations
  /**
   * @internal Create response object.
   * 
   * @param   {ServiceObject}          responseObject       The response object.
   * @param   {FolderId}               parentFolderId       The parent folder id.
   * @param   {MessageDisposition}     messageDisposition   The message disposition.
   * @return  {Promise<Item[]>}        The list of items created or modified as a result of the "creation" of the response object :Promise.
   */
  InternalCreateResponseObject(responseObject: ServiceObject, parentFolderId: FolderId, messageDisposition: MessageDisposition): Promise<Item[]> {
    var request: CreateResponseObjectRequest = new CreateResponseObjectRequest(this, ServiceErrorHandling.ThrowOnError);
    request.ParentFolderId = parentFolderId;
    request.Items = [responseObject];
    request.MessageDisposition = messageDisposition;
    return request.Execute().then((responses) => {
      return responses.__thisIndexer(0).Items;
    });
  }
  //#endregion


  //#region Folder operations

  /**
   * @internal Binds to folder.
   *
   * @param   {FolderId}           folderId      The folder id.
   * @param   {PropertySet}        propertySet   The property set.
   * @return  {Promise<TFolder>}   Folder object :Promise.
   */
  BindToFolder(folderId: FolderId, propertySet: PropertySet): Promise<Folder>;
  /**
   * @internal Binds to folder.
   *
   * @param   {FolderId}           folderId      The folder id.
   * @param   {PropertySet}        propertySet   The property set.
   * @param   {folderType}         propertySet   Type to Cast - pass Folder or subclass itself, not an instance
   * @return  {Promise<TFolder>}   Folder object :Promise.
   */
  BindToFolder<TFolder extends Folder>(folderId: FolderId, propertySet: PropertySet,/** pass Folder or subclass itself, not an instance */ folderType: any): Promise<TFolder>;
  BindToFolder(folderId: FolderId, propertySet: PropertySet, /** pass Folder or subclass itself, not an instance */ folderType: any = null): Promise<Folder> {
    EwsUtilities.ValidateParam(folderId, "folderId");
    EwsUtilities.ValidateParam(propertySet, "propertySet");

    var request: GetFolderRequest = new GetFolderRequest(this, ServiceErrorHandling.ThrowOnError);

    request.FolderIds.Add(folderId);
    request.PropertySet = propertySet;

    return request.Execute().then((responses) => {
      var result = responses.__thisIndexer(0).Folder;
      if (folderType != null && !(result instanceof folderType)) { //todo: validate folderType to be not a constructor
        throw new ServiceLocalException(
          StringHelper.Format(
            Strings.FolderTypeNotCompatible,
            "Type detection not implemented - ExchangeService.ts - BindToFolder<TFolder>",
            "Type detection not implemented"));
      }
      return result;
    });


  }
  /**
   * @internal Copies a folder. Calling this method results in a call to EWS.
   *
   * @param   {FolderId}           folderId              The folder id.
   * @param   {FolderId}           destinationFolderId   The destination folder id.
   * @return  {Promise<Folder>}    Copy of folder :Promise.
   */
  CopyFolder(folderId: FolderId, destinationFolderId: FolderId): Promise<Folder> {
    var request: CopyFolderRequest = new CopyFolderRequest(this, ServiceErrorHandling.ThrowOnError);

    request.DestinationFolderId = destinationFolderId;
    request.FolderIds.Add(folderId);

    return request.Execute().then((responses) => {
      return responses.__thisIndexer(0).Folder;
    });
  }
  /**
   * @internal Creates a folder. Calling this method results in a call to EWS.
   *
   * @param   {FolderId}   folder           The folder.
   * @param   {FolderId}   parentFolderId   The parent folder id.
   */
  CreateFolder(folder: Folder, parentFolderId: FolderId): Promise<void> {
    var request: CreateFolderRequest = new CreateFolderRequest(this, ServiceErrorHandling.ThrowOnError);
    request.Folders = [folder];
    request.ParentFolderId = parentFolderId;
    return <any>request.Execute();
  }

  /**
   * @internal Deletes a folder. Calling this method results in a call to EWS.
   *
   * @param   {FolderId}      folderId     The folder id.
   * @param   {DeleteMode}    deleteMode   The delete mode.
   */
  DeleteFolder(folderId: FolderId, deleteMode: DeleteMode): Promise<void> {
    EwsUtilities.ValidateParam(folderId, "folderId");
    var request: DeleteFolderRequest = new DeleteFolderRequest(this, ServiceErrorHandling.ThrowOnError);
    request.FolderIds.Add(folderId);
    request.DeleteMode = deleteMode;
    return <any>request.Execute();
  }
  /**
   * @internal Empties a folder. Calling this method results in a call to EWS.
   *
   * @param   {FolderId}      folderId           The folder id.
   * @param   {DeleteMode}    deleteMode         The delete mode.
   * @param   {boolean}       deleteSubFolders   if set to true empty folder should also delete sub folders.
   */
  EmptyFolder(folderId: FolderId, deleteMode: DeleteMode, deleteSubFolders: boolean): Promise<void> {
    EwsUtilities.ValidateParam(folderId, "folderId");
    var request: EmptyFolderRequest = new EmptyFolderRequest(this, ServiceErrorHandling.ThrowOnError);
    request.FolderIds.Add(folderId);
    request.DeleteMode = deleteMode;
    request.DeleteSubFolders = deleteSubFolders;
    return <any>request.Execute();
  }

  /**
   * Obtains a list of folders by searching the sub-folders of the specified folder.
   *
   * @param   {FolderId}                       parentFolderId   The Id of the folder in which to search for folders.
   * @param   {FolderView}                     view             The view controlling the number of folders returned.
   * @return  {Promise<FindFoldersResults>}    An object representing the results of the search operation :Promise.
   */
  FindFolders(parentFolderId: FolderId, view: FolderView): Promise<FindFoldersResults>;
  /**
   * Obtains a list of folders by searching the sub-folders of the specified folder.
   *
   * @param   {WellKnownFolderName}            parentFolderName   The name of the folder in which to search for folders.
   * @param   {FolderView}                     view               The view controlling the number of folders returned.
   * @return  {Promise<FindFoldersResults>}    An object representing the results of the search operation :Promise.
   */
  FindFolders(parentFolderName: WellKnownFolderName, view: FolderView): Promise<FindFoldersResults>;
  /**
   * Obtains a list of folders by searching the sub-folders of the specified folder.
   *
   * @param   {FolderId}                       parentFolderId   The Id of the folder in which to search for folders.
   * @param   {SearchFilter}                   searchFilter     The search filter. Available search filter classes include SearchFilter.IsEqualTo, SearchFilter.ContainsSubstring and SearchFilter.SearchFilterCollection
   * @param   {FolderView}                     view             The view controlling the number of folders returned.
   * @return  {Promise<FindFoldersResults>}    An object representing the results of the search operation :Promise.
   */
  FindFolders(parentFolderId: FolderId, searchFilter: SearchFilter, view: FolderView): Promise<FindFoldersResults>;
  /**
   * Obtains a list of folders by searching the sub-folders of the specified folder.
   *
   * @param   {WellKnownFolderName}            parentFolderName   The name of the folder in which to search for folders.
   * @param   {SearchFilter}                   searchFilter       The search filter. Available search filter classes include SearchFilter.IsEqualTo, SearchFilter.ContainsSubstring and SearchFilter.SearchFilterCollection
   * @param   {FolderView}                     view               The view controlling the number of folders returned.
   * @return  {Promise<FindFoldersResults>}    An object representing the results of the search operation :Promise.
   */
  FindFolders(parentFolderName: WellKnownFolderName, searchFilter: SearchFilter, view: FolderView): Promise<FindFoldersResults>;

  FindFolders(
    parentFolderIdOrName: FolderId | WellKnownFolderName,
    viewOrSearchFilter: FolderView | SearchFilter,
    folderView?: FolderView): Promise<FindFoldersResults> {
    //todo: better argument check with ewsutilities
    //EwsUtilities.ValidateParam(parentFolderId, "parentFolderId");
    //EwsUtilities.ValidateParam(view, "view");
    //EwsUtilities.ValidateParamAllowNull(searchFilter, "searchFilter");
    var argsLength = arguments.length;
    if (argsLength < 2 && argsLength > 3) {
      throw new Error("ExchangeService.ts - FindFolders - invalid number of arguments, check documentation and try again.");
    }

    //position 1 - parentFolderIdOrName
    var parentFolderIds: FolderId[] = []
    if (typeof parentFolderIdOrName === 'number') {
      parentFolderIds.push(new FolderId(parentFolderIdOrName));
    }
    else if (parentFolderIdOrName instanceof FolderId) {
      parentFolderIds.push(parentFolderIdOrName);
    }
    else {
      throw new Error("ExchangeService.ts - FindFolders - incorrect use of parameters, 1st argument must be Folder ID or WellKnownFolderName");
    }

    var searchFilter: SearchFilter = null;
    var view: FolderView = null;

    //position 2 - viewOrSearchFilter
    if (viewOrSearchFilter instanceof SearchFilter) {
      if (!(folderView instanceof FolderView)) {
        throw new Error("ExchangeService.ts - FindFolders with " + argsLength + " parameters - incorrect uses of parameter at 3nd position, it must be FolderView when using SearchFilter at 2nd place");
      }
      searchFilter = viewOrSearchFilter;
    }
    else if (viewOrSearchFilter instanceof FolderView) {
      view = viewOrSearchFilter;
    }
    else {
      throw new Error("ExchangeService.ts - FindFolders - incorrect uses of parameters at 2nd position, must be FolderView or SearchFilter");
    }

    //position 3 - folderView
    if (argsLength == 3) {
      view = folderView;
    }

    return this.InternalFindFolders(
      parentFolderIds,
      searchFilter, /* searchFilter */
      view,
      ServiceErrorHandling.ThrowOnError).then((responses) => {
        return responses.__thisIndexer(0).Results;
      });
  }
  /**
   * Finds folders.
   *
   * @param   {FolderId[]}             parentFolderIds     The parent folder ids.
   * @param   {SearchFilter}           searchFilter        The search filter. Available search filter classes include SearchFilter.IsEqualTo, SearchFilter.ContainsSubstring and SearchFilter.SearchFilterCollection
   * @param   {FolderView}             view                The view controlling the number of folders returned.
   * @param   {ServiceErrorHandling}   errorHandlingMode   Indicates the type of error handling should be done.
   * @return  {Promise<ServiceResponseCollection<FindFolderResponse>>}     Collection of service responses :Promise.
   */
  private InternalFindFolders(parentFolderIds: FolderId[], searchFilter: SearchFilter, view: FolderView, errorHandlingMode: ServiceErrorHandling): Promise<ServiceResponseCollection<FindFolderResponse>> {

    var request: FindFolderRequest = new FindFolderRequest(this, errorHandlingMode);

    request.ParentFolderIds.AddRange(parentFolderIds);
    request.SearchFilter = searchFilter;
    request.View = view;

    return request.Execute();
  }
  /**
   * @internal Load specified properties for a folder.
   *
   * @param   {Folder}         folder        The folder.
   * @param   {PropertySet}    propertySet   The property set.
   */
  LoadPropertiesForFolder(folder: Folder, propertySet: PropertySet): Promise<void> {
    EwsUtilities.ValidateParam(folder, "folder");
    EwsUtilities.ValidateParam(propertySet, "propertySet");

    var request: GetFolderRequestForLoad = new GetFolderRequestForLoad(this, ServiceErrorHandling.ThrowOnError);

    request.FolderIds.Add(folder);
    request.PropertySet = propertySet;

    return <any>request.Execute();
  }
  /**
   * @internal Marks all items in folder as read/unread. Calling this method results in a call to EWS.
   *
   * @param   {FolderId}      folderId               The folder id.
   * @param   {boolean}       readFlag               If true, items marked as read, otherwise unread.
   * @param   {boolean}       suppressReadReceipts   If true, suppress read receipts for items.
   */
  MarkAllItemsAsRead(folderId: FolderId, readFlag: boolean, suppressReadReceipts: boolean): Promise<void> {
    EwsUtilities.ValidateParam(folderId, "folderId");
    EwsUtilities.ValidateMethodVersion(this, ExchangeVersion.Exchange2013, "MarkAllItemsAsRead");
    var request: MarkAllItemsAsReadRequest = new MarkAllItemsAsReadRequest(this, ServiceErrorHandling.ThrowOnError);
    request.FolderIds.Add(folderId);
    request.ReadFlag = readFlag;
    request.SuppressReadReceipts = suppressReadReceipts;
    return <any>request.Execute();
  }
  /**
   * @internal Move a folder.
   *
   * @param   {FolderId}           folderId              The folder id.
   * @param   {FolderId}           destinationFolderId   The destination folder id.
   * @return  {Promise<Folder>}    Moved folder :Promise.
   */
  MoveFolder(folderId: FolderId, destinationFolderId: FolderId): Promise<Folder> {
    var request: MoveFolderRequest = new MoveFolderRequest(this, ServiceErrorHandling.ThrowOnError);
    request.DestinationFolderId = destinationFolderId;
    request.FolderIds.Add(folderId);
    return request.Execute().then((responses) => {
      return responses.__thisIndexer(0).Folder;
    });
  }
  /**
   * @internal Updates a folder.
   *
   * @param   {Folder}   folder   The folder.
   */
  UpdateFolder(folder: Folder): Promise<void> {
    var request: UpdateFolderRequest = new UpdateFolderRequest(this, ServiceErrorHandling.ThrowOnError);
    request.Folders.push(folder);
    return request.Execute().then((value) => {
      return null;
    });
  }
  //#endregion


  //#region Item operations

  /**
   * Archives multiple items in a single call to EWS.
   *
   * @param   {ItemId[]}   itemIds          The Ids of the items to move.
   * @param   {FolderId}   sourceFolderId   The Id of the folder in primary corresponding to which items are being archived to.
   * @return  {Promise<ServiceResponseCollection<ArchiveItemResponse>>}                     A ServiceResponseCollection providing copy results for each of the specified item Ids :Promise.
   */
  ArchiveItems<TResponse extends ServiceResponse>(itemIds: ItemId[], sourceFolderId: FolderId): Promise<ServiceResponseCollection<ArchiveItemResponse>> {
    var request: ArchiveItemRequest = new ArchiveItemRequest(this, ServiceErrorHandling.ReturnErrors);
    request.Ids.AddRange(itemIds);
    request.SourceFolderId = sourceFolderId;
    return request.Execute();
  }
  /* //ref: new method, //todo: implement other newer code from ews managed api repo  */
  /**
   * Binds to multiple items in a single call to EWS.
   *
   * @param   {ItemId[]}      itemIds         The Ids of the items to bind to.
   * @param   {PropertySet}   propertySet     The set of properties to load.
   * @param   {string}        anchorMailbox   The SmtpAddress of mailbox that hosts all items we need to bind to
   * @return  {Promise<ServiceResponseCollection<GetItemResponse>>}                    A ServiceResponseCollection providing results for each of the specified item Ids :Promise.
   */
  BindToGroupItems(itemIds: ItemId[], propertySet: PropertySet, anchorMailbox: string): Promise<ServiceResponseCollection<GetItemResponse>> {
    EwsUtilities.ValidateParamCollection(itemIds, "itemIds");
    EwsUtilities.ValidateParam(propertySet, "propertySet");
    EwsUtilities.ValidateParam(propertySet, "anchorMailbox");

    return this.InternalBindToItems(
      itemIds,
      propertySet,
      anchorMailbox,
      ServiceErrorHandling.ReturnErrors);
  }
  /**
   * @internal Binds to item.
   *
   * @param   {ItemId}            itemId        The item id.
   * @param   {PropertySet}       propertySet   The property set.
   * @return  {Promise<Item>}     Item :Promise.
   */
  BindToItem(itemId: ItemId, propertySet: PropertySet): Promise<Item>;
  /**
   * @internal Binds to item.
   *
   * @param   {ItemId}            itemId        The item id.
   * @param   {PropertySet}       propertySet   The property set.
   * @param   {<TItem>}           itemType      Item type class ex: Item, EmailMessage etc..
   * @return  {Promise<Item>}     Item :Promise.
   */
  BindToItem<TItem extends Item>(itemId: ItemId, propertySet: PropertySet, itemType: typeof Item /* pass Item or subclass itself, not instance */): Promise<TItem>;
  BindToItem(itemId: ItemId, propertySet: PropertySet,/** pass Item or subclass itself, not an instance */ itemType: typeof Item = null): Promise<Item> {

    EwsUtilities.ValidateParam(itemId, "itemId");
    EwsUtilities.ValidateParam(propertySet, "propertySet");

    return this.InternalBindToItems(
      [itemId],
      propertySet,
      null, /* anchorMailbox */
      ServiceErrorHandling.ThrowOnError).then((response) => {
        var result = response.__thisIndexer(0).Item;
        if (itemType != null && !(result instanceof itemType)) { //todo: validate itemType to be not a constructor
          throw new ServiceLocalException(
            StringHelper.Format(
              Strings.ItemTypeNotCompatible,
              "Type detection not implemented - ExchangeService.ts - BindToItem<TItem>",
              "Type detection not implemented"));
        }

        return result;
      });
  }
  /**
   * Binds to multiple items in a single call to EWS.
   *
   * @param   {ItemId[]}      itemIds       The Ids of the items to bind to.
   * @param   {PropertySet}   propertySet   The set of properties to load.
   * @return  {Promise<ServiceResponseCollection<GetItemResponse>>}                  A ServiceResponseCollection providing results for each of the specified item Ids :Promise.
   */
  BindToItems(itemIds: ItemId[], propertySet: PropertySet): Promise<ServiceResponseCollection<GetItemResponse>> {
    EwsUtilities.ValidateParamCollection(itemIds, "itemIds");
    EwsUtilities.ValidateParam(propertySet, "propertySet");

    return this.InternalBindToItems(
      itemIds,
      propertySet,
      null, /* anchorMailbox */
      ServiceErrorHandling.ReturnErrors);
  }
  /**
   * @internal Copies an item. Calling this method results in a call to EWS.
   *
   * @param   {ItemId}        itemId                The Id of the item to copy.
   * @param   {FolderId}      destinationFolderId   The Id of the folder to copy the item to.
   * @return  {Promise<Item>}     The copy of the item :Promise.
   */
  CopyItem(itemId: ItemId, destinationFolderId: FolderId): Promise<Item> {
    return this.InternalCopyItems(
      [itemId],
      destinationFolderId,
      null,
      ServiceErrorHandling.ThrowOnError).then((response) => {
        return response.__thisIndexer(0).Item;
      });
  }
  /**
   * Copies multiple items in a single call to EWS.
   *
   * @param   {ItemId[]}      itemIds               The Ids of the items to copy.
   * @param   {FolderId}      destinationFolderId   The Id of the folder to copy the items to.
   * @return  {Promise<ServiceResponseCollection<MoveCopyItemResponse>>}                          A ServiceResponseCollection providing copy results for each of the specified item Ids :Promise.
   */
  CopyItems(itemIds: ItemId[], destinationFolderId: FolderId): Promise<ServiceResponseCollection<MoveCopyItemResponse>>;
  /**
   * Copies multiple items in a single call to EWS.
   *
   * @param   {ItemId[]}      itemIds               The Ids of the items to copy.
   * @param   {FolderId}      destinationFolderId   The Id of the folder to copy the items to.
   * @param   {boolean}       returnNewItemIds      Flag indicating whether service should return new ItemIds or not.
   * @return  {Promise<ServiceResponseCollection<MoveCopyItemResponse>>}                          A ServiceResponseCollection providing copy results for each of the specified item Ids :Promise.
   */
  CopyItems(itemIds: ItemId[], destinationFolderId: FolderId, returnNewItemIds: boolean): Promise<ServiceResponseCollection<MoveCopyItemResponse>>;
  CopyItems(itemIds: ItemId[], destinationFolderId: FolderId, returnNewItemIds: boolean = null): Promise<ServiceResponseCollection<MoveCopyItemResponse>> {
    EwsUtilities.ValidateMethodVersion(
      this,
      ExchangeVersion.Exchange2010_SP1,
      "CopyItems");

    return this.InternalCopyItems(
      itemIds,
      destinationFolderId,
      returnNewItemIds,
      ServiceErrorHandling.ReturnErrors);
  }
  /**
   * @internal Creates an item. Calling this method results in a call to EWS.
   *
   * @param   {Item}                  item                  The item to create.
   * @param   {FolderId}              parentFolderId        The Id of the folder in which to place the newly created item. If null, the item is created in its default folders.
   * @param   {MessageDisposition}    messageDisposition    Indicates the disposition mode for items of type EmailMessage. Required if item is an EmailMessage instance.
   * @param   {SendInvitationsMode}   sendInvitationsMode   Indicates if and how invitations should be sent for item of type Appointment. Required if item is an Appointment instance.
   */
  CreateItem(item: Item, parentFolderId: FolderId, messageDisposition: MessageDisposition, sendInvitationsMode: SendInvitationsMode): Promise<void> {
    return <any>this.InternalCreateItems(
      [item],
      parentFolderId,
      messageDisposition,
      sendInvitationsMode,
      ServiceErrorHandling.ThrowOnError);
  }
  /**
   * Creates multiple items in a single EWS call. Supported item classes are EmailMessage, Appointment, Contact, PostItem, Task and Item. CreateItems does not support items that have unsaved attachments.
   *
   * @param   {Item[]}                items                 The items to create.
   * @param   {FolderId}              parentFolderId        The Id of the folder in which to place the newly created items. If null, items are created in their default folders.
   * @param   {MessageDisposition}    messageDisposition    Indicates the disposition mode for items of type EmailMessage. Required if items contains at least one EmailMessage instance.
   * @param   {SendInvitationsMode}   sendInvitationsMode   Indicates if and how invitations should be sent for items of type Appointment. Required if items contains at least one Appointment instance.
   * @return  {Promise<ServiceResponseCollection<ServiceResponse>>}                          A ServiceResponseCollection providing creation results for each of the specified items :Promise.
   */
  CreateItems(items: Item[], parentFolderId: FolderId, messageDisposition: MessageDisposition, sendInvitationsMode: SendInvitationsMode): Promise<ServiceResponseCollection<ServiceResponse>> {
    // All items have to be new.
    if (!items.every((item) => item.IsNew)) {
      throw new ServiceValidationException(Strings.CreateItemsDoesNotHandleExistingItems);
    }

    // Make sure that all items do *not* have unprocessed attachments.
    if (!items.every((item) => !item.HasUnprocessedAttachmentChanges())) {
      throw new ServiceValidationException(Strings.CreateItemsDoesNotAllowAttachments);
    }

    return this.InternalCreateItems(
      items,
      parentFolderId,
      messageDisposition,
      sendInvitationsMode,
      ServiceErrorHandling.ReturnErrors);
  }
  /**
   * @internal Deletes an item. Calling this method results in a call to EWS.
   *
   * @param   {ItemId}                    itemId                    The Id of the item to delete.
   * @param   {DeleteMode}                deleteMode                The deletion mode.
   * @param   {SendCancellationsMode}     sendCancellationsMode     Indicates whether cancellation messages should be sent. Required if the item Id represents an Appointment.
   * @param   {AffectedTaskOccurrence}    affectedTaskOccurrences   Indicates which instance of a recurring task should be deleted. Required if item Id represents a Task.
   */
  DeleteItem(itemId: ItemId, deleteMode: DeleteMode, sendCancellationsMode: SendCancellationsMode, affectedTaskOccurrences: AffectedTaskOccurrence): Promise<void>;
  /**
   * @internal Deletes an item. Calling this method results in a call to EWS.
   *
   * @param   {ItemId}                    itemId                    The Id of the item to delete.
   * @param   {DeleteMode}                deleteMode                The deletion mode.
   * @param   {SendCancellationsMode}     sendCancellationsMode     Indicates whether cancellation messages should be sent. Required if the item Id represents an Appointment.
   * @param   {AffectedTaskOccurrence}    affectedTaskOccurrences   Indicates which instance of a recurring task should be deleted. Required if item Id represents a Task.
   * @param   {boolean}                   suppressReadReceipts      Whether to suppress read receipts
   */
  DeleteItem(itemId: ItemId, deleteMode: DeleteMode, sendCancellationsMode: SendCancellationsMode, affectedTaskOccurrences: AffectedTaskOccurrence, suppressReadReceipts: boolean): Promise<void>;
  DeleteItem(itemId: ItemId, deleteMode: DeleteMode, sendCancellationsMode: SendCancellationsMode, affectedTaskOccurrences: AffectedTaskOccurrence, suppressReadReceipts: boolean = false): Promise<void> {
    EwsUtilities.ValidateParam(itemId, "itemId");

    return <any>this.InternalDeleteItems(
      [itemId],
      deleteMode,
      sendCancellationsMode,
      affectedTaskOccurrences,
      ServiceErrorHandling.ThrowOnError,
      suppressReadReceipts);
  }
  /**
   * Deletes multiple items in a single call to EWS.
   *
   * @param   {ItemId[]}                  itemIds                   The Ids of the items to delete.
   * @param   {DeleteMode}                deleteMode                The deletion mode.
   * @param   {SendCancellationsMode}     sendCancellationsMode     Indicates whether cancellation messages should be sent. Required if the item Id represents an Appointment.
   * @param   {AffectedTaskOccurrence}    affectedTaskOccurrences   Indicates which instance of a recurring task should be deleted. Required if item Id represents a Task.
   * @return  {Promise<ServiceResponseCollection<ServiceResponse>>}       A ServiceResponseCollection providing deletion results for each of the specified item Ids :Promise.
   */
  DeleteItems(itemIds: ItemId[], deleteMode: DeleteMode, sendCancellationsMode: SendCancellationsMode, affectedTaskOccurrences: AffectedTaskOccurrence): Promise<ServiceResponseCollection<ServiceResponse>>;
  /**
   * Deletes multiple items in a single call to EWS.
   *
   * @param   {ItemId[]}                  itemIds                   The Ids of the items to delete.
   * @param   {DeleteMode}                deleteMode                The deletion mode.
   * @param   {SendCancellationsMode}     sendCancellationsMode     Indicates whether cancellation messages should be sent. Required if the item Id represents an Appointment.
   * @param   {AffectedTaskOccurrence}    affectedTaskOccurrences   Indicates which instance of a recurring task should be deleted. Required if item Id represents a Task.
   * @param   {boolean}                   suppressReadReceipts      Whether to suppress read receipts
   * @return  {Promise<ServiceResponseCollection<ServiceRes