Added the elevated privileges sample (#38)

samples/react-sp-elevatedprivileges/README.md

@@ -0,0 +1,96 @@
+# Communicate using elevated privileges with SharePoint
+
+## Summary
+
+Sample SharePoint Framework client-side web part illustrating communication with SharePoint using elevated privileges through a custom Web API.
+
+![Sample web part showing orders retrieved from a custom Web API secured with Azure Active Directory](./assets/preview.png)
+
+## Applies to
+
+* [SharePoint Framework Developer Preview](http://dev.office.com/sharepoint/docs/spfx/sharepoint-framework-overview)
+* [Office 365 developer tenant](http://dev.office.com/sharepoint/docs/spfx/set-up-your-developer-tenant)
+
+## Solution
+
+Solution|Author(s)
+--------|---------
+react-sp-elevatedprivileges|Waldek Mastykarz (MVP, Rencore, @waldekm)
+
+## Version history
+
+Version|Date|Comments
+-------|----|--------
+1.0|October 12, 2016|Initial release
+
+## Disclaimer
+**THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.**
+
+---
+
+## Minimal Path to Awesome
+
+- clone this repo
+
+### Deploy custom Web API
+
+- in the Azure Management Portal at https://portal.azure.com create a new API App
+  - in the settings enable CORS for all origins using an `*`
+  - copy the URL of the API App
+- in your SharePoint site
+  - create a new list called **Tasks**
+  - navigate to https://yourtenant.sharepoint.com/_layouts/15/appregnew.aspx
+    - generate client ID and copy it
+    - generate client secret and copy it
+    - as the name use: **SPFx sample elevated privileges**
+    - as the URL use the URL of the Azure API App created previously
+    - as the domain use the host name of the Azure API App
+  - navigate to https://yourtenant.sharepoint.com/_layouts/15/appinv.aspx
+    - lookup the newly registered Add-in using the client ID you copied
+    - in the **Permissions** field past the following code:
+
+```xml
+<AppPermissionRequests AllowAppOnlyPolicy="true">
+  <AppPermissionRequest Scope="http://sharepoint/content/sitecollection/web/list" Right="Write" />
+</AppPermissionRequests>
+```
+
+- after confirming the changes, when prompted, select the previously created **Tasks** list 
+- from the **api** folder, in Visual Studio open the **pnp.api.elevatedprivileges.sln** file
+- in the web.config file
+  - update the value of the **clientId** setting with the previously copied client ID
+  - update the value of the **clientSecret** setting with the previously copied client secret
+  - update hte value of the **siteUrl** setting with the URL of your SharePoint site
+  - if you named your list other than **Tasks** update the value of the **listName** property with the name of your list
+- build the solution
+- deploy the **pnp.api.elevatedprivileges** project to the newly created API App
+- verify that you can access the API by navigating in your web browser to **https://your-api-app.azurewebsites.net/api/items**
+  - you should get an error that GET is not a supported method
+
+### Configure web part
+
+- in the command line
+  - change the working directory to the **webpart** folder
+  - run `npm i`
+- in your code editor open the **webpart** folder
+- in the **./src/webparts/createTask/components/CreateTask.tsx** file
+  - in line 76 replace the URL with the URL of your API App
+- in the command line execute `gulp serve`
+- add the web part to SharePoint workbench
+- enter the name of the new item and click the **Create** button
+  - verify that a new item with the name you specified has been created in the Tasks list
+
+## Features
+
+This project contains sample Web API using app-only permissions to create items in a specific SharePoint list, and a client-side web part connected to that API.
+
+This project illustrates the following concepts:
+- elevating user privileges for communicating with SharePoint through a custom Web API
+- connecting SharePoint Framework client-side web part to a custom Web API hosted in Azure
+- persisting state in React components
+- communicating state updates in React components to users
+- executing REST API web requests from React components
+- using Office UI Fabric React components in SharePoint Framework client-side web parts
+- using form controls in Rest components
+
+<img src="https://telemetry.sharepointpnp.com/sp-dev-fx-webparts/samples/react-sp-elevatedprivileges" />

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges.sln

@@ -0,0 +1,22 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "pnp.api.elevatedprivileges", "pnp.api.elevatedprivileges\pnp.api.elevatedprivileges.csproj", "{E9E8B537-849D-47B4-AA97-C3B7ED93227E}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E9E8B537-849D-47B4-AA97-C3B7ED93227E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E9E8B537-849D-47B4-AA97-C3B7ED93227E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E9E8B537-849D-47B4-AA97-C3B7ED93227E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E9E8B537-849D-47B4-AA97-C3B7ED93227E}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/App_Start/FilterConfig.cs

@@ -0,0 +1,9 @@
+using System.Web.Mvc;
+
+namespace pnp.api.elevatedprivileges {
+    public class FilterConfig {
+        public static void RegisterGlobalFilters(GlobalFilterCollection filters) {
+            filters.Add(new HandleErrorAttribute());
+        }
+    }
+}

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/App_Start/WebApiConfig.cs

@@ -0,0 +1,15 @@
+using System.Web.Http;
+
+namespace pnp.api.elevatedprivileges {
+    public static class WebApiConfig {
+        public static void Register(HttpConfiguration config) {
+            config.MapHttpAttributeRoutes();
+
+            config.Routes.MapHttpRoute(
+                name: "DefaultApi",
+                routeTemplate: "api/{controller}/{id}",
+                defaults: new { id = RouteParameter.Optional }
+            );
+        }
+    }
+}

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/Controllers/ItemsController.cs

@@ -0,0 +1,31 @@
+using Microsoft.SharePoint.Client;
+using OfficeDevPnP.Core;
+using System;
+using System.Configuration;
+using System.Net.Http;
+using System.Web.Http;
+
+namespace pnp.api.elevatedprivileges.Controllers {
+    public class ItemsController : ApiController {
+        // POST api/values
+        public HttpResponseMessage Post([FromBody]dynamic data) {
+            try {
+                AuthenticationManager authMgr = new AuthenticationManager();
+                using (ClientContext ctx = authMgr.GetAppOnlyAuthenticatedContext(
+                    ConfigurationManager.AppSettings["siteUrl"],
+                    ConfigurationManager.AppSettings["clientId"],
+                    ConfigurationManager.AppSettings["clientSecret"])) {
+                    var list = ctx.Web.Lists.GetByTitle(ConfigurationManager.AppSettings["listName"]);
+                    var item = list.AddItem(new ListItemCreationInformation());
+                    item["Title"] = data.title.ToString();
+                    item.Update();
+                    ctx.ExecuteQuery();
+                    return new HttpResponseMessage(System.Net.HttpStatusCode.Created);
+                }
+            }
+            catch {
+                return new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError);
+            }
+        }
+    }
+}

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/Filters/SharePointContextFilterAttribute.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Web.Mvc;
+
+namespace pnp.api.elevatedprivileges
+{
+    /// <summary>
+    /// SharePoint action filter attribute.
+    /// </summary>
+    public class SharePointContextFilterAttribute : ActionFilterAttribute
+    {
+        public override void OnActionExecuting(ActionExecutingContext filterContext)
+        {
+            if (filterContext == null)
+            {
+                throw new ArgumentNullException("filterContext");
+            }
+
+            Uri redirectUrl;
+            switch (SharePointContextProvider.CheckRedirectionStatus(filterContext.HttpContext, out redirectUrl))
+            {
+                case RedirectionStatus.Ok:
+                    return;
+                case RedirectionStatus.ShouldRedirect:
+                    filterContext.Result = new RedirectResult(redirectUrl.AbsoluteUri);
+                    break;
+                case RedirectionStatus.CanNotRedirect:
+                    filterContext.Result = new ViewResult { ViewName = "Error" };
+                    break;
+            }
+        }
+    }
+}

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/Global.asax

@@ -0,0 +1 @@
+<%@ Application Codebehind="Global.asax.cs" Inherits="pnp.api.elevatedprivileges.WebApiApplication" Language="C#" %>

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/Global.asax.cs

@@ -0,0 +1,12 @@
+using System.Web.Http;
+using System.Web.Mvc;
+
+namespace pnp.api.elevatedprivileges {
+    public class WebApiApplication : System.Web.HttpApplication {
+        protected void Application_Start() {
+            AreaRegistration.RegisterAllAreas();
+            GlobalConfiguration.Configure(WebApiConfig.Register);
+            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
+        }
+    }
+}

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/Properties/AssemblyInfo.cs

@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("pnp.api.elevatedprivileges")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("pnp.api.elevatedprivileges")]
+[assembly: AssemblyCopyright("Copyright ©  2016")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("eff521b1-a9db-4318-b4a8-800a497de4d2")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/SharePointContext.cs

@@ -0,0 +1,924 @@
+using Microsoft.IdentityModel.S2S.Protocols.OAuth2;
+using Microsoft.IdentityModel.Tokens;
+using Microsoft.SharePoint.Client;
+using System;
+using System.Net;
+using System.Security.Principal;
+using System.Web;
+using System.Web.Configuration;
+
+namespace pnp.api.elevatedprivileges
+{
+    /// <summary>
+    /// Encapsulates all the information from SharePoint.
+    /// </summary>
+    public abstract class SharePointContext
+    {
+        public const string SPHostUrlKey = "SPHostUrl";
+        public const string SPAppWebUrlKey = "SPAppWebUrl";
+        public const string SPLanguageKey = "SPLanguage";
+        public const string SPClientTagKey = "SPClientTag";
+        public const string SPProductNumberKey = "SPProductNumber";
+
+        protected static readonly TimeSpan AccessTokenLifetimeTolerance = TimeSpan.FromMinutes(5.0);
+
+        private readonly Uri spHostUrl;
+        private readonly Uri spAppWebUrl;
+        private readonly string spLanguage;
+        private readonly string spClientTag;
+        private readonly string spProductNumber;
+
+        // <AccessTokenString, UtcExpiresOn>
+        protected Tuple<string, DateTime> userAccessTokenForSPHost;
+        protected Tuple<string, DateTime> userAccessTokenForSPAppWeb;
+        protected Tuple<string, DateTime> appOnlyAccessTokenForSPHost;
+        protected Tuple<string, DateTime> appOnlyAccessTokenForSPAppWeb;
+
+        /// <summary>
+        /// Gets the SharePoint host url from QueryString of the specified HTTP request.
+        /// </summary>
+        /// <param name="httpRequest">The specified HTTP request.</param>
+        /// <returns>The SharePoint host url. Returns <c>null</c> if the HTTP request doesn't contain the SharePoint host url.</returns>
+        public static Uri GetSPHostUrl(HttpRequestBase httpRequest)
+        {
+            if (httpRequest == null)
+            {
+                throw new ArgumentNullException("httpRequest");
+            }
+
+            string spHostUrlString = TokenHelper.EnsureTrailingSlash(httpRequest.QueryString[SPHostUrlKey]);
+            Uri spHostUrl;
+            if (Uri.TryCreate(spHostUrlString, UriKind.Absolute, out spHostUrl) &&
+                (spHostUrl.Scheme == Uri.UriSchemeHttp || spHostUrl.Scheme == Uri.UriSchemeHttps))
+            {
+                return spHostUrl;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the SharePoint host url from QueryString of the specified HTTP request.
+        /// </summary>
+        /// <param name="httpRequest">The specified HTTP request.</param>
+        /// <returns>The SharePoint host url. Returns <c>null</c> if the HTTP request doesn't contain the SharePoint host url.</returns>
+        public static Uri GetSPHostUrl(HttpRequest httpRequest)
+        {
+            return GetSPHostUrl(new HttpRequestWrapper(httpRequest));
+        }
+
+        /// <summary>
+        /// The SharePoint host url.
+        /// </summary>
+        public Uri SPHostUrl
+        {
+            get { return this.spHostUrl; }
+        }
+
+        /// <summary>
+        /// The SharePoint app web url.
+        /// </summary>
+        public Uri SPAppWebUrl
+        {
+            get { return this.spAppWebUrl; }
+        }
+
+        /// <summary>
+        /// The SharePoint language.
+        /// </summary>
+        public string SPLanguage
+        {
+            get { return this.spLanguage; }
+        }
+
+        /// <summary>
+        /// The SharePoint client tag.
+        /// </summary>
+        public string SPClientTag
+        {
+            get { return this.spClientTag; }
+        }
+
+        /// <summary>
+        /// The SharePoint product number.
+        /// </summary>
+        public string SPProductNumber
+        {
+            get { return this.spProductNumber; }
+        }
+
+        /// <summary>
+        /// The user access token for the SharePoint host.
+        /// </summary>
+        public abstract string UserAccessTokenForSPHost
+        {
+            get;
+        }
+
+        /// <summary>
+        /// The user access token for the SharePoint app web.
+        /// </summary>
+        public abstract string UserAccessTokenForSPAppWeb
+        {
+            get;
+        }
+
+        /// <summary>
+        /// The app only access token for the SharePoint host.
+        /// </summary>
+        public abstract string AppOnlyAccessTokenForSPHost
+        {
+            get;
+        }
+
+        /// <summary>
+        /// The app only access token for the SharePoint app web.
+        /// </summary>
+        public abstract string AppOnlyAccessTokenForSPAppWeb
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="spHostUrl">The SharePoint host url.</param>
+        /// <param name="spAppWebUrl">The SharePoint app web url.</param>
+        /// <param name="spLanguage">The SharePoint language.</param>
+        /// <param name="spClientTag">The SharePoint client tag.</param>
+        /// <param name="spProductNumber">The SharePoint product number.</param>
+        protected SharePointContext(Uri spHostUrl, Uri spAppWebUrl, string spLanguage, string spClientTag, string spProductNumber)
+        {
+            if (spHostUrl == null)
+            {
+                throw new ArgumentNullException("spHostUrl");
+            }
+
+            if (string.IsNullOrEmpty(spLanguage))
+            {
+                throw new ArgumentNullException("spLanguage");
+            }
+
+            if (string.IsNullOrEmpty(spClientTag))
+            {
+                throw new ArgumentNullException("spClientTag");
+            }
+
+            if (string.IsNullOrEmpty(spProductNumber))
+            {
+                throw new ArgumentNullException("spProductNumber");
+            }
+
+            this.spHostUrl = spHostUrl;
+            this.spAppWebUrl = spAppWebUrl;
+            this.spLanguage = spLanguage;
+            this.spClientTag = spClientTag;
+            this.spProductNumber = spProductNumber;
+        }
+
+        /// <summary>
+        /// Creates a user ClientContext for the SharePoint host.
+        /// </summary>
+        /// <returns>A ClientContext instance.</returns>
+        public ClientContext CreateUserClientContextForSPHost()
+        {
+            return CreateClientContext(this.SPHostUrl, this.UserAccessTokenForSPHost);
+        }
+
+        /// <summary>
+        /// Creates a user ClientContext for the SharePoint app web.
+        /// </summary>
+        /// <returns>A ClientContext instance.</returns>
+        public ClientContext CreateUserClientContextForSPAppWeb()
+        {
+            return CreateClientContext(this.SPAppWebUrl, this.UserAccessTokenForSPAppWeb);
+        }
+
+        /// <summary>
+        /// Creates app only ClientContext for the SharePoint host.
+        /// </summary>
+        /// <returns>A ClientContext instance.</returns>
+        public ClientContext CreateAppOnlyClientContextForSPHost()
+        {
+            return CreateClientContext(this.SPHostUrl, this.AppOnlyAccessTokenForSPHost);
+        }
+
+        /// <summary>
+        /// Creates an app only ClientContext for the SharePoint app web.
+        /// </summary>
+        /// <returns>A ClientContext instance.</returns>
+        public ClientContext CreateAppOnlyClientContextForSPAppWeb()
+        {
+            return CreateClientContext(this.SPAppWebUrl, this.AppOnlyAccessTokenForSPAppWeb);
+        }
+
+        /// <summary>
+        /// Gets the database connection string from SharePoint for autohosted app.
+        /// This method is deprecated because the autohosted option is no longer available.
+        /// </summary>
+        [ObsoleteAttribute("This method is deprecated because the autohosted option is no longer available.", true)]
+        public string GetDatabaseConnectionString()
+        {
+            throw new NotSupportedException("This method is deprecated because the autohosted option is no longer available.");
+        }
+
+        /// <summary>
+        /// Determines if the specified access token is valid.
+        /// It considers an access token as not valid if it is null, or it has expired.
+        /// </summary>
+        /// <param name="accessToken">The access token to verify.</param>
+        /// <returns>True if the access token is valid.</returns>
+        protected static bool IsAccessTokenValid(Tuple<string, DateTime> accessToken)
+        {
+            return accessToken != null &&
+                   !string.IsNullOrEmpty(accessToken.Item1) &&
+                   accessToken.Item2 > DateTime.UtcNow;
+        }
+
+        /// <summary>
+        /// Creates a ClientContext with the specified SharePoint site url and the access token.
+        /// </summary>
+        /// <param name="spSiteUrl">The site url.</param>
+        /// <param name="accessToken">The access token.</param>
+        /// <returns>A ClientContext instance.</returns>
+        private static ClientContext CreateClientContext(Uri spSiteUrl, string accessToken)
+        {
+            if (spSiteUrl != null && !string.IsNullOrEmpty(accessToken))
+            {
+                return TokenHelper.GetClientContextWithAccessToken(spSiteUrl.AbsoluteUri, accessToken);
+            }
+
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Redirection status.
+    /// </summary>
+    public enum RedirectionStatus
+    {
+        Ok,
+        ShouldRedirect,
+        CanNotRedirect
+    }
+
+    /// <summary>
+    /// Provides SharePointContext instances.
+    /// </summary>
+    public abstract class SharePointContextProvider
+    {
+        private static SharePointContextProvider current;
+
+        /// <summary>
+        /// The current SharePointContextProvider instance.
+        /// </summary>
+        public static SharePointContextProvider Current
+        {
+            get { return SharePointContextProvider.current; }
+        }
+
+        /// <summary>
+        /// Initializes the default SharePointContextProvider instance.
+        /// </summary>
+        static SharePointContextProvider()
+        {
+            if (!TokenHelper.IsHighTrustApp())
+            {
+                SharePointContextProvider.current = new SharePointAcsContextProvider();
+            }
+            else
+            {
+                SharePointContextProvider.current = new SharePointHighTrustContextProvider();
+            }
+        }
+
+        /// <summary>
+        /// Registers the specified SharePointContextProvider instance as current.
+        /// It should be called by Application_Start() in Global.asax.
+        /// </summary>
+        /// <param name="provider">The SharePointContextProvider to be set as current.</param>
+        public static void Register(SharePointContextProvider provider)
+        {
+            if (provider == null)
+            {
+                throw new ArgumentNullException("provider");
+            }
+
+            SharePointContextProvider.current = provider;
+        }
+
+        /// <summary>
+        /// Checks if it is necessary to redirect to SharePoint for user to authenticate.
+        /// </summary>
+        /// <param name="httpContext">The HTTP context.</param>
+        /// <param name="redirectUrl">The redirect url to SharePoint if the status is ShouldRedirect. <c>Null</c> if the status is Ok or CanNotRedirect.</param>
+        /// <returns>Redirection status.</returns>
+        public static RedirectionStatus CheckRedirectionStatus(HttpContextBase httpContext, out Uri redirectUrl)
+        {
+            if (httpContext == null)
+            {
+                throw new ArgumentNullException("httpContext");
+            }
+
+            redirectUrl = null;
+            bool contextTokenExpired = false;
+
+            try
+            {
+                if (SharePointContextProvider.Current.GetSharePointContext(httpContext) != null)
+                {
+                    return RedirectionStatus.Ok;
+                }
+            }
+            catch (SecurityTokenExpiredException)
+            {
+                contextTokenExpired = true;
+            }
+
+            const string SPHasRedirectedToSharePointKey = "SPHasRedirectedToSharePoint";
+
+            if (!string.IsNullOrEmpty(httpContext.Request.QueryString[SPHasRedirectedToSharePointKey]) && !contextTokenExpired)
+            {
+                return RedirectionStatus.CanNotRedirect;
+            }
+
+            Uri spHostUrl = SharePointContext.GetSPHostUrl(httpContext.Request);
+
+            if (spHostUrl == null)
+            {
+                return RedirectionStatus.CanNotRedirect;
+            }
+
+            if (StringComparer.OrdinalIgnoreCase.Equals(httpContext.Request.HttpMethod, "POST"))
+            {
+                return RedirectionStatus.CanNotRedirect;
+            }
+
+            Uri requestUrl = httpContext.Request.Url;
+
+            var queryNameValueCollection = HttpUtility.ParseQueryString(requestUrl.Query);
+
+            // Removes the values that are included in {StandardTokens}, as {StandardTokens} will be inserted at the beginning of the query string.
+            queryNameValueCollection.Remove(SharePointContext.SPHostUrlKey);
+            queryNameValueCollection.Remove(SharePointContext.SPAppWebUrlKey);
+            queryNameValueCollection.Remove(SharePointContext.SPLanguageKey);
+            queryNameValueCollection.Remove(SharePointContext.SPClientTagKey);
+            queryNameValueCollection.Remove(SharePointContext.SPProductNumberKey);
+
+            // Adds SPHasRedirectedToSharePoint=1.
+            queryNameValueCollection.Add(SPHasRedirectedToSharePointKey, "1");
+
+            UriBuilder returnUrlBuilder = new UriBuilder(requestUrl);
+            returnUrlBuilder.Query = queryNameValueCollection.ToString();
+
+            // Inserts StandardTokens.
+            const string StandardTokens = "{StandardTokens}";
+            string returnUrlString = returnUrlBuilder.Uri.AbsoluteUri;
+            returnUrlString = returnUrlString.Insert(returnUrlString.IndexOf("?") + 1, StandardTokens + "&");
+
+            // Constructs redirect url.
+            string redirectUrlString = TokenHelper.GetAppContextTokenRequestUrl(spHostUrl.AbsoluteUri, Uri.EscapeDataString(returnUrlString));
+
+            redirectUrl = new Uri(redirectUrlString, UriKind.Absolute);
+
+            return RedirectionStatus.ShouldRedirect;
+        }
+
+        /// <summary>
+        /// Checks if it is necessary to redirect to SharePoint for user to authenticate.
+        /// </summary>
+        /// <param name="httpContext">The HTTP context.</param>
+        /// <param name="redirectUrl">The redirect url to SharePoint if the status is ShouldRedirect. <c>Null</c> if the status is Ok or CanNotRedirect.</param>
+        /// <returns>Redirection status.</returns>
+        public static RedirectionStatus CheckRedirectionStatus(HttpContext httpContext, out Uri redirectUrl)
+        {
+            return CheckRedirectionStatus(new HttpContextWrapper(httpContext), out redirectUrl);
+        }
+
+        /// <summary>
+        /// Creates a SharePointContext instance with the specified HTTP request.
+        /// </summary>
+        /// <param name="httpRequest">The HTTP request.</param>
+        /// <returns>The SharePointContext instance. Returns <c>null</c> if errors occur.</returns>
+        public SharePointContext CreateSharePointContext(HttpRequestBase httpRequest)
+        {
+            if (httpRequest == null)
+            {
+                throw new ArgumentNullException("httpRequest");
+            }
+
+            // SPHostUrl
+            Uri spHostUrl = SharePointContext.GetSPHostUrl(httpRequest);
+            if (spHostUrl == null)
+            {
+                return null;
+            }
+
+            // SPAppWebUrl
+            string spAppWebUrlString = TokenHelper.EnsureTrailingSlash(httpRequest.QueryString[SharePointContext.SPAppWebUrlKey]);
+            Uri spAppWebUrl;
+            if (!Uri.TryCreate(spAppWebUrlString, UriKind.Absolute, out spAppWebUrl) ||
+                !(spAppWebUrl.Scheme == Uri.UriSchemeHttp || spAppWebUrl.Scheme == Uri.UriSchemeHttps))
+            {
+                spAppWebUrl = null;
+            }
+
+            // SPLanguage
+            string spLanguage = httpRequest.QueryString[SharePointContext.SPLanguageKey];
+            if (string.IsNullOrEmpty(spLanguage))
+            {
+                return null;
+            }
+
+            // SPClientTag
+            string spClientTag = httpRequest.QueryString[SharePointContext.SPClientTagKey];
+            if (string.IsNullOrEmpty(spClientTag))
+            {
+                return null;
+            }
+
+            // SPProductNumber
+            string spProductNumber = httpRequest.QueryString[SharePointContext.SPProductNumberKey];
+            if (string.IsNullOrEmpty(spProductNumber))
+            {
+                return null;
+            }
+
+            return CreateSharePointContext(spHostUrl, spAppWebUrl, spLanguage, spClientTag, spProductNumber, httpRequest);
+        }
+
+        /// <summary>
+        /// Creates a SharePointContext instance with the specified HTTP request.
+        /// </summary>
+        /// <param name="httpRequest">The HTTP request.</param>
+        /// <returns>The SharePointContext instance. Returns <c>null</c> if errors occur.</returns>
+        public SharePointContext CreateSharePointContext(HttpRequest httpRequest)
+        {
+            return CreateSharePointContext(new HttpRequestWrapper(httpRequest));
+        }
+
+        /// <summary>
+        /// Gets a SharePointContext instance associated with the specified HTTP context.
+        /// </summary>
+        /// <param name="httpContext">The HTTP context.</param>
+        /// <returns>The SharePointContext instance. Returns <c>null</c> if not found and a new instance can't be created.</returns>
+        public SharePointContext GetSharePointContext(HttpContextBase httpContext)
+        {
+            if (httpContext == null)
+            {
+                throw new ArgumentNullException("httpContext");
+            }
+
+            Uri spHostUrl = SharePointContext.GetSPHostUrl(httpContext.Request);
+            if (spHostUrl == null)
+            {
+                return null;
+            }
+
+            SharePointContext spContext = LoadSharePointContext(httpContext);
+
+            if (spContext == null || !ValidateSharePointContext(spContext, httpContext))
+            {
+                spContext = CreateSharePointContext(httpContext.Request);
+
+                if (spContext != null)
+                {
+                    SaveSharePointContext(spContext, httpContext);
+                }
+            }
+
+            return spContext;
+        }
+
+        /// <summary>
+        /// Gets a SharePointContext instance associated with the specified HTTP context.
+        /// </summary>
+        /// <param name="httpContext">The HTTP context.</param>
+        /// <returns>The SharePointContext instance. Returns <c>null</c> if not found and a new instance can't be created.</returns>
+        public SharePointContext GetSharePointContext(HttpContext httpContext)
+        {
+            return GetSharePointContext(new HttpContextWrapper(httpContext));
+        }
+
+        /// <summary>
+        /// Creates a SharePointContext instance.
+        /// </summary>
+        /// <param name="spHostUrl">The SharePoint host url.</param>
+        /// <param name="spAppWebUrl">The SharePoint app web url.</param>
+        /// <param name="spLanguage">The SharePoint language.</param>
+        /// <param name="spClientTag">The SharePoint client tag.</param>
+        /// <param name="spProductNumber">The SharePoint product number.</param>
+        /// <param name="httpRequest">The HTTP request.</param>
+        /// <returns>The SharePointContext instance. Returns <c>null</c> if errors occur.</returns>
+        protected abstract SharePointContext CreateSharePointContext(Uri spHostUrl, Uri spAppWebUrl, string spLanguage, string spClientTag, string spProductNumber, HttpRequestBase httpRequest);
+
+        /// <summary>
+        /// Validates if the given SharePointContext can be used with the specified HTTP context.
+        /// </summary>
+        /// <param name="spContext">The SharePointContext.</param>
+        /// <param name="httpContext">The HTTP context.</param>
+        /// <returns>True if the given SharePointContext can be used with the specified HTTP context.</returns>
+        protected abstract bool ValidateSharePointContext(SharePointContext spContext, HttpContextBase httpContext);
+
+        /// <summary>
+        /// Loads the SharePointContext instance associated with the specified HTTP context.
+        /// </summary>
+        /// <param name="httpContext">The HTTP context.</param>
+        /// <returns>The SharePointContext instance. Returns <c>null</c> if not found.</returns>
+        protected abstract SharePointContext LoadSharePointContext(HttpContextBase httpContext);
+
+        /// <summary>
+        /// Saves the specified SharePointContext instance associated with the specified HTTP context.
+        /// <c>null</c> is accepted for clearing the SharePointContext instance associated with the HTTP context.
+        /// </summary>
+        /// <param name="spContext">The SharePointContext instance to be saved, or <c>null</c>.</param>
+        /// <param name="httpContext">The HTTP context.</param>
+        protected abstract void SaveSharePointContext(SharePointContext spContext, HttpContextBase httpContext);
+    }
+
+    #region ACS
+
+    /// <summary>
+    /// Encapsulates all the information from SharePoint in ACS mode.
+    /// </summary>
+    public class SharePointAcsContext : SharePointContext
+    {
+        private readonly string contextToken;
+        private readonly SharePointContextToken contextTokenObj;
+
+        /// <summary>
+        /// The context token.
+        /// </summary>
+        public string ContextToken
+        {
+            get { return this.contextTokenObj.ValidTo > DateTime.UtcNow ? this.contextToken : null; }
+        }
+
+        /// <summary>
+        /// The context token's "CacheKey" claim.
+        /// </summary>
+        public string CacheKey
+        {
+            get { return this.contextTokenObj.ValidTo > DateTime.UtcNow ? this.contextTokenObj.CacheKey : null; }
+        }
+
+        /// <summary>
+        /// The context token's "refreshtoken" claim.
+        /// </summary>
+        public string RefreshToken
+        {
+            get { return this.contextTokenObj.ValidTo > DateTime.UtcNow ? this.contextTokenObj.RefreshToken : null; }
+        }
+
+        public override string UserAccessTokenForSPHost
+        {
+            get
+            {
+                return GetAccessTokenString(ref this.userAccessTokenForSPHost,
+                                            () => TokenHelper.GetAccessToken(this.contextTokenObj, this.SPHostUrl.Authority));
+            }
+        }
+
+        public override string UserAccessTokenForSPAppWeb
+        {
+            get
+            {
+                if (this.SPAppWebUrl == null)
+                {
+                    return null;
+                }
+
+                return GetAccessTokenString(ref this.userAccessTokenForSPAppWeb,
+                                            () => TokenHelper.GetAccessToken(this.contextTokenObj, this.SPAppWebUrl.Authority));
+            }
+        }
+
+        public override string AppOnlyAccessTokenForSPHost
+        {
+            get
+            {
+                return GetAccessTokenString(ref this.appOnlyAccessTokenForSPHost,
+                                            () => TokenHelper.GetAppOnlyAccessToken(TokenHelper.SharePointPrincipal, this.SPHostUrl.Authority, TokenHelper.GetRealmFromTargetUrl(this.SPHostUrl)));
+            }
+        }
+
+        public override string AppOnlyAccessTokenForSPAppWeb
+        {
+            get
+            {
+                if (this.SPAppWebUrl == null)
+                {
+                    return null;
+                }
+
+                return GetAccessTokenString(ref this.appOnlyAccessTokenForSPAppWeb,
+                                            () => TokenHelper.GetAppOnlyAccessToken(TokenHelper.SharePointPrincipal, this.SPAppWebUrl.Authority, TokenHelper.GetRealmFromTargetUrl(this.SPAppWebUrl)));
+            }
+        }
+
+        public SharePointAcsContext(Uri spHostUrl, Uri spAppWebUrl, string spLanguage, string spClientTag, string spProductNumber, string contextToken, SharePointContextToken contextTokenObj)
+            : base(spHostUrl, spAppWebUrl, spLanguage, spClientTag, spProductNumber)
+        {
+            if (string.IsNullOrEmpty(contextToken))
+            {
+                throw new ArgumentNullException("contextToken");
+            }
+
+            if (contextTokenObj == null)
+            {
+                throw new ArgumentNullException("contextTokenObj");
+            }
+
+            this.contextToken = contextToken;
+            this.contextTokenObj = contextTokenObj;
+        }
+
+        /// <summary>
+        /// Ensures the access token is valid and returns it.
+        /// </summary>
+        /// <param name="accessToken">The access token to verify.</param>
+        /// <param name="tokenRenewalHandler">The token renewal handler.</param>
+        /// <returns>The access token string.</returns>
+        private static string GetAccessTokenString(ref Tuple<string, DateTime> accessToken, Func<OAuth2AccessTokenResponse> tokenRenewalHandler)
+        {
+            RenewAccessTokenIfNeeded(ref accessToken, tokenRenewalHandler);
+
+            return IsAccessTokenValid(accessToken) ? accessToken.Item1 : null;
+        }
+
+        /// <summary>
+        /// Renews the access token if it is not valid.
+        /// </summary>
+        /// <param name="accessToken">The access token to renew.</param>
+        /// <param name="tokenRenewalHandler">The token renewal handler.</param>
+        private static void RenewAccessTokenIfNeeded(ref Tuple<string, DateTime> accessToken, Func<OAuth2AccessTokenResponse> tokenRenewalHandler)
+        {
+            if (IsAccessTokenValid(accessToken))
+            {
+                return;
+            }
+
+            try
+            {
+                OAuth2AccessTokenResponse oAuth2AccessTokenResponse = tokenRenewalHandler();
+
+                DateTime expiresOn = oAuth2AccessTokenResponse.ExpiresOn;
+
+                if ((expiresOn - oAuth2AccessTokenResponse.NotBefore) > AccessTokenLifetimeTolerance)
+                {
+                    // Make the access token get renewed a bit earlier than the time when it expires
+                    // so that the calls to SharePoint with it will have enough time to complete successfully.
+                    expiresOn -= AccessTokenLifetimeTolerance;
+                }
+
+                accessToken = Tuple.Create(oAuth2AccessTokenResponse.AccessToken, expiresOn);
+            }
+            catch (WebException)
+            {
+            }
+        }
+    }
+
+    /// <summary>
+    /// Default provider for SharePointAcsContext.
+    /// </summary>
+    public class SharePointAcsContextProvider : SharePointContextProvider
+    {
+        private const string SPContextKey = "SPContext";
+        private const string SPCacheKeyKey = "SPCacheKey";
+
+        protected override SharePointContext CreateSharePointContext(Uri spHostUrl, Uri spAppWebUrl, string spLanguage, string spClientTag, string spProductNumber, HttpRequestBase httpRequest)
+        {
+            string contextTokenString = TokenHelper.GetContextTokenFromRequest(httpRequest);
+            if (string.IsNullOrEmpty(contextTokenString))
+            {
+                return null;
+            }
+
+            SharePointContextToken contextToken = null;
+            try
+            {
+                contextToken = TokenHelper.ReadAndValidateContextToken(contextTokenString, httpRequest.Url.Authority);
+            }
+            catch (WebException)
+            {
+                return null;
+            }
+            catch (AudienceUriValidationFailedException)
+            {
+                return null;
+            }
+
+            return new SharePointAcsContext(spHostUrl, spAppWebUrl, spLanguage, spClientTag, spProductNumber, contextTokenString, contextToken);
+        }
+
+        protected override bool ValidateSharePointContext(SharePointContext spContext, HttpContextBase httpContext)
+        {
+            SharePointAcsContext spAcsContext = spContext as SharePointAcsContext;
+
+            if (spAcsContext != null)
+            {
+                Uri spHostUrl = SharePointContext.GetSPHostUrl(httpContext.Request);
+                string contextToken = TokenHelper.GetContextTokenFromRequest(httpContext.Request);
+                HttpCookie spCacheKeyCookie = httpContext.Request.Cookies[SPCacheKeyKey];
+                string spCacheKey = spCacheKeyCookie != null ? spCacheKeyCookie.Value : null;
+
+                return spHostUrl == spAcsContext.SPHostUrl &&
+                       !string.IsNullOrEmpty(spAcsContext.CacheKey) &&
+                       spCacheKey == spAcsContext.CacheKey &&
+                       !string.IsNullOrEmpty(spAcsContext.ContextToken) &&
+                       (string.IsNullOrEmpty(contextToken) || contextToken == spAcsContext.ContextToken);
+            }
+
+            return false;
+        }
+
+        protected override SharePointContext LoadSharePointContext(HttpContextBase httpContext)
+        {
+            return httpContext.Session[SPContextKey] as SharePointAcsContext;
+        }
+
+        protected override void SaveSharePointContext(SharePointContext spContext, HttpContextBase httpContext)
+        {
+            SharePointAcsContext spAcsContext = spContext as SharePointAcsContext;
+
+            if (spAcsContext != null)
+            {
+                HttpCookie spCacheKeyCookie = new HttpCookie(SPCacheKeyKey)
+                {
+                    Value = spAcsContext.CacheKey,
+                    Secure = true,
+                    HttpOnly = true
+                };
+
+                httpContext.Response.AppendCookie(spCacheKeyCookie);
+            }
+
+            httpContext.Session[SPContextKey] = spAcsContext;
+        }
+    }
+
+    #endregion ACS
+
+    #region HighTrust
+
+    /// <summary>
+    /// Encapsulates all the information from SharePoint in HighTrust mode.
+    /// </summary>
+    public class SharePointHighTrustContext : SharePointContext
+    {
+        private readonly WindowsIdentity logonUserIdentity;
+
+        /// <summary>
+        /// The Windows identity for the current user.
+        /// </summary>
+        public WindowsIdentity LogonUserIdentity
+        {
+            get { return this.logonUserIdentity; }
+        }
+
+        public override string UserAccessTokenForSPHost
+        {
+            get
+            {
+                return GetAccessTokenString(ref this.userAccessTokenForSPHost,
+                                            () => TokenHelper.GetS2SAccessTokenWithWindowsIdentity(this.SPHostUrl, this.LogonUserIdentity));
+            }
+        }
+
+        public override string UserAccessTokenForSPAppWeb
+        {
+            get
+            {
+                if (this.SPAppWebUrl == null)
+                {
+                    return null;
+                }
+
+                return GetAccessTokenString(ref this.userAccessTokenForSPAppWeb,
+                                            () => TokenHelper.GetS2SAccessTokenWithWindowsIdentity(this.SPAppWebUrl, this.LogonUserIdentity));
+            }
+        }
+
+        public override string AppOnlyAccessTokenForSPHost
+        {
+            get
+            {
+                return GetAccessTokenString(ref this.appOnlyAccessTokenForSPHost,
+                                            () => TokenHelper.GetS2SAccessTokenWithWindowsIdentity(this.SPHostUrl, null));
+            }
+        }
+
+        public override string AppOnlyAccessTokenForSPAppWeb
+        {
+            get
+            {
+                if (this.SPAppWebUrl == null)
+                {
+                    return null;
+                }
+
+                return GetAccessTokenString(ref this.appOnlyAccessTokenForSPAppWeb,
+                                            () => TokenHelper.GetS2SAccessTokenWithWindowsIdentity(this.SPAppWebUrl, null));
+            }
+        }
+
+        public SharePointHighTrustContext(Uri spHostUrl, Uri spAppWebUrl, string spLanguage, string spClientTag, string spProductNumber, WindowsIdentity logonUserIdentity)
+            : base(spHostUrl, spAppWebUrl, spLanguage, spClientTag, spProductNumber)
+        {
+            if (logonUserIdentity == null)
+            {
+                throw new ArgumentNullException("logonUserIdentity");
+            }
+
+            this.logonUserIdentity = logonUserIdentity;
+        }
+
+        /// <summary>
+        /// Ensures the access token is valid and returns it.
+        /// </summary>
+        /// <param name="accessToken">The access token to verify.</param>
+        /// <param name="tokenRenewalHandler">The token renewal handler.</param>
+        /// <returns>The access token string.</returns>
+        private static string GetAccessTokenString(ref Tuple<string, DateTime> accessToken, Func<string> tokenRenewalHandler)
+        {
+            RenewAccessTokenIfNeeded(ref accessToken, tokenRenewalHandler);
+
+            return IsAccessTokenValid(accessToken) ? accessToken.Item1 : null;
+        }
+
+        /// <summary>
+        /// Renews the access token if it is not valid.
+        /// </summary>
+        /// <param name="accessToken">The access token to renew.</param>
+        /// <param name="tokenRenewalHandler">The token renewal handler.</param>
+        private static void RenewAccessTokenIfNeeded(ref Tuple<string, DateTime> accessToken, Func<string> tokenRenewalHandler)
+        {
+            if (IsAccessTokenValid(accessToken))
+            {
+                return;
+            }
+
+            DateTime expiresOn = DateTime.UtcNow.Add(TokenHelper.HighTrustAccessTokenLifetime);
+
+            if (TokenHelper.HighTrustAccessTokenLifetime > AccessTokenLifetimeTolerance)
+            {
+                // Make the access token get renewed a bit earlier than the time when it expires
+                // so that the calls to SharePoint with it will have enough time to complete successfully.
+                expiresOn -= AccessTokenLifetimeTolerance;
+            }
+
+            accessToken = Tuple.Create(tokenRenewalHandler(), expiresOn);
+        }
+    }
+
+    /// <summary>
+    /// Default provider for SharePointHighTrustContext.
+    /// </summary>
+    public class SharePointHighTrustContextProvider : SharePointContextProvider
+    {
+        private const string SPContextKey = "SPContext";
+
+        protected override SharePointContext CreateSharePointContext(Uri spHostUrl, Uri spAppWebUrl, string spLanguage, string spClientTag, string spProductNumber, HttpRequestBase httpRequest)
+        {
+            WindowsIdentity logonUserIdentity = httpRequest.LogonUserIdentity;
+            if (logonUserIdentity == null || !logonUserIdentity.IsAuthenticated || logonUserIdentity.IsGuest || logonUserIdentity.User == null)
+            {
+                return null;
+            }
+
+            return new SharePointHighTrustContext(spHostUrl, spAppWebUrl, spLanguage, spClientTag, spProductNumber, logonUserIdentity);
+        }
+
+        protected override bool ValidateSharePointContext(SharePointContext spContext, HttpContextBase httpContext)
+        {
+            SharePointHighTrustContext spHighTrustContext = spContext as SharePointHighTrustContext;
+
+            if (spHighTrustContext != null)
+            {
+                Uri spHostUrl = SharePointContext.GetSPHostUrl(httpContext.Request);
+                WindowsIdentity logonUserIdentity = httpContext.Request.LogonUserIdentity;
+
+                return spHostUrl == spHighTrustContext.SPHostUrl &&
+                       logonUserIdentity != null &&
+                       logonUserIdentity.IsAuthenticated &&
+                       !logonUserIdentity.IsGuest &&
+                       logonUserIdentity.User == spHighTrustContext.LogonUserIdentity.User;
+            }
+
+            return false;
+        }
+
+        protected override SharePointContext LoadSharePointContext(HttpContextBase httpContext)
+        {
+            return httpContext.Session[SPContextKey] as SharePointHighTrustContext;
+        }
+
+        protected override void SaveSharePointContext(SharePointContext spContext, HttpContextBase httpContext)
+        {
+            httpContext.Session[SPContextKey] = spContext as SharePointHighTrustContext;
+        }
+    }
+
+    #endregion HighTrust
+}

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/Web.Debug.config

@@ -0,0 +1,30 @@
+<?xml version="1.0"?>
+
+<!-- For more information on using Web.config transformation visit http://go.microsoft.com/fwlink/?LinkId=301874 -->
+
+<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
+  <!--
+    In the example below, the "SetAttributes" transform will change the value of
+    "connectionString" to use "ReleaseSQLServer" only when the "Match" locator
+    finds an attribute "name" that has a value of "MyDB".
+
+    <connectionStrings>
+      <add name="MyDB"
+        connectionString="Data Source=ReleaseSQLServer;Initial Catalog=MyReleaseDB;Integrated Security=True"
+        xdt:Transform="SetAttributes" xdt:Locator="Match(name)"/>
+    </connectionStrings>
+  -->
+  <system.web>
+    <!--
+      In the example below, the "Replace" transform will replace the entire
+      <customErrors> section of your Web.config file.
+      Note that because there is only one customErrors section under the
+      <system.web> node, there is no need to use the "xdt:Locator" attribute.
+
+      <customErrors defaultRedirect="GenericError.htm"
+        mode="RemoteOnly" xdt:Transform="Replace">
+        <error statusCode="500" redirect="InternalError.htm"/>
+      </customErrors>
+    -->
+  </system.web>
+</configuration>

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/Web.Release.config

@@ -0,0 +1,31 @@
+<?xml version="1.0"?>
+
+<!-- For more information on using Web.config transformation visit http://go.microsoft.com/fwlink/?LinkId=301874 -->
+
+<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
+  <!--
+    In the example below, the "SetAttributes" transform will change the value of
+    "connectionString" to use "ReleaseSQLServer" only when the "Match" locator
+    finds an attribute "name" that has a value of "MyDB".
+
+    <connectionStrings>
+      <add name="MyDB"
+        connectionString="Data Source=ReleaseSQLServer;Initial Catalog=MyReleaseDB;Integrated Security=True"
+        xdt:Transform="SetAttributes" xdt:Locator="Match(name)"/>
+    </connectionStrings>
+  -->
+  <system.web>
+    <compilation xdt:Transform="RemoveAttributes(debug)" />
+    <!--
+      In the example below, the "Replace" transform will replace the entire
+      <customErrors> section of your Web.config file.
+      Note that because there is only one customErrors section under the
+      <system.web> node, there is no need to use the "xdt:Locator" attribute.
+
+      <customErrors defaultRedirect="GenericError.htm"
+        mode="RemoteOnly" xdt:Transform="Replace">
+        <error statusCode="500" redirect="InternalError.htm"/>
+      </customErrors>
+    -->
+  </system.web>
+</configuration>

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/Web.config

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  For more information on how to configure your ASP.NET application, please visit
+  http://go.microsoft.com/fwlink/?LinkId=301879
+  -->
+<configuration>
+  <appSettings>
+    <add key="webpages:Version" value="3.0.0.0" />
+    <add key="webpages:Enabled" value="false" />
+    <add key="ClientValidationEnabled" value="true" />
+    <add key="UnobtrusiveJavaScriptEnabled" value="true" />
+    <add key="clientId" value="00000000-0000-0000-0000-000000000000"/>
+    <add key="clientSecret" value=""/>
+    <add key="siteUrl" value="https://your-tenant.sharepoint.com"/>
+    <add key="listName" value="Tasks"/>
+  </appSettings>
+  <system.web>
+    <compilation debug="true" targetFramework="4.5.2" />
+    <httpRuntime targetFramework="4.5.2" />
+  </system.web>
+  <system.webServer>
+    <handlers>
+      <remove name="ExtensionlessUrlHandler-Integrated-4.0" />
+      <remove name="OPTIONSVerbHandler" />
+      <remove name="TRACEVerbHandler" />
+      <add name="ExtensionlessUrlHandler-Integrated-4.0" path="*." verb="*" type="System.Web.Handlers.TransferRequestHandler" preCondition="integratedMode,runtimeVersionv4.0" />
+    </handlers>
+  </system.webServer>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="Newtonsoft.Json" culture="neutral" publicKeyToken="30ad4fe6b2a6aeed" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.Optimization" publicKeyToken="31bf3856ad364e35" />
+        <bindingRedirect oldVersion="1.0.0.0-1.1.0.0" newVersion="1.1.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="WebGrease" publicKeyToken="31bf3856ad364e35" />
+        <bindingRedirect oldVersion="0.0.0.0-1.5.2.14234" newVersion="1.5.2.14234" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.Helpers" publicKeyToken="31bf3856ad364e35" />
+        <bindingRedirect oldVersion="1.0.0.0-3.0.0.0" newVersion="3.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.WebPages" publicKeyToken="31bf3856ad364e35" />
+        <bindingRedirect oldVersion="1.0.0.0-3.0.0.0" newVersion="3.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" />
+        <bindingRedirect oldVersion="1.0.0.0-5.2.3.0" newVersion="5.2.3.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Data.Edm" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-5.6.4.0" newVersion="5.6.4.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.WindowsAzure.Storage" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+  <system.codedom>
+    <compilers>
+      <compiler language="c#;cs;csharp" extension=".cs" type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider, Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" warningLevel="4" compilerOptions="/langversion:6 /nowarn:1659;1699;1701" />
+      <compiler language="vb;vbs;visualbasic;vbscript" extension=".vb" type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider, Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" warningLevel="4" compilerOptions="/langversion:14 /nowarn:41008 /define:_MYTYPE=\&quot;Web\&quot; /optionInfer+" />
+    </compilers>
+  </system.codedom>
+</configuration>

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/packages.config

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Antlr" version="3.4.1.9004" targetFramework="net452" />
+  <package id="AppForSharePointOnlineWebToolkit" version="3.1.2" targetFramework="net452" />
+  <package id="bootstrap" version="3.0.0" targetFramework="net452" />
+  <package id="jQuery" version="1.10.2" targetFramework="net452" />
+  <package id="Microsoft.AspNet.Mvc" version="5.2.3" targetFramework="net452" />
+  <package id="Microsoft.AspNet.Razor" version="3.2.3" targetFramework="net452" />
+  <package id="Microsoft.AspNet.Web.Optimization" version="1.1.3" targetFramework="net452" />
+  <package id="Microsoft.AspNet.WebApi" version="5.2.3" targetFramework="net452" />
+  <package id="Microsoft.AspNet.WebApi.Client" version="5.2.3" targetFramework="net452" />
+  <package id="Microsoft.AspNet.WebApi.Core" version="5.2.3" targetFramework="net452" />
+  <package id="Microsoft.AspNet.WebApi.HelpPage" version="5.2.3" targetFramework="net452" />
+  <package id="Microsoft.AspNet.WebApi.WebHost" version="5.2.3" targetFramework="net452" />
+  <package id="Microsoft.AspNet.WebPages" version="3.2.3" targetFramework="net452" />
+  <package id="Microsoft.Azure.ActiveDirectory.GraphClient" version="2.1.0" targetFramework="net452" />
+  <package id="Microsoft.Azure.KeyVault.Core" version="1.0.0" targetFramework="net452" />
+  <package id="Microsoft.CodeDom.Providers.DotNetCompilerPlatform" version="1.0.0" targetFramework="net452" />
+  <package id="Microsoft.Data.Edm" version="5.6.4" targetFramework="net452" />
+  <package id="Microsoft.Data.OData" version="5.6.4" targetFramework="net452" />
+  <package id="Microsoft.Data.Services.Client" version="5.6.4" targetFramework="net452" />
+  <package id="Microsoft.Net.Compilers" version="1.0.0" targetFramework="net452" developmentDependency="true" />
+  <package id="Microsoft.SharePointOnline.CSOM" version="16.1.5715.1200" targetFramework="net452" />
+  <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net452" />
+  <package id="Modernizr" version="2.6.2" targetFramework="net452" />
+  <package id="Newtonsoft.Json" version="6.0.8" targetFramework="net452" />
+  <package id="Respond" version="1.2.0" targetFramework="net452" />
+  <package id="SharePointPnPCoreOnline" version="2.8.1610.0" targetFramework="net452" />
+  <package id="System.Spatial" version="5.6.4" targetFramework="net452" />
+  <package id="WebGrease" version="1.5.2" targetFramework="net452" />
+  <package id="WindowsAzure.Storage" version="7.0.0" targetFramework="net452" />
+</packages>

samples/react-sp-elevatedprivileges/api/pnp.api.elevatedprivileges/pnp.api.elevatedprivileges.csproj

@@ -0,0 +1,295 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.0\build\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.props" Condition="Exists('..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.0\build\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.props')" />
+  <Import Project="..\packages\Microsoft.Net.Compilers.1.0.0\build\Microsoft.Net.Compilers.props" Condition="Exists('..\packages\Microsoft.Net.Compilers.1.0.0\build\Microsoft.Net.Compilers.props')" />
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>
+    </ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{E9E8B537-849D-47B4-AA97-C3B7ED93227E}</ProjectGuid>
+    <ProjectTypeGuids>{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>pnp.api.elevatedprivileges</RootNamespace>
+    <AssemblyName>pnp.api.elevatedprivileges</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <MvcBuildViews>false</MvcBuildViews>
+    <UseIISExpress>true</UseIISExpress>
+    <IISExpressSSLPort />
+    <IISExpressAnonymousAuthentication />
+    <IISExpressWindowsAuthentication />
+    <IISExpressUseClassicPipelineMode />
+    <UseGlobalApplicationHostFile />
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.Azure.ActiveDirectory.GraphClient, Version=2.1.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Azure.ActiveDirectory.GraphClient.2.1.0\lib\portable-net4+sl5+win+wpa+wp8\Microsoft.Azure.ActiveDirectory.GraphClient.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.Azure.KeyVault.Core, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Azure.KeyVault.Core.1.0.0\lib\net40\Microsoft.Azure.KeyVault.Core.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.0\lib\net45\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="Microsoft.Data.Edm, Version=5.6.4.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Data.Edm.5.6.4\lib\net40\Microsoft.Data.Edm.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.Data.OData, Version=5.6.4.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Data.OData.5.6.4\lib\net40\Microsoft.Data.OData.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.Data.Services.Client, Version=5.6.4.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Data.Services.Client.5.6.4\lib\net40\Microsoft.Data.Services.Client.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel.Extensions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=69c3241e6f0468ca, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.Office.Client.Policy, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.Office.Client.Policy.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.Office.Client.TranslationServices, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.Office.Client.TranslationServices.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.Office.SharePoint.Tools, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.Office.SharePoint.Tools.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.Online.SharePoint.Client.Tenant, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.Online.SharePoint.Client.Tenant.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.ProjectServer.Client, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.ProjectServer.Client.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.SharePoint.Client, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.SharePoint.Client.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.SharePoint.Client.DocumentManagement, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.SharePoint.Client.DocumentManagement.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.SharePoint.Client.Publishing, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.SharePoint.Client.Publishing.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.SharePoint.Client.Runtime, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.SharePoint.Client.Runtime.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.SharePoint.Client.Runtime.Windows, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.SharePoint.Client.Runtime.Windows.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.SharePoint.Client.Search, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.SharePoint.Client.Search.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.SharePoint.Client.Search.Applications, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.SharePoint.Client.Search.Applications.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.SharePoint.Client.Taxonomy, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.SharePoint.Client.Taxonomy.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.SharePoint.Client.UserProfiles, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.SharePoint.Client.UserProfiles.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.SharePoint.Client.WorkflowServices, Version=16.1.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.SharePointOnline.CSOM.16.1.5715.1200\lib\net45\Microsoft.SharePoint.Client.WorkflowServices.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Microsoft.WindowsAzure.Storage, Version=7.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\WindowsAzure.Storage.7.0.0\lib\net40\Microsoft.WindowsAzure.Storage.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\packages\Newtonsoft.Json.6.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="OfficeDevPnP.Core, Version=2.8.1610.0, Culture=neutral, PublicKeyToken=3751622786b357c2, processorArchitecture=MSIL">
+      <HintPath>..\packages\SharePointPnPCoreOnline.2.8.1610.0\lib\net45\OfficeDevPnP.Core.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.IdentityModel" />
+    <Reference Include="System.IdentityModel.Selectors" />
+    <Reference Include="System.ServiceModel" />
+    <Reference Include="System.Spatial, Version=5.6.4.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Spatial.5.6.4\lib\net40\System.Spatial.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System.Web.Entity" />
+    <Reference Include="System.Web.ApplicationServices" />
+    <Reference Include="System.ComponentModel.DataAnnotations" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="System.Web.Extensions" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Web" />
+    <Reference Include="System.Web.Abstractions" />
+    <Reference Include="System.Web.Routing" />
+    <Reference Include="System.Xml" />
+    <Reference Include="System.Configuration" />
+    <Reference Include="System.Runtime.Serialization" />
+    <Reference Include="Microsoft.Web.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <Private>True</Private>
+      <HintPath>..\packages\Microsoft.Web.Infrastructure.1.0.0.0\lib\net40\Microsoft.Web.Infrastructure.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Net.Http">
+    </Reference>
+    <Reference Include="System.Net.Http.Formatting, Version=5.2.3.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.AspNet.WebApi.Client.5.2.3\lib\net45\System.Net.Http.Formatting.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Net.Http.WebRequest">
+    </Reference>
+    <Reference Include="System.Web.Helpers, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <Private>True</Private>
+      <HintPath>..\packages\Microsoft.AspNet.WebPages.3.2.3\lib\net45\System.Web.Helpers.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Web.Http, Version=5.2.3.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.AspNet.WebApi.Core.5.2.3\lib\net45\System.Web.Http.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Web.Http.WebHost, Version=5.2.3.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.AspNet.WebApi.WebHost.5.2.3\lib\net45\System.Web.Http.WebHost.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Web.Mvc, Version=5.2.3.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <Private>True</Private>
+      <HintPath>..\packages\Microsoft.AspNet.Mvc.5.2.3\lib\net45\System.Web.Mvc.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Web.Optimization">
+      <HintPath>..\packages\Microsoft.AspNet.Web.Optimization.1.1.3\lib\net40\System.Web.Optimization.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Web.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <Private>True</Private>
+      <HintPath>..\packages\Microsoft.AspNet.Razor.3.2.3\lib\net45\System.Web.Razor.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Web.WebPages, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <Private>True</Private>
+      <HintPath>..\packages\Microsoft.AspNet.WebPages.3.2.3\lib\net45\System.Web.WebPages.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Web.WebPages.Deployment, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <Private>True</Private>
+      <HintPath>..\packages\Microsoft.AspNet.WebPages.3.2.3\lib\net45\System.Web.WebPages.Deployment.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <Private>True</Private>
+      <HintPath>..\packages\Microsoft.AspNet.WebPages.3.2.3\lib\net45\System.Web.WebPages.Razor.dll</HintPath>
+    </Reference>
+    <Reference Include="WebGrease">
+      <Private>True</Private>
+      <HintPath>..\packages\WebGrease.1.5.2\lib\WebGrease.dll</HintPath>
+    </Reference>
+    <Reference Include="Antlr3.Runtime">
+      <Private>True</Private>
+      <HintPath>..\packages\Antlr.3.4.1.9004\lib\Antlr3.Runtime.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup />
+  <ItemGroup>
+    <Compile Include="App_Start\FilterConfig.cs" />
+    <Compile Include="App_Start\WebApiConfig.cs" />
+    <Compile Include="Controllers\ItemsController.cs" />
+    <Compile Include="Filters\SharePointContextFilterAttribute.cs" />
+    <Compile Include="Global.asax.cs">
+      <DependentUpon>Global.asax</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SharePointContext.cs" />
+    <Compile Include="TokenHelper.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="favicon.ico" />
+    <Content Include="Global.asax" />
+    <Content Include="Web.config">
+      <SubType>Designer</SubType>
+    </Content>
+    <Content Include="Web.Debug.config">
+      <DependentUpon>Web.config</DependentUpon>
+    </Content>
+    <Content Include="Web.Release.config">
+      <DependentUpon>Web.config</DependentUpon>
+    </Content>
+  </ItemGroup>
+  <ItemGroup />
+  <ItemGroup>
+    <Content Include="packages.config" />
+  </ItemGroup>
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <Import Project="$(VSToolsPath)\WebApplications\Microsoft.WebApplication.targets" Condition="'$(VSToolsPath)' != ''" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v10.0\WebApplications\Microsoft.WebApplication.targets" Condition="false" />
+  <Target Name="MvcBuildViews" AfterTargets="AfterBuild" Condition="'$(MvcBuildViews)'=='true'">
+    <AspNetCompiler VirtualPath="temp" PhysicalPath="$(WebProjectOutputDir)" />
+  </Target>
+  <ProjectExtensions>
+    <VisualStudio>
+      <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}">
+        <WebProjectProperties>
+          <UseIIS>True</UseIIS>
+          <AutoAssignPort>True</AutoAssignPort>
+          <DevelopmentServerPort>2495</DevelopmentServerPort>
+          <DevelopmentServerVPath>/</DevelopmentServerVPath>
+          <IISUrl>http://localhost:2495/</IISUrl>
+          <NTLMAuthentication>False</NTLMAuthentication>
+          <UseCustomServer>False</UseCustomServer>
+          <CustomServerUrl>
+          </CustomServerUrl>
+          <SaveServerSettingsInUserFile>False</SaveServerSettingsInUserFile>
+        </WebProjectProperties>
+      </FlavorProperties>
+    </VisualStudio>
+  </ProjectExtensions>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\Microsoft.Net.Compilers.1.0.0\build\Microsoft.Net.Compilers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.Net.Compilers.1.0.0\build\Microsoft.Net.Compilers.props'))" />
+    <Error Condition="!Exists('..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.0\build\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.0\build\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.props'))" />
+  </Target>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target> -->
+</Project>

samples/react-sp-elevatedprivileges/webpart/.editorconfig

@@ -0,0 +1,25 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+
+[*]
+
+# change these settings to your own preference
+indent_style = space
+indent_size = 2
+
+# we recommend you to keep these unchanged
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[{package,bower}.json]
+indent_style = space
+indent_size = 2

samples/react-sp-elevatedprivileges/webpart/.gitattributes

@@ -0,0 +1 @@
+* text=auto

samples/react-sp-elevatedprivileges/webpart/.gitignore

@@ -0,0 +1,32 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Dependency directories
+node_modules
+
+# Build generated files
+dist
+lib
+solution
+temp
+*.spapp
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# OSX
+.DS_Store
+
+# Visual Studio files
+.ntvs_analysis.dat
+.vs
+bin
+obj
+
+# Resx Generated Code
+*.resx.ts
+
+# Styles Generated Code
+*.scss.ts

samples/react-sp-elevatedprivileges/webpart/.npmignore

@@ -0,0 +1,14 @@
+# Folders
+.vscode
+coverage
+node_modules
+sharepoint
+src
+temp
+
+# Files
+*.csproj
+.git*
+.yo-rc.json
+gulpfile.js
+tsconfig.json

samples/react-sp-elevatedprivileges/webpart/.vscode/settings.json

@@ -0,0 +1,21 @@
+{
+  // The number of spaces a tab is equal to.
+  "editor.tabSize": 2,
+
+  // When enabled, will trim trailing whitespace when you save a file.
+  "files.trimTrailingWhitespace": true,
+
+  // Controls if the editor should automatically close brackets after opening them
+  "editor.autoClosingBrackets": false,
+
+  // Configure glob patterns for excluding files and folders.
+  "search.exclude": {
+    "**/bower_components": true,
+    "**/node_modules": true,
+    "coverage": true,
+    "dist": true,
+    "lib-amd": true,
+    "lib": true,
+    "temp": true
+  }
+}

samples/react-sp-elevatedprivileges/webpart/.vscode/tasks.json

@@ -0,0 +1,34 @@
+{
+  // See http://go.microsoft.com/fwlink/?LinkId=733558
+  // for the documentation about the tasks.json format
+  "version": "0.1.0",
+  "command": "gulp",
+  "isShellCommand": true,
+  "showOutput": "always",
+  "args": [
+    "--no-color"
+  ],
+  "tasks": [
+    {
+      "taskName": "bundle",
+      "isBuildCommand": true,
+      "problemMatcher": [
+        "$tsc"
+      ]
+    },
+    {
+      "taskName": "test",
+      "isTestCommand": true,
+      "problemMatcher": [
+        "$tsc"
+      ]
+    },
+    {
+      "taskName": "serve",
+      "isWatching": true,
+      "problemMatcher": [
+        "$tsc"
+      ]
+    }
+  ]
+}

samples/react-sp-elevatedprivileges/webpart/.yo-rc.json

@@ -0,0 +1,7 @@
+{
+  "@microsoft/generator-sharepoint": {
+    "libraryName": "react-sp-elevatedprivileges",
+    "libraryId": "dbc8827c-729c-4e8f-9ecc-f0d57f279ba2",
+    "framework": "react"
+  }
+}

samples/react-sp-elevatedprivileges/webpart/config/config.json

@@ -0,0 +1,21 @@
+{
+  "entries": [
+    {
+      "entry": "./lib/webparts/createTask/CreateTaskWebPart.js",
+      "manifest": "./src/webparts/createTask/CreateTaskWebPart.manifest.json",
+      "outputPath": "./dist/create-task.bundle.js"
+    }
+  ],
+  "externals": {
+    "@microsoft/sp-client-base": "node_modules/@microsoft/sp-client-base/dist/sp-client-base.js",
+    "@microsoft/sp-client-preview": "node_modules/@microsoft/sp-client-preview/dist/sp-client-preview.js",
+    "@microsoft/sp-lodash-subset": "node_modules/@microsoft/sp-lodash-subset/dist/sp-lodash-subset.js",
+    "office-ui-fabric-react": "node_modules/office-ui-fabric-react/dist/office-ui-fabric-react.js",
+    "react": "node_modules/react/dist/react.min.js",
+    "react-dom": "node_modules/react-dom/dist/react-dom.min.js",
+    "react-dom/server": "node_modules/react-dom/dist/react-dom-server.min.js"
+  },
+  "localizedResources": {
+    "createTaskStrings": "webparts/createTask/loc/{locale}.js"
+  }
+}

samples/react-sp-elevatedprivileges/webpart/config/deploy-azure-storage.json

@@ -0,0 +1,6 @@
+{
+  "workingDir": "./temp/deploy/",
+  "account": "<!-- STORAGE ACCOUNT NAME -->",
+  "container": "react-sp-elevatedprivileges",
+  "accessKey": "<!-- ACCESS KEY -->"
+}

samples/react-sp-elevatedprivileges/webpart/config/package-solution.json

@@ -0,0 +1,10 @@
+{
+  "solution": {
+    "name": "react-sp-elevatedprivileges-client-side-solution",
+    "id": "dbc8827c-729c-4e8f-9ecc-f0d57f279ba2",
+    "version": "1.0.0.0"
+  },
+  "paths": {
+    "zippedPackage": "solution/react-sp-elevatedprivileges.spapp"
+  }
+}

samples/react-sp-elevatedprivileges/webpart/config/prepare-deploy.json

@@ -0,0 +1,3 @@
+{
+  "deployCdnPath": "temp/deploy"
+}

samples/react-sp-elevatedprivileges/webpart/config/serve.json

@@ -0,0 +1,9 @@
+{
+  "port": 4321,
+  "initialPage": "https://localhost:5432/workbench",
+  "https": true,
+  "api": {
+    "port": 5432,
+    "entryPath": "node_modules/@microsoft/sp-webpart-workbench/lib/api/"
+  }
+}

samples/react-sp-elevatedprivileges/webpart/config/tslint.json

@@ -0,0 +1,51 @@
+{
+  // Display errors as warnings
+  "displayAsWarning": true,
+  // The TSLint task may have been configured with several custom lint rules
+  // before this config file is read (for example lint rules from the tslint-microsoft-contrib
+  // project). If true, this flag will deactivate any of these rules.
+  "removeExistingRules": true,
+  // When true, the TSLint task is configured with some default TSLint "rules.":
+  "useDefaultConfigAsBase": false,
+  // Since removeExistingRules=true and useDefaultConfigAsBase=false, there will be no lint rules
+  // which are active, other than the list of rules below.
+  "lintConfig": {
+    // Opt-in to Lint rules which help to eliminate bugs in JavaScript
+    "rules": {
+      "class-name": false,
+      "export-name": false,
+      "forin": false,
+      "label-position": false,
+      "label-undefined": false,
+      "member-access": true,
+      "no-arg": false,
+      "no-console": false,
+      "no-construct": false,
+      "no-duplicate-case": true,
+      "no-duplicate-key": false,
+      "no-duplicate-variable": true,
+      "no-eval": false,
+      "no-function-expression": true,
+      "no-internal-module": true,
+      "no-shadowed-variable": true,
+      "no-switch-case-fall-through": true,
+      "no-unnecessary-semicolons": true,
+      "no-unused-expression": true,
+      "no-unused-imports": true,
+      "no-unused-variable": true,
+      "no-unreachable": true,
+      "no-use-before-declare": true,
+      "no-with-statement": true,
+      "semicolon": true,
+      "trailing-comma": false,
+      "typedef": false,
+      "typedef-whitespace": false,
+      "use-named-parameter": true,
+      "valid-typeof": true,
+      "variable-name": false,
+      "whitespace": false,
+      "prefer-const": true,
+      "a11y-role": true
+    }
+  }
+}

samples/react-sp-elevatedprivileges/webpart/config/write-manifests.json

@@ -0,0 +1,3 @@
+{
+  "cdnBasePath": "<!-- PATH TO CDN -->"
+}

samples/react-sp-elevatedprivileges/webpart/gulpfile.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const gulp = require('gulp');
+const build = require('@microsoft/sp-build-web');
+
+build.initialize(gulp);

samples/react-sp-elevatedprivileges/webpart/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "react-sp-elevatedprivileges",
+  "version": "0.0.1",
+  "private": true,
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "dependencies": {
+    "@microsoft/sp-client-base": "~0.3.0",
+    "@microsoft/sp-client-preview": "~0.4.0",
+    "office-ui-fabric-react": "0.36.0",
+    "react": "0.14.8",
+    "react-dom": "0.14.8"
+  },
+  "devDependencies": {
+    "@microsoft/sp-build-web": "~0.6.0",
+    "@microsoft/sp-module-interfaces": "~0.3.0",
+    "@microsoft/sp-webpart-workbench": "~0.4.0",
+    "gulp": "~3.9.1"
+  },
+  "scripts": {
+    "build": "gulp bundle",
+    "clean": "gulp nuke",
+    "test": "gulp test"
+  }
+}

samples/react-sp-elevatedprivileges/webpart/react-sp-elevatedprivileges.njsproj

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Gulp" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{dbc8827c-729c-4e8f-9ecc-f0d57f279ba2}</ProjectGuid>
+    <ProjectHome />
+    <ProjectView>ProjectFiles</ProjectView>
+    <StartupFile>node_modules\gulp\bin\gulp.js</StartupFile>
+    <WorkingDirectory>.</WorkingDirectory>
+    <OutputPath>.</OutputPath>
+    <ProjectTypeGuids>{3AF33F2E-1136-4D97-BBB7-1795711AC8B8};{349c5851-65df-11da-9384-00065b846f21};{9092AA53-FB77-4645-B42D-1CCCA6BD08BD}</ProjectTypeGuids>
+    <TypeScriptSourceMap>true</TypeScriptSourceMap>
+    <TypeScriptModuleKind>CommonJS</TypeScriptModuleKind>
+    <EnableTypeScript>false</EnableTypeScript>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+    <ScriptArguments>serve</ScriptArguments>
+    <StartWebBrowser>True</StartWebBrowser>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)' == 'Debug'" />
+  <PropertyGroup Condition="'$(Configuration)' == 'Release'" />
+  <Target Name="Gulp">
+    <Message Text="Running gulp2vs.js" Importance="normal" />
+    <Exec Command="CMD.EXE /c node $(MSBuildThisFileDirectory)\node_modules\gulp\bin\gulp.js bundle" />
+  </Target>
+  <ItemGroup>
+    <Content Include="*.js" />
+    <Content Include="*.json" />
+    <Content Include="*.md" />
+    <Content Include="config\**\*.json" />
+    <Content Include="docs\*.md" />
+    <Content Include="sharepoint\feature_xml\**\*.*" />
+    <Content Include="src\**\*.html" />
+    <Content Include="src\**\*.js" />
+    <Content Include="src\**\*.json" />
+    <Content Include="src\**\*.less" />
+    <Content Include="src\**\*.resx" />
+    <Content Include="src\**\*.scss" />
+    <Content Include="src\**\*.ts" />
+    <Content Include="src\**\*.tsx" />
+    <Content Include="typings\**\*.ts" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.Common.targets" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <!--Do not delete the following Import Project.  While this appears to do nothing it is a marker for setting TypeScript properties before our import that depends on them.-->
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\TypeScript\Microsoft.TypeScript.targets" Condition="False" />
+  <Import Project="$(VSToolsPath)\Node.js Tools\Microsoft.NodejsTools.targets" />
+  <ProjectExtensions>
+    <VisualStudio>
+      <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}">
+        <WebProjectProperties>
+          <UseIIS>False</UseIIS>
+          <AutoAssignPort>True</AutoAssignPort>
+          <DevelopmentServerPort>0</DevelopmentServerPort>
+          <DevelopmentServerVPath>/</DevelopmentServerVPath>
+          <IISUrl>http://localhost:48022/</IISUrl>
+          <NTLMAuthentication>False</NTLMAuthentication>
+          <UseCustomServer>True</UseCustomServer>
+          <CustomServerUrl>http://localhost:1337</CustomServerUrl>
+          <SaveServerSettingsInUserFile>False</SaveServerSettingsInUserFile>
+        </WebProjectProperties>
+      </FlavorProperties>
+      <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}" User="">
+        <WebProjectProperties>
+          <StartPageUrl>
+          </StartPageUrl>
+          <StartAction>CurrentPage</StartAction>
+          <AspNetDebugging>True</AspNetDebugging>
+          <SilverlightDebugging>False</SilverlightDebugging>
+          <NativeDebugging>False</NativeDebugging>
+          <SQLDebugging>False</SQLDebugging>
+          <ExternalProgram>
+          </ExternalProgram>
+          <StartExternalURL>
+          </StartExternalURL>
+          <StartCmdLineArguments>
+          </StartCmdLineArguments>
+          <StartWorkingDirectory>
+          </StartWorkingDirectory>
+          <EnableENC>False</EnableENC>
+          <AlwaysStartWebServerOnDebug>False</AlwaysStartWebServerOnDebug>
+        </WebProjectProperties>
+      </FlavorProperties>
+    </VisualStudio>
+  </ProjectExtensions>
+</Project>

samples/react-sp-elevatedprivileges/webpart/src/tests.js

@@ -0,0 +1,5 @@
+var context = require.context('.', true, /.+\.test\.js?$/);
+
+context.keys().forEach(context);
+
+module.exports = context;

samples/react-sp-elevatedprivileges/webpart/src/webparts/createTask/CreateTask.module.scss

@@ -0,0 +1,21 @@
+.createTask {
+  .container {
+    max-width: 700px;
+    margin: 0px auto;
+    box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.2), 0 25px 50px 0 rgba(0, 0, 0, 0.1);
+  }
+
+  .row {
+    padding: 20px;
+  }
+
+  .listItem {
+    max-width: 715px;
+    margin: 5px auto 5px auto;
+    box-shadow: 0 0 4px 0 rgba(0, 0, 0, 0.2), 0 25px 50px 0 rgba(0, 0, 0, 0.1);
+  }
+
+  .button {
+    text-decoration: none;
+  }
+}

samples/react-sp-elevatedprivileges/webpart/src/webparts/createTask/CreateTaskWebPart.manifest.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "../../../node_modules/@microsoft/sp-module-interfaces/lib/manifestSchemas/jsonSchemas/clientSideComponentManifestSchema.json",
+
+  "id": "744bc357-0a6a-4f97-b4ef-312bb8c378d9",
+  "componentType": "WebPart",
+  "version": "0.0.1",
+  "manifestVersion": 2,
+
+  "preconfiguredEntries": [{
+    "groupId": "744bc357-0a6a-4f97-b4ef-312bb8c378d9",
+    "group": { "default": "Under Development" },
+    "title": { "default": "Create task" },
+    "description": { "default": "Creates task using remote API with elevated privileges" },
+    "officeFabricIconFontName": "Page",
+    "properties": {
+    }
+  }]
+}

samples/react-sp-elevatedprivileges/webpart/src/webparts/createTask/CreateTaskWebPart.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import * as ReactDom from 'react-dom';
+import {
+  BaseClientSideWebPart,
+  IWebPartContext
+} from '@microsoft/sp-client-preview';
+
+import CreateTask, { ICreateTaskProps } from './components/CreateTask';
+import { ICreateTaskWebPartProps } from './ICreateTaskWebPartProps';
+
+export default class CreateTaskWebPart extends BaseClientSideWebPart<ICreateTaskWebPartProps> {
+
+  public constructor(context: IWebPartContext) {
+    super(context);
+  }
+
+  public render(): void {
+    const element: React.ReactElement<ICreateTaskProps> = React.createElement(CreateTask, {});
+
+    ReactDom.render(element, this.domElement);
+  }
+}

samples/react-sp-elevatedprivileges/webpart/src/webparts/createTask/ICreateTaskWebPartProps.ts

@@ -0,0 +1,2 @@
+export interface ICreateTaskWebPartProps {
+}

samples/react-sp-elevatedprivileges/webpart/src/webparts/createTask/components/CreateTask.tsx

@@ -0,0 +1,136 @@
+import * as React from 'react';
+import { css, Button, Spinner, TextField } from 'office-ui-fabric-react';
+import { HttpClient } from '@microsoft/sp-client-base';
+
+import styles from '../CreateTask.module.scss';
+import { ICreateTaskWebPartProps } from '../ICreateTaskWebPartProps';
+
+export interface ICreateTaskProps extends ICreateTaskWebPartProps {
+}
+
+export interface ICreateTaskState {
+  itemTitleInvalid: boolean;
+  creatingItem: boolean;
+  itemTitle: string;
+  status: string;
+  itemTitleChanged: boolean;
+}
+
+export default class CreateTask extends React.Component<ICreateTaskProps, ICreateTaskState> {
+  constructor(props: ICreateTaskProps, state: ICreateTaskState) {
+    super(props);
+
+    this.state = {
+      creatingItem: false,
+      itemTitle: '',
+      itemTitleInvalid: true,
+      status: '',
+      itemTitleChanged: false
+    };
+
+    if (!String.prototype.trim) {
+      (() => {
+        // Make sure we trim BOM and NBSP
+        var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
+        String.prototype.trim = function () {
+          return this.replace(rtrim, '');
+        };
+      })();
+    }
+  }
+
+  public render(): JSX.Element {
+    const creatingItem: JSX.Element = this.state.creatingItem ? <div style={{ margin: '0 auto' }}><Spinner label={'Creating item...'} /></div> : <div />;
+    const status: JSX.Element = this.state.status.length > 0 ? <div>{this.state.status}</div> : <div />;
+
+    return (
+      <div className={styles.createTask}>
+        <div className={styles.container}>
+          <div className={css('ms-Grid-row', styles.row)}>
+            <div className='ms-Grid-col ms-u-lg10 ms-u-xl8 ms-u-xlPush2 ms-u-lgPush1'>
+              <div className='ms-font-xl'>
+                Create list item
+              </div>
+              <TextField label={'Item title'} disabled={this.state.creatingItem}
+                onBeforeChange={(newValue: string) => { this.itemTitleChanged(newValue); }}
+                onGetErrorMessage={(): string => { return this.validateItemTitle(); } }
+                value={this.state.itemTitle} />
+              <Button onClick={() => { this.createItem(); } }
+                disabled={this.state.creatingItem || this.state.itemTitleInvalid}>Create item</Button>
+              {creatingItem}
+              {status}
+            </div>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  private createItem(): void {
+    this.setState((prevState: ICreateTaskState, props: ICreateTaskProps): ICreateTaskState => {
+      prevState.creatingItem = true;
+      prevState.status = '';
+      return prevState;
+    });
+
+    window.fetch('https://pnp-spfx-elevation-api.azurewebsites.net/api/items', {
+      method: 'POST',
+      body: JSON.stringify({ title: this.state.itemTitle }),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    })
+      .then((response: Response): void => {
+        if (response.ok) {
+          this.setState((prevState: ICreateTaskState, props: ICreateTaskProps): ICreateTaskState => {
+            prevState.creatingItem = false;
+            prevState.status = 'Item successfully created';
+            return prevState;
+          });
+        }
+        else {
+          this.setState((prevState: ICreateTaskState, props: ICreateTaskProps): ICreateTaskState => {
+            prevState.creatingItem = false;
+            prevState.status = 'Error creating item: ' + response.statusText;
+            return prevState;
+          });
+        }
+      }, (error: any): void => {
+        this.setState((prevState: ICreateTaskState, props: ICreateTaskProps): ICreateTaskState => {
+          prevState.creatingItem = false;
+          prevState.status = 'Error creating item: ' + error;
+          return prevState;
+        });
+      });
+  }
+
+  private itemTitleChanged(newValue: string): void {
+    this.setState((prevState: ICreateTaskState, props: ICreateTaskProps): ICreateTaskState => {
+      prevState.itemTitleChanged = true;
+      prevState.status = '';
+      prevState.itemTitle = newValue;
+      return prevState;
+    });
+  }
+
+  private validateItemTitle(): string {
+    if (!this.state.itemTitleChanged) {
+      return '';
+    }
+
+    if (this.state.itemTitle.trim().length === 0) {
+      this.setState((prevState: ICreateTaskState, props: ICreateTaskProps): ICreateTaskState => {
+        prevState.itemTitleInvalid = true;
+        return prevState;
+      });
+      return 'Please enter item title';
+    }
+    else {
+      this.setState((prevState: ICreateTaskState, props: ICreateTaskProps): ICreateTaskState => {
+        prevState.itemTitleInvalid = false;
+        return prevState;
+      });
+      return '';
+    }
+  }
+}

samples/react-sp-elevatedprivileges/webpart/src/webparts/createTask/loc/en-us.js

@@ -0,0 +1,7 @@
+define([], function() {
+  return {
+    "PropertyPaneDescription": "Description",
+    "BasicGroupName": "Group Name",
+    "DescriptionFieldLabel": "Description Field"
+  }
+});

samples/react-sp-elevatedprivileges/webpart/src/webparts/createTask/loc/mystrings.d.ts

@@ -0,0 +1,10 @@
+declare interface ICreateTaskStrings {
+  PropertyPaneDescription: string;
+  BasicGroupName: string;
+  DescriptionFieldLabel: string;
+}
+
+declare module 'createTaskStrings' {
+  const strings: ICreateTaskStrings;
+  export = strings;
+}

samples/react-sp-elevatedprivileges/webpart/src/webparts/createTask/tests/CreateTask.test.ts

@@ -0,0 +1,7 @@
+import * as assert from 'assert';
+
+describe('CreateTaskWebPart', () => {
+  it('should do something', () => {
+    assert.ok(true);
+  });
+});

samples/react-sp-elevatedprivileges/webpart/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "jsx": "react",
+    "declaration": true,
+    "sourceMap": true
+  }
+}

samples/react-sp-elevatedprivileges/webpart/typings/@ms/odsp-webpack.d.ts

@@ -0,0 +1,13 @@
+// Type definitions for webpack in Microsoft ODSP projects
+// Project: ODSP-WEBPACK
+
+/*
+ * This definition of webpack require overrides all other definitions of require in our toolchain
+ * Make sure all other definitions of require are commented out e.g. in node.d.ts
+ */ 
+declare var require: { 
+    (path: string): any; 
+    (paths: string[], callback: (...modules: any[]) => void): void; 
+    resolve: (id: string) => string;
+    ensure: (paths: string[], callback: (require: <T>(path: string) => T) => void, path: string) => void; 
+};

samples/react-sp-elevatedprivileges/webpart/typings/@ms/odsp.d.ts

@@ -0,0 +1,10 @@
+// Type definitions for Microsoft ODSP projects
+// Project: ODSP
+
+/// <reference path="odsp-webpack.d.ts" />
+
+/* Global definition for DEBUG builds */ 
+declare const DEBUG: boolean;
+
+/* Global definition for UNIT_TEST builds */ 
+declare const UNIT_TEST: boolean;

samples/react-sp-elevatedprivileges/webpart/typings/assertion-error/assertion-error.d.ts

@@ -0,0 +1,15 @@
+// Type definitions for assertion-error 1.0.0
+// Project: https://github.com/chaijs/assertion-error
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'assertion-error' {
+	class AssertionError implements Error {
+		constructor(message: string, props?: any, ssf?: Function);
+		name: string;
+		message: string;
+		showDiff: boolean;
+		stack: string;
+	}
+	export = AssertionError;
+}

samples/react-sp-elevatedprivileges/webpart/typings/chai/chai.d.ts

@@ -0,0 +1,388 @@
+// Type definitions for chai 3.2.0
+// Project: http://chaijs.com/
+// Definitions by: Jed Mao <https://github.com/jedmao/>,
+//                 Bart van der Schoor <https://github.com/Bartvds>,
+//                 Andrew Brown <https://github.com/AGBrown>,
+//                 Olivier Chevet <https://github.com/olivr70>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// <reference path="../assertion-error/assertion-error.d.ts"/>
+
+declare module Chai {
+
+    interface ChaiStatic {
+        expect: ExpectStatic;
+        should(): Should;
+        /**
+         * Provides a way to extend the internals of Chai
+         */
+        use(fn: (chai: any, utils: any) => void): any;
+        assert: AssertStatic;
+        config: Config;
+        AssertionError: AssertionError;
+    }
+
+    export interface ExpectStatic extends AssertionStatic {
+        fail(actual?: any, expected?: any, message?: string, operator?: string): void;
+    }
+
+    export interface AssertStatic extends Assert {
+    }
+
+    export interface AssertionStatic {
+        (target: any, message?: string): Assertion;
+    }
+
+    interface ShouldAssertion {
+        equal(value1: any, value2: any, message?: string): void;
+        Throw: ShouldThrow;
+        throw: ShouldThrow;
+        exist(value: any, message?: string): void;
+    }
+
+    interface Should extends ShouldAssertion {
+        not: ShouldAssertion;
+        fail(actual: any, expected: any, message?: string, operator?: string): void;
+    }
+
+    interface ShouldThrow {
+        (actual: Function): void;
+        (actual: Function, expected: string|RegExp, message?: string): void;
+        (actual: Function, constructor: Error|Function, expected?: string|RegExp, message?: string): void;
+    }
+
+    interface Assertion extends LanguageChains, NumericComparison, TypeComparison {
+        not: Assertion;
+        deep: Deep;
+        any: KeyFilter;
+        all: KeyFilter;
+        a: TypeComparison;
+        an: TypeComparison;
+        include: Include;
+        includes: Include;
+        contain: Include;
+        contains: Include;
+        ok: Assertion;
+        true: Assertion;
+        false: Assertion;
+        null: Assertion;
+        undefined: Assertion;
+        NaN: Assertion;
+        exist: Assertion;
+        empty: Assertion;
+        arguments: Assertion;
+        Arguments: Assertion;
+        equal: Equal;
+        equals: Equal;
+        eq: Equal;
+        eql: Equal;
+        eqls: Equal;
+        property: Property;
+        ownProperty: OwnProperty;
+        haveOwnProperty: OwnProperty;
+        ownPropertyDescriptor: OwnPropertyDescriptor;
+        haveOwnPropertyDescriptor: OwnPropertyDescriptor;
+        length: Length;
+        lengthOf: Length;
+        match: Match;
+        matches: Match;
+        string(string: string, message?: string): Assertion;
+        keys: Keys;
+        key(string: string): Assertion;
+        throw: Throw;
+        throws: Throw;
+        Throw: Throw;
+        respondTo: RespondTo;
+        respondsTo: RespondTo;
+        itself: Assertion;
+        satisfy: Satisfy;
+        satisfies: Satisfy;
+        closeTo(expected: number, delta: number, message?: string): Assertion;
+        members: Members;
+        increase: PropertyChange;
+        increases: PropertyChange;
+        decrease: PropertyChange;
+        decreases: PropertyChange;
+        change: PropertyChange;
+        changes: PropertyChange;
+        extensible: Assertion;
+        sealed: Assertion;
+        frozen: Assertion;
+
+    }
+
+    interface LanguageChains {
+        to: Assertion;
+        be: Assertion;
+        been: Assertion;
+        is: Assertion;
+        that: Assertion;
+        which: Assertion;
+        and: Assertion;
+        has: Assertion;
+        have: Assertion;
+        with: Assertion;
+        at: Assertion;
+        of: Assertion;
+        same: Assertion;
+    }
+
+    interface NumericComparison {
+        above: NumberComparer;
+        gt: NumberComparer;
+        greaterThan: NumberComparer;
+        least: NumberComparer;
+        gte: NumberComparer;
+        below: NumberComparer;
+        lt: NumberComparer;
+        lessThan: NumberComparer;
+        most: NumberComparer;
+        lte: NumberComparer;
+        within(start: number, finish: number, message?: string): Assertion;
+    }
+
+    interface NumberComparer {
+        (value: number, message?: string): Assertion;
+    }
+
+    interface TypeComparison {
+        (type: string, message?: string): Assertion;
+        instanceof: InstanceOf;
+        instanceOf: InstanceOf;
+    }
+
+    interface InstanceOf {
+        (constructor: Object, message?: string): Assertion;
+    }
+
+    interface Deep {
+        equal: Equal;
+        include: Include;
+        property: Property;
+        members: Members;
+    }
+
+    interface KeyFilter {
+        keys: Keys;
+    }
+
+    interface Equal {
+        (value: any, message?: string): Assertion;
+    }
+
+    interface Property {
+        (name: string, value?: any, message?: string): Assertion;
+    }
+
+    interface OwnProperty {
+        (name: string, message?: string): Assertion;
+    }
+
+    interface OwnPropertyDescriptor {
+        (name: string, descriptor: PropertyDescriptor, message?: string): Assertion;
+        (name: string, message?: string): Assertion;
+    }
+
+    interface Length extends LanguageChains, NumericComparison {
+        (length: number, message?: string): Assertion;
+    }
+
+    interface Include {
+        (value: Object, message?: string): Assertion;
+        (value: string, message?: string): Assertion;
+        (value: number, message?: string): Assertion;
+        keys: Keys;
+        members: Members;
+        any: KeyFilter;
+        all: KeyFilter;
+    }
+
+    interface Match {
+        (regexp: RegExp|string, message?: string): Assertion;
+    }
+
+    interface Keys {
+        (...keys: string[]): Assertion;
+        (keys: any[]): Assertion;
+        (keys: Object): Assertion;
+    }
+
+    interface Throw {
+        (): Assertion;
+        (expected: string, message?: string): Assertion;
+        (expected: RegExp, message?: string): Assertion;
+        (constructor: Error, expected?: string, message?: string): Assertion;
+        (constructor: Error, expected?: RegExp, message?: string): Assertion;
+        (constructor: Function, expected?: string, message?: string): Assertion;
+        (constructor: Function, expected?: RegExp, message?: string): Assertion;
+    }
+
+    interface RespondTo {
+        (method: string, message?: string): Assertion;
+    }
+
+    interface Satisfy {
+        (matcher: Function, message?: string): Assertion;
+    }
+
+    interface Members {
+        (set: any[], message?: string): Assertion;
+    }
+
+    interface PropertyChange {
+        (object: Object, prop: string, msg?: string): Assertion;
+    }
+
+    export interface Assert {
+        /**
+         * @param expression Expression to test for truthiness.
+         * @param message Message to display on error.
+         */
+        (expression: any, message?: string): void;
+
+        fail(actual?: any, expected?: any, msg?: string, operator?: string): void;
+
+        ok(val: any, msg?: string): void;
+        isOk(val: any, msg?: string): void;
+        notOk(val: any, msg?: string): void;
+        isNotOk(val: any, msg?: string): void;
+
+        equal(act: any, exp: any, msg?: string): void;
+        notEqual(act: any, exp: any, msg?: string): void;
+
+        strictEqual(act: any, exp: any, msg?: string): void;
+        notStrictEqual(act: any, exp: any, msg?: string): void;
+
+        deepEqual(act: any, exp: any, msg?: string): void;
+        notDeepEqual(act: any, exp: any, msg?: string): void;
+
+        isTrue(val: any, msg?: string): void;
+        isFalse(val: any, msg?: string): void;
+
+        isNull(val: any, msg?: string): void;
+        isNotNull(val: any, msg?: string): void;
+
+        isUndefined(val: any, msg?: string): void;
+        isDefined(val: any, msg?: string): void;
+
+        isNaN(val: any, msg?: string): void;
+        isNotNaN(val: any, msg?: string): void;
+
+        isAbove(val: number, abv: number, msg?: string): void;
+        isBelow(val: number, blw: number, msg?: string): void;
+
+        isFunction(val: any, msg?: string): void;
+        isNotFunction(val: any, msg?: string): void;
+
+        isObject(val: any, msg?: string): void;
+        isNotObject(val: any, msg?: string): void;
+
+        isArray(val: any, msg?: string): void;
+        isNotArray(val: any, msg?: string): void;
+
+        isString(val: any, msg?: string): void;
+        isNotString(val: any, msg?: string): void;
+
+        isNumber(val: any, msg?: string): void;
+        isNotNumber(val: any, msg?: string): void;
+
+        isBoolean(val: any, msg?: string): void;
+        isNotBoolean(val: any, msg?: string): void;
+
+        typeOf(val: any, type: string, msg?: string): void;
+        notTypeOf(val: any, type: string, msg?: string): void;
+
+        instanceOf(val: any, type: Function, msg?: string): void;
+        notInstanceOf(val: any, type: Function, msg?: string): void;
+
+        include(exp: string, inc: any, msg?: string): void;
+        include(exp: any[], inc: any, msg?: string): void;
+
+        notInclude(exp: string, inc: any, msg?: string): void;
+        notInclude(exp: any[], inc: any, msg?: string): void;
+
+        match(exp: any, re: RegExp, msg?: string): void;
+        notMatch(exp: any, re: RegExp, msg?: string): void;
+
+        property(obj: Object, prop: string, msg?: string): void;
+        notProperty(obj: Object, prop: string, msg?: string): void;
+        deepProperty(obj: Object, prop: string, msg?: string): void;
+        notDeepProperty(obj: Object, prop: string, msg?: string): void;
+
+        propertyVal(obj: Object, prop: string, val: any, msg?: string): void;
+        propertyNotVal(obj: Object, prop: string, val: any, msg?: string): void;
+
+        deepPropertyVal(obj: Object, prop: string, val: any, msg?: string): void;
+        deepPropertyNotVal(obj: Object, prop: string, val: any, msg?: string): void;
+
+        lengthOf(exp: any, len: number, msg?: string): void;
+        //alias frenzy
+        throw(fn: Function, msg?: string): void;
+        throw(fn: Function, regExp: RegExp): void;
+        throw(fn: Function, errType: Function, msg?: string): void;
+        throw(fn: Function, errType: Function, regExp: RegExp): void;
+
+        throws(fn: Function, msg?: string): void;
+        throws(fn: Function, regExp: RegExp): void;
+        throws(fn: Function, errType: Function, msg?: string): void;
+        throws(fn: Function, errType: Function, regExp: RegExp): void;
+
+        Throw(fn: Function, msg?: string): void;
+        Throw(fn: Function, regExp: RegExp): void;
+        Throw(fn: Function, errType: Function, msg?: string): void;
+        Throw(fn: Function, errType: Function, regExp: RegExp): void;
+
+        doesNotThrow(fn: Function, msg?: string): void;
+        doesNotThrow(fn: Function, regExp: RegExp): void;
+        doesNotThrow(fn: Function, errType: Function, msg?: string): void;
+        doesNotThrow(fn: Function, errType: Function, regExp: RegExp): void;
+
+        operator(val: any, operator: string, val2: any, msg?: string): void;
+        closeTo(act: number, exp: number, delta: number, msg?: string): void;
+
+        sameMembers(set1: any[], set2: any[], msg?: string): void;
+        sameDeepMembers(set1: any[], set2: any[], msg?: string): void;
+        includeMembers(superset: any[], subset: any[], msg?: string): void;
+
+        ifError(val: any, msg?: string): void;
+
+        isExtensible(obj: {}, msg?: string): void;
+        extensible(obj: {}, msg?: string): void;
+        isNotExtensible(obj: {}, msg?: string): void;
+        notExtensible(obj: {}, msg?: string): void;
+
+        isSealed(obj: {}, msg?: string): void;
+        sealed(obj: {}, msg?: string): void;
+        isNotSealed(obj: {}, msg?: string): void;
+        notSealed(obj: {}, msg?: string): void;
+
+        isFrozen(obj: Object, msg?: string): void;
+        frozen(obj: Object, msg?: string): void;
+        isNotFrozen(obj: Object, msg?: string): void;
+        notFrozen(obj: Object, msg?: string): void;
+
+
+    }
+
+    export interface Config {
+        includeStack: boolean;
+    }
+
+    export class AssertionError {
+        constructor(message: string, _props?: any, ssf?: Function);
+        name: string;
+        message: string;
+        showDiff: boolean;
+        stack: string;
+    }
+}
+
+declare var chai: Chai.ChaiStatic;
+
+declare module "chai" {
+    export = chai;
+}
+
+interface Object {
+    should: Chai.Assertion;
+}

samples/react-sp-elevatedprivileges/webpart/typings/combokeys/combokeys.d.ts

@@ -0,0 +1,107 @@
+// Type definitions for Combokeys v2.4.6
+// Project: https://github.com/PolicyStat/combokeys
+// Definitions by: Ian Clanton-Thuon <https://github.com/iclanton>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare namespace Combokeys {
+    interface CombokeysStatic {
+        new (element: Element): Combokeys;
+
+        /**
+         * all instances of Combokeys
+         */
+        instances: Combokeys[];
+
+        /**
+         * reset all instances
+         */
+        reset(): void;
+    }
+
+    interface Combokeys {
+        element: Element;
+
+        /**
+         * binds an event to Combokeys
+         *
+         * can be a single key, a combination of keys separated with +,
+         * an array of keys, or a sequence of keys separated by spaces
+         *
+         * be sure to list the modifier keys first to make sure that the
+         * correct key ends up getting bound (the last key in the pattern)
+         *
+         * @param {keys} key combination or combinations
+         * @param {callback} callback function
+         * @param {handler} optional - one of "keypress", "keydown", or "keyup"
+         * @returns void
+         */
+        bind(keys: string | string[], callback: () => void, action?: string): void;
+
+
+        /**
+         * binds multiple combinations to the same callback
+         *
+         * @param {keys} key combinations
+         * @param {callback} callback function
+         * @param {handler} optional - one of "keypress", "keydown", or "keyup"
+         * @returns void
+         */
+        bindMultiple(keys: string[], callback: () => void, action?: string): void;
+
+        /**
+         * unbinds an event to Combokeys
+         *
+         * the unbinding sets the callback function of the specified key combo
+         * to an empty function and deletes the corresponding key in the
+         * directMap dict.
+         *
+         * the keycombo+action has to be exactly the same as
+         * it was defined in the bind method
+         *
+         * @param {keys} key combination or combinations
+         * @param {action} optional - one of "keypress", "keydown", or "keyup"
+         * @returns void
+         */
+        unbind(keys: string | string[], action?: string): void;
+
+        /**
+         * triggers an event that has already been bound
+         *
+         * @param {keys} key combination
+         * @param {action} optional - one of "keypress", "keydown", or "keyup"
+         * @returns void
+         */
+        trigger(keys: string, action?: string): void;
+
+        /**
+         * resets the library back to its initial state. This is useful
+         * if you want to clear out the current keyboard shortcuts and bind
+         * new ones - for example if you switch to another page
+         *
+         * @returns void
+         */
+        reset(): void;
+
+        /**
+         * should we stop this event before firing off callbacks
+         *
+         * @param {e} event
+         * @param {element} bound element
+         * @return {boolean}
+         */
+        stopCallback(e: Event, element: Element): boolean;
+
+        /**
+         * detach all listners from the bound element
+         *
+         * @return {void}
+         */
+        detach(): void;
+    }
+}
+
+declare var combokeys: Combokeys.CombokeysStatic;
+
+declare module "combokeys" {
+    export = combokeys;
+}

samples/react-sp-elevatedprivileges/webpart/typings/es6-collections/es6-collections.d.ts

@@ -0,0 +1,113 @@
+// Type definitions for es6-collections v0.5.1
+// Project: https://github.com/WebReflection/es6-collections/
+// Definitions by: Ron Buckton <http://github.com/rbuckton>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/* *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+interface IteratorResult<T> {
+    done: boolean;
+    value?: T;
+}
+
+interface Iterator<T> {
+    next(value?: any): IteratorResult<T>;
+    return?(value?: any): IteratorResult<T>;
+    throw?(e?: any): IteratorResult<T>;
+}
+
+interface ForEachable<T> {
+    forEach(callbackfn: (value: T) => void): void;
+}
+
+interface Map<K, V> {
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackfn: (value: V, index: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get(key: K): V;
+    has(key: K): boolean;
+    set(key: K, value?: V): Map<K, V>;
+    entries(): Iterator<[K, V]>;
+    keys(): Iterator<K>;
+    values(): Iterator<V>;
+    size: number;
+}
+
+interface MapConstructor {
+    new <K, V>(): Map<K, V>;
+    new <K, V>(iterable: ForEachable<[K, V]>): Map<K, V>;
+    prototype: Map<any, any>;
+}
+
+declare var Map: MapConstructor;
+
+interface Set<T> {
+    add(value: T): Set<T>;
+    clear(): void;
+    delete(value: T): boolean;
+    forEach(callbackfn: (value: T, index: T, set: Set<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    entries(): Iterator<[T, T]>;
+    keys(): Iterator<T>;
+    values(): Iterator<T>;
+    size: number;
+}
+
+interface SetConstructor {
+    new <T>(): Set<T>;
+    new <T>(iterable: ForEachable<T>): Set<T>;
+    prototype: Set<any>;
+}
+
+declare var Set: SetConstructor;
+
+interface WeakMap<K, V> {
+    delete(key: K): boolean;
+	clear(): void;
+    get(key: K): V;
+    has(key: K): boolean;
+    set(key: K, value?: V): WeakMap<K, V>;
+}
+
+interface WeakMapConstructor {
+    new <K, V>(): WeakMap<K, V>;
+    new <K, V>(iterable: ForEachable<[K, V]>): WeakMap<K, V>;
+    prototype: WeakMap<any, any>;
+}
+
+declare var WeakMap: WeakMapConstructor;
+
+interface WeakSet<T> {
+    delete(value: T): boolean;
+	clear(): void;
+    add(value: T): WeakSet<T>;
+    has(value: T): boolean;
+}
+
+interface WeakSetConstructor {
+    new <T>(): WeakSet<T>;
+    new <T>(iterable: ForEachable<T>): WeakSet<T>;
+    prototype: WeakSet<any>;
+}
+
+declare var WeakSet: WeakSetConstructor;
+
+declare module "es6-collections" {
+    var Map: MapConstructor;
+    var Set: SetConstructor;
+    var WeakMap: WeakMapConstructor;
+    var WeakSet: WeakSetConstructor;
+}

samples/react-sp-elevatedprivileges/webpart/typings/es6-promise/es6-promise.d.ts

@@ -0,0 +1,74 @@
+// Type definitions for es6-promise
+// Project: https://github.com/jakearchibald/ES6-Promise
+// Definitions by: François de Campredon <https://github.com/fdecampredon/>, vvakame <https://github.com/vvakame>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface Thenable<R> {
+    then<U>(onFulfilled?: (value: R) => U | Thenable<U>, onRejected?: (error: any) => U | Thenable<U>): Thenable<U>;
+    then<U>(onFulfilled?: (value: R) => U | Thenable<U>, onRejected?: (error: any) => void): Thenable<U>;
+    catch<U>(onRejected?: (error: any) => U | Thenable<U>): Thenable<U>;
+}
+
+declare class Promise<R> implements Thenable<R> {
+	/**
+	 * If you call resolve in the body of the callback passed to the constructor,
+	 * your promise is fulfilled with result object passed to resolve.
+	 * If you call reject your promise is rejected with the object passed to reject.
+	 * For consistency and debugging (eg stack traces), obj should be an instanceof Error.
+	 * Any errors thrown in the constructor callback will be implicitly passed to reject().
+	 */
+	constructor(callback: (resolve : (value?: R | Thenable<R>) => void, reject: (error?: any) => void) => void);
+
+	/**
+	 * onFulfilled is called when/if "promise" resolves. onRejected is called when/if "promise" rejects.
+	 * Both are optional, if either/both are omitted the next onFulfilled/onRejected in the chain is called.
+	 * Both callbacks have a single parameter , the fulfillment value or rejection reason.
+	 * "then" returns a new promise equivalent to the value you return from onFulfilled/onRejected after being passed through Promise.resolve.
+	 * If an error is thrown in the callback, the returned promise rejects with that error.
+	 *
+	 * @param onFulfilled called when/if "promise" resolves
+	 * @param onRejected called when/if "promise" rejects
+	 */
+    then<U>(onFulfilled?: (value: R) => U | Thenable<U>, onRejected?: (error: any) => U | Thenable<U>): Promise<U>;
+    then<U>(onFulfilled?: (value: R) => U | Thenable<U>, onRejected?: (error: any) => void): Promise<U>;
+
+	/**
+	 * Sugar for promise.then(undefined, onRejected)
+	 *
+	 * @param onRejected called when/if "promise" rejects
+	 */
+	catch<U>(onRejected?: (error: any) => U | Thenable<U>): Promise<U>;
+}
+
+declare module Promise {
+	/**
+	 * Make a new promise from the thenable.
+	 * A thenable is promise-like in as far as it has a "then" method.
+	 */
+	function resolve<R>(value?: R | Thenable<R>): Promise<R>;
+
+	/**
+	 * Make a promise that rejects to obj. For consistency and debugging (eg stack traces), obj should be an instanceof Error
+	 */
+	function reject(error: any): Promise<any>;
+
+	/**
+	 * Make a promise that fulfills when every item in the array fulfills, and rejects if (and when) any item rejects.
+	 * the array passed to all can be a mixture of promise-like objects and other objects.
+	 * The fulfillment value is an array (in order) of fulfillment values. The rejection value is the first rejection value.
+	 */
+	function all<R>(promises: (R | Thenable<R>)[]): Promise<R[]>;
+
+	/**
+	 * Make a Promise that fulfills when any item fulfills, and rejects if any item rejects.
+	 */
+	function race<R>(promises: (R | Thenable<R>)[]): Promise<R>;
+}
+
+declare module 'es6-promise' {
+	var foo: typeof Promise; // Temp variable to reference Promise in local context
+	module rsvp {
+		export var Promise: typeof foo;
+	}
+	export = rsvp;
+}

samples/react-sp-elevatedprivileges/webpart/typings/knockout/knockout.d.ts

@@ -0,0 +1,631 @@
+// Type definitions for Knockout v3.2.0
+// Project: http://knockoutjs.com
+// Definitions by: Boris Yankov <https://github.com/borisyankov/>, Igor Oleinikov <https://github.com/Igorbek/>, Clément Bourgeois <https://github.com/moonpyk/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+interface KnockoutSubscribableFunctions<T> {
+    [key: string]: KnockoutBindingHandler;
+
+	notifySubscribers(valueToWrite?: T, event?: string): void;
+}
+
+interface KnockoutComputedFunctions<T> {
+    [key: string]: KnockoutBindingHandler;
+}
+
+interface KnockoutObservableFunctions<T> {
+    [key: string]: KnockoutBindingHandler;
+
+	equalityComparer(a: any, b: any): boolean;
+}
+
+interface KnockoutObservableArrayFunctions<T> {
+    // General Array functions
+    indexOf(searchElement: T, fromIndex?: number): number;
+    slice(start: number, end?: number): T[];
+    splice(start: number): T[];
+    splice(start: number, deleteCount: number, ...items: T[]): T[];
+    pop(): T;
+    push(...items: T[]): void;
+    shift(): T;
+    unshift(...items: T[]): number;
+    reverse(): KnockoutObservableArray<T>;
+    sort(): KnockoutObservableArray<T>;
+    sort(compareFunction: (left: T, right: T) => number): KnockoutObservableArray<T>;
+
+    // Ko specific
+    [key: string]: KnockoutBindingHandler;
+
+    replace(oldItem: T, newItem: T): void;
+
+    remove(item: T): T[];
+    remove(removeFunction: (item: T) => boolean): T[];
+    removeAll(items: T[]): T[];
+    removeAll(): T[];
+
+    destroy(item: T): void;
+    destroy(destroyFunction: (item: T) => boolean): void;
+    destroyAll(items: T[]): void;
+    destroyAll(): void;
+}
+
+interface KnockoutSubscribableStatic {
+    fn: KnockoutSubscribableFunctions<any>;
+
+    new <T>(): KnockoutSubscribable<T>;
+}
+
+interface KnockoutSubscription {
+	dispose(): void;
+}
+
+interface KnockoutSubscribable<T> extends KnockoutSubscribableFunctions<T> {
+	subscribe(callback: (newValue: T) => void, target?: any, event?: string): KnockoutSubscription;
+	subscribe<TEvent>(callback: (newValue: TEvent) => void, target: any, event: string): KnockoutSubscription;
+	extend(requestedExtenders: { [key: string]: any; }): KnockoutSubscribable<T>;
+	getSubscriptionsCount(): number;
+}
+
+interface KnockoutComputedStatic {
+    fn: KnockoutComputedFunctions<any>;
+
+    <T>(): KnockoutComputed<T>;
+    <T>(func: () => T, context?: any, options?: any): KnockoutComputed<T>;
+    <T>(def: KnockoutComputedDefine<T>, context?: any): KnockoutComputed<T>;
+}
+
+interface KnockoutComputed<T> extends KnockoutObservable<T>, KnockoutComputedFunctions<T> {
+	fn: KnockoutComputedFunctions<any>;
+
+	dispose(): void;
+	isActive(): boolean;
+	getDependenciesCount(): number;
+    extend(requestedExtenders: { [key: string]: any; }): KnockoutComputed<T>;
+}
+
+interface KnockoutObservableArrayStatic {
+    fn: KnockoutObservableArrayFunctions<any>;
+
+    <T>(value?: T[]): KnockoutObservableArray<T>;
+}
+
+interface KnockoutObservableArray<T> extends KnockoutObservable<T[]>, KnockoutObservableArrayFunctions<T> {
+    extend(requestedExtenders: { [key: string]: any; }): KnockoutObservableArray<T>;
+}
+
+interface KnockoutObservableStatic {
+    fn: KnockoutObservableFunctions<any>;
+
+    <T>(value?: T): KnockoutObservable<T>;
+}
+
+interface KnockoutObservable<T> extends KnockoutSubscribable<T>, KnockoutObservableFunctions<T> {
+	(): T;
+	(value: T): void;
+
+	peek(): T;
+	valueHasMutated?:{(): void;};
+	valueWillMutate?:{(): void;};
+    extend(requestedExtenders: { [key: string]: any; }): KnockoutObservable<T>;
+}
+
+interface KnockoutComputedDefine<T> {
+	read(): T;
+	write? (value: T): void;
+	disposeWhenNodeIsRemoved?: Node;
+	disposeWhen? (): boolean;
+	owner?: any;
+	deferEvaluation?: boolean;
+	pure?: boolean;
+}
+
+interface KnockoutBindingContext {
+    $parent: any;
+    $parents: any[];
+    $root: any;
+    $data: any;
+    $rawData: any | KnockoutObservable<any>;
+    $index?: KnockoutObservable<number>;
+    $parentContext?: KnockoutBindingContext;
+    $component: any;
+    $componentTemplateNodes: Node[];
+
+    extend(properties: any): any;
+    createChildContext(dataItemOrAccessor: any, dataItemAlias?: any, extendCallback?: Function): any;
+}
+
+interface KnockoutAllBindingsAccessor {
+    (): any;
+    get(name: string): any;
+    has(name: string): boolean;
+}
+
+interface KnockoutBindingHandler {
+    after?: Array<string>;
+    init?: (element: any, valueAccessor: () => any, allBindingsAccessor?: KnockoutAllBindingsAccessor, viewModel?: any, bindingContext?: KnockoutBindingContext) => void | { controlsDescendantBindings: boolean; };
+    update?: (element: any, valueAccessor: () => any, allBindingsAccessor?: KnockoutAllBindingsAccessor, viewModel?: any, bindingContext?: KnockoutBindingContext) => void;
+    options?: any;
+    preprocess?: (value: string, name: string, addBindingCallback?: (name: string, value: string) => void) => string;
+}
+
+interface KnockoutBindingHandlers {
+    [bindingHandler: string]: KnockoutBindingHandler;
+
+    // Controlling text and appearance
+    visible: KnockoutBindingHandler;
+    text: KnockoutBindingHandler;
+    html: KnockoutBindingHandler;
+    css: KnockoutBindingHandler;
+    style: KnockoutBindingHandler;
+    attr: KnockoutBindingHandler;
+
+    // Control Flow
+    foreach: KnockoutBindingHandler;
+    if: KnockoutBindingHandler;
+    ifnot: KnockoutBindingHandler;
+    with: KnockoutBindingHandler;
+
+    // Working with form fields
+    click: KnockoutBindingHandler;
+    event: KnockoutBindingHandler;
+    submit: KnockoutBindingHandler;
+    enable: KnockoutBindingHandler;
+    disable: KnockoutBindingHandler;
+    value: KnockoutBindingHandler;
+    textInput: KnockoutBindingHandler;
+    hasfocus: KnockoutBindingHandler;
+    checked: KnockoutBindingHandler;
+    options: KnockoutBindingHandler;
+    selectedOptions: KnockoutBindingHandler;
+    uniqueName: KnockoutBindingHandler;
+
+    // Rendering templates
+	template: KnockoutBindingHandler;
+
+	// Components (new for v3.2)
+	component: KnockoutBindingHandler;
+}
+
+interface KnockoutMemoization {
+    memoize(callback: () => string): string;
+    unmemoize(memoId: string, callbackParams: any[]): boolean;
+    unmemoizeDomNodeAndDescendants(domNode: any, extraCallbackParamsArray: any[]): boolean;
+    parseMemoText(memoText: string): string;
+}
+
+interface KnockoutVirtualElement {}
+
+interface KnockoutVirtualElements {
+    allowedBindings: { [bindingName: string]: boolean; };
+    emptyNode(node: KnockoutVirtualElement ): void;
+    firstChild(node: KnockoutVirtualElement ): KnockoutVirtualElement;
+    insertAfter( container: KnockoutVirtualElement, nodeToInsert: Node, insertAfter: Node ): void;
+    nextSibling(node: KnockoutVirtualElement): Node;
+    prepend(node: KnockoutVirtualElement, toInsert: Node ): void;
+    setDomNodeChildren(node: KnockoutVirtualElement, newChildren: { length: number;[index: number]: Node; } ): void;
+    childNodes(node: KnockoutVirtualElement ): Node[];
+}
+
+interface KnockoutExtenders {
+    throttle(target: any, timeout: number): KnockoutComputed<any>;
+	notify(target: any, notifyWhen: string): any;
+
+	rateLimit(target: any, timeout: number): any;
+	rateLimit(target: any, options: { timeout: number; method?: string; }): any;
+
+	trackArrayChanges(target: any): any;
+}
+
+//
+// NOTE TO MAINTAINERS AND CONTRIBUTORS : pay attention to only include symbols that are
+// publicly exported in the minified version of ko, without that you can give the false
+// impression that some functions will be available in production builds.
+//
+interface KnockoutUtils {
+    //////////////////////////////////
+    // utils.domData.js
+    //////////////////////////////////
+
+    domData: {
+        get (node: Element, key: string): any;
+
+        set (node: Element, key: string, value: any): void;
+
+        getAll(node: Element, createIfNotFound: boolean): any;
+
+        clear(node: Element): boolean;
+    };
+
+    //////////////////////////////////
+    // utils.domNodeDisposal.js
+    //////////////////////////////////
+
+    domNodeDisposal: {
+        addDisposeCallback(node: Element, callback: Function): void;
+
+        removeDisposeCallback(node: Element, callback: Function): void;
+
+        cleanNode(node: Node): Element;
+
+        removeNode(node: Node): void;
+    };
+
+    addOrRemoveItem<T>(array: T[] | KnockoutObservable<T>, value: T, included: T): void;
+
+    arrayFilter<T>(array: T[], predicate: (item: T) => boolean): T[];
+
+    arrayFirst<T>(array: T[], predicate: (item: T) => boolean, predicateOwner?: any): T;
+
+    arrayForEach<T>(array: T[], action: (item: T, index: number) => void): void;
+
+    arrayGetDistinctValues<T>(array: T[]): T[];
+
+    arrayIndexOf<T>(array: T[], item: T): number;
+
+    arrayMap<T, U>(array: T[], mapping: (item: T) => U): U[];
+
+    arrayPushAll<T>(array: T[] | KnockoutObservableArray<T>, valuesToPush: T[]): T[];
+
+    arrayRemoveItem(array: any[], itemToRemove: any): void;
+
+    compareArrays<T>(a: T[], b: T[]): Array<KnockoutArrayChange<T>>;
+
+    extend(target: Object, source: Object): Object;
+
+    fieldsIncludedWithJsonPost: any[];
+
+    getFormFields(form: any, fieldName: string): any[];
+
+    objectForEach(obj: any, action: (key: any, value: any) => void): void;
+
+    parseHtmlFragment(html: string): any[];
+
+    parseJson(jsonString: string): any;
+
+    postJson(urlOrForm: any, data: any, options: any): void;
+
+    peekObservable<T>(value: KnockoutObservable<T>): T;
+
+    range(min: any, max: any): any;
+
+    registerEventHandler(element: any, eventType: any, handler: Function): void;
+
+    setHtml(node: Element, html: () => string): void;
+
+    setHtml(node: Element, html: string): void;
+
+    setTextContent(element: any, textContent: string | KnockoutObservable<string>): void;
+
+    stringifyJson(data: any, replacer?: Function, space?: string): string;
+
+    toggleDomNodeCssClass(node: any, className: string, shouldHaveClass: boolean): void;
+
+    triggerEvent(element: any, eventType: any): void;
+
+    unwrapObservable<T>(value: KnockoutObservable<T> | T): T;
+
+    // NOT PART OF THE MINIFIED API SURFACE (ONLY IN knockout-{version}.debug.js) https://github.com/SteveSanderson/knockout/issues/670
+    // forceRefresh(node: any): void;
+    // ieVersion: number;
+    // isIe6: boolean;
+    // isIe7: boolean;
+    // jQueryHtmlParse(html: string): any[];
+    // makeArray(arrayLikeObject: any): any[];
+    // moveCleanedNodesToContainerElement(nodes: any[]): HTMLElement;
+    // replaceDomNodes(nodeToReplaceOrNodeArray: any, newNodesArray: any[]): void;
+    // setDomNodeChildren(domNode: any, childNodes: any[]): void;
+    // setElementName(element: any, name: string): void;
+    // setOptionNodeSelectionState(optionNode: any, isSelected: boolean): void;
+    // simpleHtmlParse(html: string): any[];
+    // stringStartsWith(str: string, startsWith: string): boolean;
+    // stringTokenize(str: string, delimiter: string): string[];
+    // stringTrim(str: string): string;
+    // tagNameLower(element: any): string;
+}
+
+interface KnockoutArrayChange<T> {
+    status: string;
+    value: T;
+    index: number;
+    moved?: number;
+}
+
+//////////////////////////////////
+// templateSources.js
+//////////////////////////////////
+
+interface KnockoutTemplateSourcesDomElement {
+    text(): any;
+    text(value: any): void;
+
+    data(key: string): any;
+    data(key: string, value: any): any;
+}
+
+interface KnockoutTemplateAnonymous extends KnockoutTemplateSourcesDomElement {
+	nodes(): any;
+	nodes(value: any): void;
+}
+
+interface KnockoutTemplateSources {
+
+    domElement: {
+	    prototype: KnockoutTemplateSourcesDomElement
+	    new (element: Element): KnockoutTemplateSourcesDomElement
+    };
+
+    anonymousTemplate: {
+		prototype: KnockoutTemplateAnonymous;
+		new (element: Element): KnockoutTemplateAnonymous;
+    };
+}
+
+//////////////////////////////////
+// nativeTemplateEngine.js
+//////////////////////////////////
+
+interface KnockoutNativeTemplateEngine {
+
+    renderTemplateSource(templateSource: Object, bindingContext?: KnockoutBindingContext, options?: Object): any[];
+}
+
+//////////////////////////////////
+// templateEngine.js
+//////////////////////////////////
+
+interface KnockoutTemplateEngine extends KnockoutNativeTemplateEngine {
+
+    createJavaScriptEvaluatorBlock(script: string): string;
+
+    makeTemplateSource(template: any, templateDocument?: Document): any;
+
+    renderTemplate(template: any, bindingContext: KnockoutBindingContext, options: Object, templateDocument: Document): any;
+
+    isTemplateRewritten(template: any, templateDocument: Document): boolean;
+
+    rewriteTemplate(template: any, rewriterCallback: Function, templateDocument: Document): void;
+}
+
+/////////////////////////////////
+
+interface KnockoutStatic {
+    utils: KnockoutUtils;
+    memoization: KnockoutMemoization;
+
+	bindingHandlers: KnockoutBindingHandlers;
+	getBindingHandler(handler: string): KnockoutBindingHandler;
+
+    virtualElements: KnockoutVirtualElements;
+    extenders: KnockoutExtenders;
+
+    applyBindings(viewModelOrBindingContext?: any, rootNode?: any): void;
+	applyBindingsToDescendants(viewModelOrBindingContext: any, rootNode: any): void;
+	applyBindingAccessorsToNode(node: Node, bindings: (bindingContext: KnockoutBindingContext, node: Node) => {}, bindingContext: KnockoutBindingContext): void;
+	applyBindingAccessorsToNode(node: Node, bindings: {}, bindingContext: KnockoutBindingContext): void;
+	applyBindingAccessorsToNode(node: Node, bindings: (bindingContext: KnockoutBindingContext, node: Node) => {}, viewModel: any): void;
+	applyBindingAccessorsToNode(node: Node, bindings: {}, viewModel: any): void;
+    applyBindingsToNode(node: Node, bindings: any, viewModelOrBindingContext?: any): any;
+
+    subscribable: KnockoutSubscribableStatic;
+    observable: KnockoutObservableStatic;
+
+	computed: KnockoutComputedStatic;
+	pureComputed<T>(evaluatorFunction: () => T, context?: any): KnockoutComputed<T>;
+	pureComputed<T>(options: KnockoutComputedDefine<T>, context?: any): KnockoutComputed<T>;
+
+    observableArray: KnockoutObservableArrayStatic;
+
+    contextFor(node: any): any;
+    isSubscribable(instance: any): boolean;
+    toJSON(viewModel: any, replacer?: Function, space?: any): string;
+    toJS(viewModel: any): any;
+    isObservable(instance: any): boolean;
+    isWriteableObservable(instance: any): boolean;
+    isComputed(instance: any): boolean;
+    dataFor(node: any): any;
+    removeNode(node: Element): void;
+    cleanNode(node: Element): Element;
+    renderTemplate(template: Function, viewModel: any, options?: any, target?: any, renderMode?: any): any;
+    renderTemplate(template: string, viewModel: any, options?: any, target?: any, renderMode?: any): any;
+	unwrap<T>(value: KnockoutObservable<T> | T): T;
+
+	computedContext: KnockoutComputedContext;
+
+    //////////////////////////////////
+    // templateSources.js
+    //////////////////////////////////
+
+    templateSources: KnockoutTemplateSources;
+
+    //////////////////////////////////
+    // templateEngine.js
+    //////////////////////////////////
+
+    templateEngine: {
+
+        prototype: KnockoutTemplateEngine;
+
+        new (): KnockoutTemplateEngine;
+    };
+
+    //////////////////////////////////
+    // templateRewriting.js
+    //////////////////////////////////
+
+    templateRewriting: {
+
+        ensureTemplateIsRewritten(template: Node, templateEngine: KnockoutTemplateEngine, templateDocument: Document): any;
+        ensureTemplateIsRewritten(template: string, templateEngine: KnockoutTemplateEngine, templateDocument: Document): any;
+
+        memoizeBindingAttributeSyntax(htmlString: string, templateEngine: KnockoutTemplateEngine): any;
+
+        applyMemoizedBindingsToNextSibling(bindings: any, nodeName: string): string;
+    };
+
+    //////////////////////////////////
+    // nativeTemplateEngine.js
+    //////////////////////////////////
+
+    nativeTemplateEngine: {
+
+        prototype: KnockoutNativeTemplateEngine;
+
+        new (): KnockoutNativeTemplateEngine;
+
+        instance: KnockoutNativeTemplateEngine;
+    };
+
+    //////////////////////////////////
+    // jqueryTmplTemplateEngine.js
+    //////////////////////////////////
+
+    jqueryTmplTemplateEngine: {
+
+        prototype: KnockoutTemplateEngine;
+
+        renderTemplateSource(templateSource: Object, bindingContext: KnockoutBindingContext, options: Object): Node[];
+
+        createJavaScriptEvaluatorBlock(script: string): string;
+
+        addTemplate(templateName: string, templateMarkup: string): void;
+    };
+
+    //////////////////////////////////
+    // templating.js
+    //////////////////////////////////
+
+    setTemplateEngine(templateEngine: KnockoutNativeTemplateEngine): void;
+
+    renderTemplate(template: Function, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any;
+    renderTemplate(template: any, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any;
+    renderTemplate(template: Function, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any;
+    renderTemplate(template: any, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any;
+    renderTemplate(template: Function, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any;
+    renderTemplate(template: any, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any;
+    renderTemplate(template: Function, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any;
+    renderTemplate(template: any, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any;
+
+    renderTemplateForEach(template: Function, arrayOrObservableArray: any[], options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any;
+    renderTemplateForEach(template: any, arrayOrObservableArray: any[], options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any;
+    renderTemplateForEach(template: Function, arrayOrObservableArray: KnockoutObservable<any>, options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any;
+    renderTemplateForEach(template: any, arrayOrObservableArray: KnockoutObservable<any>, options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any;
+
+    expressionRewriting: {
+        bindingRewriteValidators: any;
+        parseObjectLiteral: { (objectLiteralString: string): any[] }
+    };
+
+    /////////////////////////////////
+
+	bindingProvider: {
+		instance: KnockoutBindingProvider;
+		new (): KnockoutBindingProvider;
+	}
+
+    /////////////////////////////////
+    // selectExtensions.js
+    /////////////////////////////////
+
+    selectExtensions: {
+
+        readValue(element: HTMLElement): any;
+
+        writeValue(element: HTMLElement, value: any): void;
+    };
+
+    components: KnockoutComponents;
+}
+
+interface KnockoutBindingProvider {
+	nodeHasBindings(node: Node): boolean;
+	getBindings(node: Node, bindingContext: KnockoutBindingContext): {};
+	getBindingAccessors?(node: Node, bindingContext: KnockoutBindingContext): { [key: string]: string; };
+}
+
+interface KnockoutComputedContext {
+	getDependenciesCount(): number;
+	isInitial: () => boolean;
+	isSleeping: boolean;
+}
+
+//
+// refactored types into a namespace to reduce global pollution
+// and used Union Types to simplify overloads (requires TypeScript 1.4)
+//
+declare module KnockoutComponentTypes {
+
+    interface Config {
+        viewModel?: ViewModelFunction | ViewModelSharedInstance | ViewModelFactoryFunction | AMDModule;
+        template: string | Node[]| DocumentFragment | TemplateElement | AMDModule;
+        synchronous?: boolean;
+    }
+
+    interface ComponentConfig {
+        viewModel?: ViewModelFunction | ViewModelSharedInstance | ViewModelFactoryFunction | AMDModule;
+        template: any;
+        createViewModel?: any;
+    }
+
+    interface EmptyConfig {
+    }
+
+    // common AMD type
+    interface AMDModule {
+        require: string;
+    }
+
+    // viewmodel types
+    interface ViewModelFunction {
+        (params?: any): any;
+    }
+
+    interface ViewModelSharedInstance {
+        instance: any;
+    }
+
+    interface ViewModelFactoryFunction {
+        createViewModel: (params?: any, componentInfo?: ComponentInfo) => any;
+    }
+
+    interface ComponentInfo {
+        element: Node;
+        templateNodes: Node[];
+    }
+
+    interface TemplateElement {
+        element: string | Node;
+    }
+
+    interface Loader {
+        getConfig? (componentName: string, callback: (result: ComponentConfig) => void): void;
+        loadComponent? (componentName: string, config: ComponentConfig, callback: (result: Definition) => void): void;
+        loadTemplate? (componentName: string, templateConfig: any, callback: (result: Node[]) => void): void;
+        loadViewModel? (componentName: string, viewModelConfig: any, callback: (result: any) => void): void;
+        suppressLoaderExceptions?: boolean;
+    }
+
+    interface Definition {
+        template: Node[];
+        createViewModel? (params: any, options: { element: Node; }): any;
+    }
+}
+
+interface KnockoutComponents {
+    // overloads for register method:
+    register(componentName: string, config: KnockoutComponentTypes.Config | KnockoutComponentTypes.EmptyConfig): void;
+
+    isRegistered(componentName: string): boolean;
+    unregister(componentName: string): void;
+    get(componentName: string, callback: (definition: KnockoutComponentTypes.Definition) => void): void;
+    clearCachedDefinition(componentName: string): void
+    defaultLoader: KnockoutComponentTypes.Loader;
+    loaders: KnockoutComponentTypes.Loader[];
+    getComponentNameForNode(node: Node): string;
+}
+
+declare var ko: KnockoutStatic;
+
+declare module "knockout" {
+	export = ko;
+}

samples/react-sp-elevatedprivileges/webpart/typings/mocha/mocha.d.ts

@@ -0,0 +1,214 @@
+// Type definitions for mocha 2.2.5
+// Project: http://mochajs.org/
+// Definitions by: Kazi Manzur Rashid <https://github.com/kazimanzurrashid/>, otiai10 <https://github.com/otiai10>, jt000 <https://github.com/jt000>, Vadim Macagon <https://github.com/enlight>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface MochaSetupOptions {
+    //milliseconds to wait before considering a test slow
+    slow?: number;
+
+    // timeout in milliseconds
+    timeout?: number;
+
+    // ui name "bdd", "tdd", "exports" etc
+    ui?: string;
+
+    //array of accepted globals
+    globals?: any[];
+
+    // reporter instance (function or string), defaults to `mocha.reporters.Spec`
+    reporter?: any;
+
+    // bail on the first test failure
+    bail?: boolean;
+
+    // ignore global leaks
+    ignoreLeaks?: boolean;
+
+    // grep string or regexp to filter tests with
+    grep?: any;
+}
+
+interface MochaDone {
+    (error?: Error): void;
+}
+
+declare var mocha: Mocha;
+declare var describe: Mocha.IContextDefinition;
+declare var xdescribe: Mocha.IContextDefinition;
+// alias for `describe`
+declare var context: Mocha.IContextDefinition;
+// alias for `describe`
+declare var suite: Mocha.IContextDefinition;
+declare var it: Mocha.ITestDefinition;
+declare var xit: Mocha.ITestDefinition;
+// alias for `it`
+declare var test: Mocha.ITestDefinition;
+
+declare function before(action: () => void): void;
+
+declare function before(action: (done: MochaDone) => void): void;
+
+declare function setup(action: () => void): void;
+
+declare function setup(action: (done: MochaDone) => void): void;
+
+declare function after(action: () => void): void;
+
+declare function after(action: (done: MochaDone) => void): void;
+
+declare function teardown(action: () => void): void;
+
+declare function teardown(action: (done: MochaDone) => void): void;
+
+declare function beforeEach(action: () => void): void;
+
+declare function beforeEach(action: (done: MochaDone) => void): void;
+
+declare function suiteSetup(action: () => void): void;
+
+declare function suiteSetup(action: (done: MochaDone) => void): void;
+
+declare function afterEach(action: () => void): void;
+
+declare function afterEach(action: (done: MochaDone) => void): void;
+
+declare function suiteTeardown(action: () => void): void;
+
+declare function suiteTeardown(action: (done: MochaDone) => void): void;
+
+declare class Mocha {
+    constructor(options?: {
+        grep?: RegExp;
+        ui?: string;
+        reporter?: string;
+        timeout?: number;
+        bail?: boolean;
+    });
+
+    /** Setup mocha with the given options. */
+    setup(options: MochaSetupOptions): Mocha;
+    bail(value?: boolean): Mocha;
+    addFile(file: string): Mocha;
+    /** Sets reporter by name, defaults to "spec". */
+    reporter(name: string): Mocha;
+    /** Sets reporter constructor, defaults to mocha.reporters.Spec. */
+    reporter(reporter: (runner: Mocha.IRunner, options: any) => any): Mocha;
+    ui(value: string): Mocha;
+    grep(value: string): Mocha;
+    grep(value: RegExp): Mocha;
+    invert(): Mocha;
+    ignoreLeaks(value: boolean): Mocha;
+    checkLeaks(): Mocha;
+    /** Enables growl support. */
+    growl(): Mocha;
+    globals(value: string): Mocha;
+    globals(values: string[]): Mocha;
+    useColors(value: boolean): Mocha;
+    useInlineDiffs(value: boolean): Mocha;
+    timeout(value: number): Mocha;
+    slow(value: number): Mocha;
+    enableTimeouts(value: boolean): Mocha;
+    asyncOnly(value: boolean): Mocha;
+    noHighlighting(value: boolean): Mocha;
+    /** Runs tests and invokes `onComplete()` when finished. */
+    run(onComplete?: (failures: number) => void): Mocha.IRunner;
+}
+
+// merge the Mocha class declaration with a module
+declare module Mocha {
+    /** Partial interface for Mocha's `Runnable` class. */
+    interface IRunnable {
+        title: string;
+        fn: Function;
+        async: boolean;
+        sync: boolean;
+        timedOut: boolean;
+    }
+
+    /** Partial interface for Mocha's `Suite` class. */
+    interface ISuite {
+        parent: ISuite;
+        title: string;
+
+        fullTitle(): string;
+    }
+
+    /** Partial interface for Mocha's `Test` class. */
+    interface ITest extends IRunnable {
+        parent: ISuite;
+        pending: boolean;
+
+        fullTitle(): string;
+    }
+
+    /** Partial interface for Mocha's `Runner` class. */
+    interface IRunner {}
+
+    interface IContextDefinition {
+        (description: string, spec: () => void): ISuite;
+        only(description: string, spec: () => void): ISuite;
+        skip(description: string, spec: () => void): void;
+        timeout(ms: number): void;
+    }
+
+    interface ITestDefinition {
+        (expectation: string, assertion?: () => void): ITest;
+        (expectation: string, assertion?: (done: MochaDone) => void): ITest;
+        only(expectation: string, assertion?: () => void): ITest;
+        only(expectation: string, assertion?: (done: MochaDone) => void): ITest;
+        skip(expectation: string, assertion?: () => void): void;
+        skip(expectation: string, assertion?: (done: MochaDone) => void): void;
+        timeout(ms: number): void;
+    }
+
+    export module reporters {
+        export class Base {
+            stats: {
+                suites: number;
+                tests: number;
+                passes: number;
+                pending: number;
+                failures: number;
+            };
+
+            constructor(runner: IRunner);
+        }
+
+        export class Doc extends Base {}
+        export class Dot extends Base {}
+        export class HTML extends Base {}
+        export class HTMLCov extends Base {}
+        export class JSON extends Base {}
+        export class JSONCov extends Base {}
+        export class JSONStream extends Base {}
+        export class Landing extends Base {}
+        export class List extends Base {}
+        export class Markdown extends Base {}
+        export class Min extends Base {}
+        export class Nyan extends Base {}
+        export class Progress extends Base {
+            /**
+             * @param options.open String used to indicate the start of the progress bar.
+             * @param options.complete String used to indicate a complete test on the progress bar.
+             * @param options.incomplete String used to indicate an incomplete test on the progress bar.
+             * @param options.close String used to indicate the end of the progress bar.
+             */
+            constructor(runner: IRunner, options?: {
+                open?: string;
+                complete?: string;
+                incomplete?: string;
+                close?: string;
+            });
+        }
+        export class Spec extends Base {}
+        export class TAP extends Base {}
+        export class XUnit extends Base {
+            constructor(runner: IRunner, options?: any);
+        }
+    }
+}
+
+declare module "mocha" {
+    export = Mocha;
+}

samples/react-sp-elevatedprivileges/webpart/typings/react/react-addons-shallow-compare.d.ts

@@ -0,0 +1,19 @@
+// Type definitions for React v0.14 (react-addons-css-transition-group)
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="react.d.ts" />
+
+declare namespace __React {
+    namespace __Addons {
+        export function shallowCompare<P, S>(
+            component: __React.Component<P, S>,
+            nextProps: P,
+            nextState: S): boolean;
+    }
+}
+
+declare module "react-addons-shallow-compare" {
+    export = __React.__Addons.shallowCompare;
+}

samples/react-sp-elevatedprivileges/webpart/typings/react/react-addons-test-utils.d.ts

@@ -0,0 +1,155 @@
+// Type definitions for React v0.14 (react-addons-test-utils)
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="react.d.ts" />
+
+declare namespace __React {
+    interface SyntheticEventData {
+        altKey?: boolean;
+        button?: number;
+        buttons?: number;
+        clientX?: number;
+        clientY?: number;
+        changedTouches?: TouchList;
+        charCode?: boolean;
+        clipboardData?: DataTransfer;
+        ctrlKey?: boolean;
+        deltaMode?: number;
+        deltaX?: number;
+        deltaY?: number;
+        deltaZ?: number;
+        detail?: number;
+        getModifierState?(key: string): boolean;
+        key?: string;
+        keyCode?: number;
+        locale?: string;
+        location?: number;
+        metaKey?: boolean;
+        pageX?: number;
+        pageY?: number;
+        relatedTarget?: EventTarget;
+        repeat?: boolean;
+        screenX?: number;
+        screenY?: number;
+        shiftKey?: boolean;
+        targetTouches?: TouchList;
+        touches?: TouchList;
+        view?: AbstractView;
+        which?: number;
+    }
+
+    interface EventSimulator {
+        (element: Element, eventData?: SyntheticEventData): void;
+        (component: Component<any, any>, eventData?: SyntheticEventData): void;
+    }
+
+    interface MockedComponentClass {
+        new(): any;
+    }
+
+    class ShallowRenderer {
+        getRenderOutput<E extends ReactElement<any>>(): E;
+        getRenderOutput(): ReactElement<any>;
+        render(element: ReactElement<any>, context?: any): void;
+        unmount(): void;
+    }
+
+    namespace __Addons {
+        namespace TestUtils {
+            namespace Simulate {
+                export var blur: EventSimulator;
+                export var change: EventSimulator;
+                export var click: EventSimulator;
+                export var cut: EventSimulator;
+                export var doubleClick: EventSimulator;
+                export var drag: EventSimulator;
+                export var dragEnd: EventSimulator;
+                export var dragEnter: EventSimulator;
+                export var dragExit: EventSimulator;
+                export var dragLeave: EventSimulator;
+                export var dragOver: EventSimulator;
+                export var dragStart: EventSimulator;
+                export var drop: EventSimulator;
+                export var focus: EventSimulator;
+                export var input: EventSimulator;
+                export var keyDown: EventSimulator;
+                export var keyPress: EventSimulator;
+                export var keyUp: EventSimulator;
+                export var mouseDown: EventSimulator;
+                export var mouseEnter: EventSimulator;
+                export var mouseLeave: EventSimulator;
+                export var mouseMove: EventSimulator;
+                export var mouseOut: EventSimulator;
+                export var mouseOver: EventSimulator;
+                export var mouseUp: EventSimulator;
+                export var paste: EventSimulator;
+                export var scroll: EventSimulator;
+                export var submit: EventSimulator;
+                export var touchCancel: EventSimulator;
+                export var touchEnd: EventSimulator;
+                export var touchMove: EventSimulator;
+                export var touchStart: EventSimulator;
+                export var wheel: EventSimulator;
+            }
+
+            export function renderIntoDocument(
+                element: DOMElement<any>): Element;
+            export function renderIntoDocument<P>(
+                element: ReactElement<P>): Component<P, any>;
+            export function renderIntoDocument<C extends Component<any, any>>(
+                element: ReactElement<any>): C;
+
+            export function mockComponent(
+                mocked: MockedComponentClass, mockTagName?: string): typeof TestUtils;
+
+            export function isElementOfType(
+                element: ReactElement<any>, type: ReactType): boolean;
+            export function isDOMComponent(instance: ReactInstance): boolean;
+            export function isCompositeComponent(instance: ReactInstance): boolean;
+            export function isCompositeComponentWithType(
+                instance: ReactInstance,
+                type: ComponentClass<any>): boolean;
+
+            export function findAllInRenderedTree(
+                root: Component<any, any>,
+                fn: (i: ReactInstance) => boolean): ReactInstance[];
+
+            export function scryRenderedDOMComponentsWithClass(
+                root: Component<any, any>,
+                className: string): Element[];
+            export function findRenderedDOMComponentWithClass(
+                root: Component<any, any>,
+                className: string): Element;
+
+            export function scryRenderedDOMComponentsWithTag(
+                root: Component<any, any>,
+                tagName: string): Element[];
+            export function findRenderedDOMComponentWithTag(
+                root: Component<any, any>,
+                tagName: string): Element;
+
+            export function scryRenderedComponentsWithType<P>(
+                root: Component<any, any>,
+                type: ComponentClass<P>): Component<P, {}>[];
+            export function scryRenderedComponentsWithType<C extends Component<any, any>>(
+                root: Component<any, any>,
+                type: ComponentClass<any>): C[];
+
+            export function findRenderedComponentWithType<P>(
+                root: Component<any, any>,
+                type: ComponentClass<P>): Component<P, {}>;
+            export function findRenderedComponentWithType<C extends Component<any, any>>(
+                root: Component<any, any>,
+                type: ComponentClass<any>): C;
+
+            export function createRenderer(): ShallowRenderer;
+        }
+    }
+}
+
+declare module "react-addons-test-utils" {
+    import TestUtils = __React.__Addons.TestUtils;
+    export = TestUtils;
+}

samples/react-sp-elevatedprivileges/webpart/typings/react/react-addons-update.d.ts

@@ -0,0 +1,35 @@
+// Type definitions for React v0.14 (react-addons-update)
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="react.d.ts" />
+
+declare namespace __React {
+    interface UpdateSpecCommand {
+        $set?: any;
+        $merge?: {};
+        $apply?(value: any): any;
+    }
+
+    interface UpdateSpecPath {
+        [key: string]: UpdateSpec;
+    }
+
+    type UpdateSpec = UpdateSpecCommand | UpdateSpecPath;
+
+    interface UpdateArraySpec extends UpdateSpecCommand {
+        $push?: any[];
+        $unshift?: any[];
+        $splice?: any[][];
+    }
+
+    namespace __Addons {
+        export function update(value: any[], spec: UpdateArraySpec): any[];
+        export function update(value: {}, spec: UpdateSpec): any;
+    }
+}
+
+declare module "react-addons-update" {
+    export = __React.__Addons.update;
+}

samples/react-sp-elevatedprivileges/webpart/typings/react/react-dom.d.ts

@@ -0,0 +1,66 @@
+// Type definitions for React v0.14 (react-dom)
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="react.d.ts" />
+
+declare namespace __React {
+    namespace __DOM {
+        function findDOMNode<E extends Element>(instance: ReactInstance): E;
+        function findDOMNode(instance: ReactInstance): Element;
+
+        function render<P>(
+            element: DOMElement<P>,
+            container: Element,
+            callback?: (element: Element) => any): Element;
+        function render<P, S>(
+            element: ClassicElement<P>,
+            container: Element,
+            callback?: (component: ClassicComponent<P, S>) => any): ClassicComponent<P, S>;
+        function render<P, S>(
+            element: ReactElement<P>,
+            container: Element,
+            callback?: (component: Component<P, S>) => any): Component<P, S>;
+
+        function unmountComponentAtNode(container: Element): boolean;
+
+        var version: string;
+
+        function unstable_batchedUpdates<A, B>(callback: (a: A, b: B) => any, a: A, b: B): void;
+        function unstable_batchedUpdates<A>(callback: (a: A) => any, a: A): void;
+        function unstable_batchedUpdates(callback: () => any): void;
+
+        function unstable_renderSubtreeIntoContainer<P>(
+            parentComponent: Component<any, any>,
+            nextElement: DOMElement<P>,
+            container: Element,
+            callback?: (element: Element) => any): Element;
+        function unstable_renderSubtreeIntoContainer<P, S>(
+            parentComponent: Component<any, any>,
+            nextElement: ClassicElement<P>,
+            container: Element,
+            callback?: (component: ClassicComponent<P, S>) => any): ClassicComponent<P, S>;
+        function unstable_renderSubtreeIntoContainer<P, S>(
+            parentComponent: Component<any, any>,
+            nextElement: ReactElement<P>,
+            container: Element,
+            callback?: (component: Component<P, S>) => any): Component<P, S>;
+    }
+
+    namespace __DOMServer {
+        function renderToString(element: ReactElement<any>): string;
+        function renderToStaticMarkup(element: ReactElement<any>): string;
+        var version: string;
+    }
+}
+
+declare module "react-dom" {
+    import DOM = __React.__DOM;
+    export = DOM;
+}
+
+declare module "react-dom/server" {
+    import DOMServer = __React.__DOMServer;
+    export = DOMServer;
+}

samples/react-sp-elevatedprivileges/webpart/typings/systemjs/systemjs.d.ts

@@ -0,0 +1,21 @@
+// Type definitions for System.js 0.18.4
+// Project: https://github.com/systemjs/systemjs
+// Definitions by: Ludovic HENIN <https://github.com/ludohenin/>, Nathan Walker <https://github.com/NathanWalker/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface System {
+  import(name: string): any;
+  defined: any;
+  amdDefine: () => void;
+  amdRequire: () => void;
+  baseURL: string;
+  paths: { [key: string]: string };
+  meta: { [key: string]: Object };
+  config: any;
+}
+
+declare var System: System;
+
+declare module "systemjs" {
+  export = System;
+}

samples/react-sp-elevatedprivileges/webpart/typings/tsd.d.ts

@@ -0,0 +1,18 @@
+/// <reference path="@ms/odsp.d.ts" />
+/// <reference path="@ms/odsp-webpack.d.ts" />
+/// <reference path="assertion-error/assertion-error.d.ts" />
+/// <reference path="chai/chai.d.ts" />
+/// <reference path="es6-collections/es6-collections.d.ts" />
+/// <reference path="es6-promise/es6-promise.d.ts" />
+/// <reference path="lodash/lodash.d.ts" />
+/// <reference path="mocha/mocha.d.ts" />
+/// <reference path="node/node.d.ts" />
+/// <reference path="react/react.d.ts" />
+/// <reference path="react/react-addons-shallow-compare.d.ts" />
+/// <reference path="react/react-addons-test-utils.d.ts" />
+/// <reference path="react/react-addons-update.d.ts" />
+/// <reference path="react/react-dom.d.ts" />
+/// <reference path="systemjs/systemjs.d.ts" />
+/// <reference path="whatwg-fetch/whatwg-fetch.d.ts" />
+/// <reference path="knockout/knockout.d.ts" />
+/// <reference path="combokeys/combokeys.d.ts" />

samples/react-sp-elevatedprivileges/webpart/typings/whatwg-fetch/whatwg-fetch.d.ts

@@ -0,0 +1,87 @@
+// Type definitions for fetch API
+// Project: https://github.com/github/fetch
+// Definitions by: Ryan Graham <https://github.com/ryan-codingintrigue>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../es6-promise/es6-promise.d.ts" />
+
+declare class Request extends Body {
+	constructor(input: string|Request, init?:RequestInit);
+	method: string;
+	url: string;
+	headers: Headers;
+	context: string|RequestContext;
+	referrer: string;
+	mode: string|RequestMode;
+	credentials: string|RequestCredentials;
+	cache: string|RequestCache;
+}
+
+interface RequestInit {
+	method?: string;
+	headers?: HeaderInit|{ [index: string]: string };
+	body?: BodyInit;
+	mode?: string|RequestMode;
+	credentials?: string|RequestCredentials;
+	cache?: string|RequestCache;
+}
+
+declare enum RequestContext {
+	"audio", "beacon", "cspreport", "download", "embed", "eventsource", "favicon", "fetch",
+	"font", "form", "frame", "hyperlink", "iframe", "image", "imageset", "import",
+	"internal", "location", "manifest", "object", "ping", "plugin", "prefetch", "script",
+	"serviceworker", "sharedworker", "subresource", "style", "track", "video", "worker",
+	"xmlhttprequest", "xslt"
+}
+declare enum RequestMode { "same-origin", "no-cors", "cors" }
+declare enum RequestCredentials { "omit", "same-origin", "include" }
+declare enum RequestCache { "default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached" }
+
+declare class Headers {
+	append(name: string, value: string): void;
+	delete(name: string):void;
+	get(name: string): string;
+	getAll(name: string): Array<string>;
+	has(name: string): boolean;
+	set(name: string, value: string): void;
+}
+
+declare class Body {
+	bodyUsed: boolean;
+	arrayBuffer(): Promise<ArrayBuffer>;
+	blob(): Promise<Blob>;
+	formData(): Promise<FormData>;
+	json(): Promise<any>;
+	json<T>(): Promise<T>;
+	text(): Promise<string>;
+}
+declare class Response extends Body {
+	constructor(body?: BodyInit, init?: ResponseInit);
+	error(): Response;
+	redirect(url: string, status: number): Response;
+	type: string|ResponseType;
+	url: string;
+	status: number;
+	ok: boolean;
+	statusText: string;
+	headers: Headers;
+	clone(): Response;
+}
+
+declare enum ResponseType { "basic", "cors", "default", "error", "opaque" }
+
+interface ResponseInit {
+	status: number;
+	statusText?: string;
+	headers?: HeaderInit;
+}
+
+declare type HeaderInit = Headers|Array<string>;
+declare type BodyInit = Blob|FormData|string;
+declare type RequestInfo = Request|string;
+
+interface Window {
+	fetch(url: string|Request, init?: RequestInit): Promise<Response>;
+}
+
+declare var fetch: typeof window.fetch;