# Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation This site has an agentic ask interface you may use to query the documentation dynamically by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://docs.ipaper.io/index.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. --- # iPaper Technical Documentation Welcome to the iPaper technical documentation. Here you’ll find everything tech related, such as how to consume our API and how to implement various integrations, etc. If you find anything missing, please contact our customer care at # Google Analytics Learn how to implement Google Analytics tracking in your Display ## Overview Google Analytics tracking is configurable on a license-level: the same Google Analytics Tracking ID will be applied to all your Display instances in the same license, once configured. ## Events All events are tracked to the **iPaper Display** category in the following format: ```javascript gtag('event', [EVENT NAME], { event_category: 'iPaper Display', event_action: [ACTION], event_label: [LABEL], non_interaction: [IS NON INTERACTIVE] }); ``` {% hint style="info" %} **Note:** Google Analytics 4 (GA4) does not by default collect event categories, so event names in GA4 have ‘ipd\_’ prepended for iPaper Display events {% endhint %} {% hint style="info" %} **Note:** When using Google Analytics 4 (GA4), the contents of event\_label are also sent as individual event parameters prepended with ‘ip\_’ {% endhint %} ### Overview {% hint style="info" %} **Note:** Dependent on whether you are using Universal Analytics (UA) or Google Analytics 4 (GA4) the event names will be slightly different {% endhint %}
UA event nameGA4 event nameInteractiveDataComments
Instance
Loadipd_loadNo

{
  Url: [DISPLAY_URL]
}
Time Spentipd_time_spentNo

{
  Duration: [DURATION_IN_SECONDS]
}
Button entity
Button Clickipd_button_clickYes

{
  ActionUrl: [BUTTON_ENTITY_ACTION_URL]
}
Image entity
Image Clickipd_image_clickYes

{
  ActionUrl: [IMAGE_ENTITY_ACTION_URL],
  AssetUrl: [IMAGE_ENTITY_ASSET_URL]
}
Product entity
Product Clickipd_product_clickYes

{
  Id: [PRODUCT_ENTITY_PRODUCT_ID],
  ActionUrl: [PRODUCT_ENTITY_PRODUCT_URL]
}
Instance
Video Clickipd_video_clickYes

{
  ActionUrl: [VIDEO_ENTITY_ACTION_URL],
  AssetUrl: [VIDEO_ENTITY_ASSET_URL]
}
Only available for autoplaying video. ActionUrl is only present if the entity has an action assigned to it.
Video Startipd_video_startYes

{
  ActionUrl: [VIDEO_ENTITY_ACTION_URL],
  AssetUrl: [VIDEO_ENTITY_ASSET_URL]
}
Only available for non-autoplaying video. Fires once per video entity, when a user manually plays video. ActionUrl is only present if the entity has an action assigned to it.
Video Played 25 Percentipd_video_played_25_percentYes

{
  ActionUrl: [VIDEO_ENTITY_ACTION_URL],
  AssetUrl: [VIDEO_ENTITY_ASSET_URL]
}
Only available for non-autoplaying video. Fires once per video entity, once the timestamp of a video exceeds the stated percentage of its total duration. ActionUrl is only present if the entity has an action assigned to it.
Video Played 50 Percentipd_video_played_50_percentYes

{
  ActionUrl: [VIDEO_ENTITY_ACTION_URL],
  AssetUrl: [VIDEO_ENTITY_ASSET_URL]
}
Only available for non-autoplaying video. Fires once per video entity, once the timestamp of a video exceeds the stated percentage of its total duration. ActionUrl is only present if the entity has an action assigned to it.
Video Played 75 Percentipd_video_played_75_percentYes

{
  ActionUrl: [VIDEO_ENTITY_ACTION_URL],
  AssetUrl: [VIDEO_ENTITY_ASSET_URL]
}
Only available for non-autoplaying video. Fires once per video entity, once the timestamp of a video exceeds the stated percentage of its total duration. ActionUrl is only present if the entity has an action assigned to it.
Video Played 100 Percentipd_video_played_100_percentYes

{
  ActionUrl: [VIDEO_ENTITY_ACTION_URL],
  AssetUrl: [VIDEO_ENTITY_ASSET_URL]
}
Only available for non-autoplaying video. Fires once per video entity, once the timestamp of a video exceeds the stated percentage of its total duration. ActionUrl is only present if the entity has an action assigned to it.
### Example For example, when somebody clicks on a button in your Display, we will track it as such via the “Button Click” event: **Universal Analytics (UA):** ```javascript gtag('event', 'Button Click', { event_category: 'iPaper Display', event_action: 'Button Click', event_label: 'Url: https://wwww.ipaper.io/', non_interaction: true }); ``` **Google Analytics 4 (GA4):** ```javascript gtag('event', 'ipd_button_click', { event_category: 'iPaper Display', event_action: 'Button Click', event_label: 'Url: https://wwww.ipaper.io/', non_interaction: true, ip_url: 'https://wwww.ipaper.io/' }); ``` ### Interactive flag There are some events that we want to mark as non-interactive (or [“non-interaction events”](https://developers.google.com/analytics/devguides/collection/analyticsjs/events?hl=da#non-interaction_events) by Google Analytics’ definition). This will mean that even if these events are fired, the session will be considered as bounced if the user does not further interact with the page. ### Event labels The data format below is represented in JSON. It is converted to a string for the `eventLabel` object using the following convention: * Key names are PascalCased * Key-value pairs are separated by the pipe character `|` Example: ```json { Id: [PRODUCT_ENTITY_PRODUCT_ID], Url: [PRODUCT_ENTITY_PRODUCT_URL] } ``` …is converted into: `Id: [PRODUCT_ENTITY_PRODUCT_ID] | Url: [PRODUCT_ENTITY_PRODUCT_URL]` # Quick Start The v1 Display JavaScript API allows for streamlined interaction a Display instance ## Overview The v1 Display JavaScript API is used for client webpages to show and interact with iPaper Display instances. Display instances may be directly associated with a given URL by means of pattern matching of the current page URL against a pre-defined pattern in the call-to-action (CTA) button URL value provided. ### Display instance A Display instance, also known as a “Display”, can be built from the iPaper Admin, if you have the Display module enabled. It is 400px wide and has an arbitrary height, depending on the amount of content in the instance. ### The call-to-action (CTA) button For every Display instance, a call-to-action (CTA) button is associated with it. The instance and the CTA button can be toggled individually. In a typical zero-configuration ground state: * if a Display instance is associated with a given URL, the CTA button will be shown on page load. Clicking on the button will reveal the Display instance, which will animate into the viewport from the left or right side offscreen. The Display API can be used to show/hide the button and the Display instance programmatically. * if a given URL has no Display instance associated with it, no CTA button or Display instance will be shown. However, you can load a Display instance arbitrarily using this API. The Display Javascript API [exposes magic commands](/display-javascript-api/commands) and [emits a custom event upon instantiation](/display-javascript-api/events). ## Setup A Display instance and its CTA button can only be shown on pages that has the Display JavaScript API embedded. The Display API embed script will look something like this, with `` being substitued with partner and license-dependent configurations: ```javascript ``` {% hint style="info" %} **Note:** `` in the snippet above will be substituted with partner and license-dependent configurations and be automatically populated, when you retrieve the API script from the admin. {% endhint %} # Commands Commands are instructions issued by the page to the Display JavaScript API. Commands can be invoked by calling magic methods, which can be accessed directly from the API instance. ## Overview Commands are issued by your page, using magic methods exposed by the Display API instance. As these magic commands are attached to the Display API instance, it is imperative that you ensure the Display API is successfully instantiated. You can either: 1. check if the API is present upon at invocation ```javascript // Example 1 if (window.iPaperDisplayApi) { window.iPaperDisplayApi.show(); } // Example 2 window.iPaperDisplayApi && window.iPaperDisplayApi.show(); ``` 2. or listen to a custom event that signals that the API is ready to use. ```javascript document.addEventListener('iPaperDisplayApiReady', function () { // At the point in time, window.iPaperDisplayApi is available in the global scope window.iPaperDisplayApi.show(); }); ``` See [Events page for further information](/display-javascript-api/events). ## Display instance A Display instance will be shown in a full viewport height ` ``` ## Embedding flipbooks in specific sizes ### 100%×100% size (full viewport size) {% hint style="info" %} **Note:** This is supported on all platforms and is the recommended way of iframing catalogs. {% endhint %} In order to iframe a iPaper catalog, spanning 100% of page, we need to use a specific setup. The markup below shows the essence of what is needed. Firstly, if we set the ` ``` ### Non-100%×100% size {% hint style="warning" %} **Important:** This is only supported for the **iPad** and **Desktop** platforms. On all other platforms it is unsupported. While you may get it to work, expect it to break on certain devices and later on when we change the system. {% endhint %} For these platforms you can specify width in any size you want, even in percentages. Do take care to leave enough space for the user to have a usable experience however. To set the size, you need to change the dimensions on the outer div like this: ```html Catalogues
``` ### Dynamically Resizing Dynamically resizing the div will work. Do make sure you resize the outer element and not the iframe. ### Removing the iPaper User Interface To remove the iPaper user interface, go to **Settings > General > Interface > Hide top bar**.\ Or have a look at [Query String Parameters](/flipbook-integration/query-string-parameters#hidestandardui) {% hint style="info" %} **Note:** All JavaScript events will still be fired, even without the user interface present. {% endhint %} ## Troubleshooting ### There is unexpected whitespace around my flipbook **Symptoms:** There is unexpected whitespace around the flipbook (either vertically or horizontally). When the viewport is resized to a smaller size, the padding proportionally decreases. **Common causes:** The containing element of the ` ``` The URL to be modified will be the string ``. The following query strings are supported:
KeyAccepted valuesDefault valueDescription
targetUrlstringThe public URL of the flipbookChanges the URL that users are redirected to when an embedded minipaper is clicked on. The URL must be fully qualified, starting with http:// or https://, and be URL encoded.

Example:
<MinipaperEmbedUrl>?targetUrl=https%3A%2F%2Fipaper.io%2F
target_self, _blank, _parent, _top_blankChanges the behavior of the anchor element that determines where to display the linked URL. Read more about the specification for target attribute.

Example:
<MinipaperEmbedUrl>?target=_self
If you want multiple query string keys to be attached to the URL, you can separate them using the `&` character, i.e.: `?targetUrl=&target=`. The order of the queries does not matter. {% hint style="info" %} **Note:** As per specification, **all values in query strings must be properly** [**URL-encoded**](https://en.wikipedia.org/wiki/Percent-encoding). There are several online tools for encoding text for use in query strings, for example: . {% endhint %} ## Preserving aspect ratio If you want to preserve the aspect ratio of the embedded minipaper, so that it is scaled proportionately in a page with responsive design, we suggest using the [`padding-bottom` trick](https://css-tricks.com/aspect-ratio-boxes/), which will force an aspect ratio of your choice on the surrounding container. The element displaying the minipaper—the ` ``` # Query String Parameters Certain functions in Flipbooks can be invoked by including query string parameters in the Flipbook address. The following parameters are documented and supported. Any parameter not documented here is not supported and shold not be used and depended upon. ## ForceLanguage Say you have an international catalog with visitors from many nationalities. In iPaper CMS you can only define one language for the user interface (though this can be used to auto-detect the users language), but using the ForceLanguage parameter, you can override the normal user interface language. Example URL that forces the language to French: ``` http://catalogs.company.com/Brochure/?ForceLanguage=fr ``` {% hint style="info" %} **Note:** Please refer to iPaper Support if you need a specific language code. If you link to a non-existing language code, the catalog default will be used instead. {% endhint %} ## GoToFirstSearchResult If you do not want to link to a specific page number, but rather to the first page that contains a certain search term, the GoToFirstSearchResult parameter can be used. The following sample link would take the user to the first page containing the term “Century”: ``` http://catalogs.company.com/Brochure/?GoToFirstSearchResult=Century ``` {% hint style="info" %} **Note:** If the search term is not found, the user will be sent to the first page. {% endhint %} {% hint style="danger" %} **Warning:** If both `GoToFirstSearchResult` and [`GoToAndHighlightFirstSearchResult`](#gotoandhighlightfirstsearchresult) are specified in the URL, this query string value will be ignored. {% endhint %} ## GoToAndHighlightFirstSearchResult This query performs the same operation as [`GoToFirstSearchResult`](#gotofirstsearchresult) above, but has the additional ability to highlight the term on the page itself. ``` http://catalogs.company.com/Brochure/?GoToAndHighlightFirstSearchResult=Century ``` {% hint style="info" %} **Note:** If both [`GoToFirstSearchResult`](#gotofirstsearchresult) and `GoToAndHighlightFirstSearchResult` are specified in the URL, this query string value will take precedence. {% endhint %} ## HideNavigationBars Using this setting you can override the “Hide paging arrows” setting on Flipbooks. To set a default on a Flipbook go to **Settings > General > Interface > Hide paging arrows**. ``` http://catalogs.company.com/Brochure/?HideNavigationBars=true ``` {% hint style="info" %} **Note:** Users will still be able to flip the pages in the Flipbook by swiping the pages, they will just not be able to see or use the navigation buttons. {% endhint %} ## HideStandardUI Using this setting you can override the “Hide top bar” setting on Flipbooks. To set a default on a Flipbook go to **Settings > General > Interface > Hide top bar**. This setting will hide the top bar along with basket, search, menu, logo and anything else present in the bar. ``` http://catalogs.company.com/Brochure/?HideStandardUI=true ``` ## Page The Page parameter is used when you want to deeplink to a certain page in the catalog. The following sample link would take the user directly to page 15: ``` http://catalogs.company.com/Brochure/?Page=15 ``` {% hint style="info" %} **Note:** Linking to a non-existing page number will take the user to the first page instead. {% endhint %} ## Query string forwarding To forward query strings to links, you can prefix query strings with `ipforward_`. We will strip the prefix and add your query strings to any outgoing links in the Flipbook. As an example, the below URL: ``` http://catalogs.company.com/Brochure/?ipforward_YourParameter=x ``` Would result in external links getting decorated with your parameter: `YourParameter=x` You can use the `ipforward_` prefix with any parameter you want. If someone follows a link within your Flipbook, the `ipforward_` is stripped, so only your parameter is retained in the link. And you can of course add multiple parameters:\ `?ipforward_YourParameter=x&ipforward_YourOtherParameter=y` ## ShouldEnableGoogleAnalyticsDebugMode Enabling debug mode for a specific GA4 (Google Analytics 4) measurement ID will allow you to see each individual action happening live in Google Analytics debug view. As an example, the below URL: ``` http://catalogs.company.com/Brochure/?ShouldEnableGoogleAnalyticsDebugMode=true ``` # Remote Authentication Using the Remote Authentication module it’s possible to completely secure a Flipbook, while maintaining full control of access validation on the clients’ own systems. {% hint style="warning" %} **Important:** Please note that iPaper does not support any 3rd party protocols such as OAuth or Facebook. If you are looking to integrate a SSO solution into your flipbook, you will need you create a custom solution using Token Based Authentication {% endhint %} ## Authentication Types There are two overall mechanisms that allows the user to be granted access to the flipbook. ### Credential Based Authentication In this scenario, when the user tries to open a secured Flipbook, he/she is automatically redirected to our standard login page. On the login page, the user can enter his/her username & password. Once “Login” is clicked, the iPaper system contacts the clients’ system. Depending on the response from the clients’ system, the user is either denied or granted access. ### Token Based Authentication In this scenario, the user is browsing on the clients’ secured website. Instead of having to login again to see the catalog, token based authentication can be used. When linking to the desired catalog, an arbitrary string (token) is sent along in the querystring. Once the catalog opens, iPaper will contact the clients’ system and provide the token back - at this point the clients’ system can verify that the user stems from there originally and hence grant or deny access. ## Implementing Token Based Authentication For token based authentication the client system must expose a public url that the iPaper system will call to authenticate tokens. While not a requirement, we recommend that it’s exposed through HTTPS for optimal security. The url itself is specified through the “Authentication url” setting under the “Remote Authentication” module for either a Flipbook or a folder. For token based authentication to be invoked, a catalog must be opened with a “RemoteAuthenticationToken” parameter in the querystring. Once a protected catalog is opened and a remote authentication token is present in the querystring, we will send a POST request to specified url, containing the following POST fields: | POST Field | Description | | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ | | CatalogUrl | This is the url of the catalog - in case logins need to be verified according to the requested catalog. Example: /Company/Catalogs/Week13/ | | UserIP | This is the IP of the user trying to authenticate. Example: 212.242.193.110 | | AuthenticationMode | For credential based authentication this will always be Credentials | | Token | This is the token as specified by the RemoteAuthenticationToken querystring parameter | The response should be in the following format: ``` true ``` AccessAllowed being a boolean specifying whether the user is granted or denied access to the requested catalog. ## Remote Authenticaition Settings These are set on the Flipbooks(s) to be protected, just as the actual remote authentication service URL. ### Alternate External Login URL When using token based authentication and the user visits a catalog directly, it might be desirable to redirect the user to the clients’ own website for logging in. If the “External login url” setting is set, the user will automatically be redirected here, instead of being shown the standard login page. At this point, the client site may perform a login, create a token and redirect the user back to the catalog. The original catalog url will be provided in the “CatalogUrl” querystring parameter. ### Alternate External Login Failure URL In case of a login failure, it may be desirable to send the user to a custom login failure page. If the “External login failure url” setting is specified, the user will be sent here on login failures, instead of being shown the standard login failure page. ## Extra Response Options Besides the AccessAllowed (true/false) response, there’s a number of extra results that may be returned. ### RedirectTo In the authentication response, a RedirectTo parameter may be specified like so: ``` true http://www.client.com/ExpiredLogin.aspx ``` If the RedirectTo parameter is set, the iPaper system will automatically redirect the user to the specified url. This may be useful to provide a user with user specific feedback in case of login failures, promotions etc. Note that the RedirectTo parameter will be utilized no matter if a positive or negative AccessAllowed response is returned. If a positive AccessAllowed response is returned, the user is granted access to the catalog before being sent on to the RedirectTo url. Thus the user can be sent back to the catalog without going through the authentication procedure again. The original catalog url will be provided in the `CatalogUrl` querystring parameter. ### GrantAccessToDescendants In the authentication response, a GrantAccessToDescendants parameter may be specified like so: ``` true true/false ``` If the GrantAccessToDescendants element is set to true, iPaper will automatically validate the user for any Flipbook that are either direct children or descendants of the current address. Imagine the following structure: * /MyFolder/ * /MyFolder/A/ * /MyFolder/B/ * /MyFolder/C/ If you access A/B/C directly and validate, you will only be granted access to that specific catalog, even with the GrantAccessToDescendants parameter set to true. If you setup one of the A/B/C Flipbooks as the default Flipbook of /MyFolder/ and validate, the user will automatically be validated for any Flipbooks starting with /MyFolder/ - in effect, A/B/C. As such, visiting just the default Flipbook, can be used to validate the user for a whole structure of Flipbooks. ## Sample ASP.NET Implementation The *RemoteAuthentication.zip* file contains two pages: Login.aspx and Authenticate.ashx {% file src="/files/Xs0szCOy3WBtlPbpg8Ud" %} Authenticate.ashx contains functionality for validating both credential and token based authentication requests, using a simple switch on the AuthenticationMode parameter. The credentials and token are hardcoded in the files, so it can be used as a template for performing a real validation. Login.aspx is used for testing out token based authentication with a remote login page. The following workflow shows the functionality: 1. User attempts to open a protected catalog. 2. User is sent to the remote login url (Login.aspx). 3. Once user validates, Login.aspx redirects the user back to the original catalog, alongside a RemoteAuthenticationToken in querystring. 4. iPaper contacts the authentication page and attempts to validate the provided token. 5. Given a positive result, the user now has access to the catalog. # Shop Export Using shop configuration it is possible to let the user add a number of items to the shopping basket in the catalog, after which the contents can be sent to a remote site for further processing. At this point, the remote site can handle registration, payment, etc. ## Setup Once the shop configuration has been enabled, you can enable export by selecting “Export” as the primary checkout option. Once enabled, you will have to provide an export URL. This is the URL to which the shop contents are sent, when the user invokes the shop export function. Finally, you can choose whether to send the data in the current window, or open it in a new window. ## Export format To assist in keeping track of orders sent through our Shop Export we supply a few more details than just the items that was ordered. | Property Name | Description | | ------------------- | --------------------------------------------------------------------------------------------------------- | | paper | Short hand URL from where the flipbook was served | | flipbookcompleteurl | Full URL of the flipbook | | exportorigin | Full URL of the flipbook, including the querystring that was set at the point in time the export was done | | orderId | Order Id in the iPaper platform that can be used for reference | | orderDate | Date when the order was exported from the iPaper platform | For each item in the basket that was exported we include the name, description, price, product ID, and amount, as selected in the catalog. An example of a shop XML is as follow: ```xml 2 99.95 ... ``` {% hint style="info" %} **Note:** Even though the shop XML also exposes the `paper` attribute alongside with `flipbookcompleteurl`, we strongly encourage you to use the latter because the former does not include the full public URL of the flipbook. {% endhint %} ## Loading the exported shop XML The following is a complete sample of an aspx page that is able to receive and parse the shop XML. What is done with it afterwards is up to you. This sample simply prints the contents of the basket to the page. ```cshtml <%@ Page Language="C#" AutoEventWireup="true" ValidateRequest="false" %> <%@ Import Namespace="System.Xml" %> <%@ Import Namespace="System.Collections.Generic" %> <%@ Import Namespace="System.Globalization" %> ``` # Getting Started The Flipbook JavaScript API allows you to interact with flipbooks, executing commands and subscribing to events. The Flipbook JavaScript API makes it easy to execute commands in flipbooks as well as listen/subscribe to events happening inside these. The JS API is available both for embedded flipbooks as well as directly in the flipbook viewer through custom scripting. Below are some guides to get you set up and ready to start exploring the possibilities of the JS API. ## Setting up the API for embedded Flipbooks In order to use the JS API you must include the API script on your page. The API script can be seen below: ```html ``` Once you have included this script on your page, you will need to instantiate a new instance of the API. When doing so you specify an iframe to target (your embedded flipbook) as well as an API version to use (version 3 is the latest and only version currently available): ```html ``` Once this has been done, you're ready to start using the JS API. You can explore the [available commands and events here](/flipbook-javascript-api/commands-and-events). You will be able to call/use these on the instance you set up above (i.e. `instance.[Category Name].[Command/Event name]`). When using the JS API with embedded flipbooks, it is possible to have multiple flipbooks where each of them has their own API instance set up. [Please refer to this page on an example of this usage.](/flipbook-javascript-api/advanced-usage#multiple-embedded-flipbooks) ## Setting up the API in Custom Scripting Using the JS API through the Flipbook Custom Scripting module is simple. The API script is already included in the flipbook viewer, so all you need to do is add a script that instantiates a new instance of the API. When doing so you will need to specify a version to use (version 3 is the latest and only version currently available): 
<script>
    const instance = iPaperJsApi(3);
</script>
Once this has been done, you're ready to start using the JS API. You can explore the [available commands and events here](/flipbook-javascript-api/commands-and-events). You will be able to call/use these on the instance you set up above (i.e. `instance.[Category Name].[Command/Event name]`). # Commands & Events ## An introduction to commands & events A **command** is an action/instruction sent to the Flipbook. These are used to trigger functionality inside the flipbook. An **event** is when certain things happen inside a flipbook. These can be subscribed to in order to execute code when they occur. The code that should be executed is passed as a callback function when subscribing. You can set up multiple subscriptions to the same event. In addition, when you set up a subscription you will get an unsubscribe function returned which can be used to delete/cancel the subscription at any time (Note: You will need to `await` the subscription setup for the unsubscribe function to be accessible). For example: ```javascript var mySubscription = await instance.basket.onToggled(() => { console.log('The basket was toggled'); }); mySubscription.unsubscribe(); ``` The JS API comes with an extensive list of commands and events, which are split into the categories below: {% content-ref url="/pages/4zE0Bs9b64WIp3wRasfu" %} [Basket](/flipbook-javascript-api/commands-and-events/basket) {% endcontent-ref %} {% content-ref url="/pages/HQ3f7xa57O97a4EUGI3k" %} [Consent](/flipbook-javascript-api/commands-and-events/consent) {% endcontent-ref %} {% content-ref url="/pages/FvI162KpbT856lKdBDRe" %} [Paging](/flipbook-javascript-api/commands-and-events/paging) {% endcontent-ref %} {% content-ref url="/pages/JXFRW0OQLufshIsfpXHa" %} [Publication](/flipbook-javascript-api/commands-and-events/publication) {% endcontent-ref %} {% content-ref url="/pages/YicvZpkPJINRnufWpi9L" %} [Search](/flipbook-javascript-api/commands-and-events/search) {% endcontent-ref %} {% content-ref url="/pages/WXIY9tEiuvM56HP90GwH" %} [Table of Contents](/flipbook-javascript-api/commands-and-events/table-of-contents) {% endcontent-ref %} {% content-ref url="/pages/c8z2n26gMe8MtEbVAQgP" %} [Sharing](/flipbook-javascript-api/commands-and-events/sharing) {% endcontent-ref %} In addition to these commands and events, there is also a `updateConfig` command that can be used to update/set certain config settings of the API instance. The command accepts a single argument, consisting of the properties below: | Property | Type | Description | | --------------- | ------ | ---------------------------------------------------------------------------- | | `preventAction` | Object | Used to prevent default Flipbook behaviour when certain events are triggered | For the `preventAction` object inside, this accepts one or multiple of the following properties: | Property | Type | Description | | ------------- | --------- | ----------------------------------------------------------------------------------- | | `basketClick` | `boolean` | When set to true, this will prevent the native basket from opening | | `itemAdd` | `boolean` | When set to true, this will prevent all shop items being added to the native basket | Below is an example use which will prevent the native basket from opening: ```javascript instance.updateConfig({ preventAction: { basketClick: true, itemAdd: true } }); ``` # Basket ## Commands ### `open` Opens the basket. 
instance.basket.open();
### `close` Closes the basket. ```javascript instance.basket.close(); ``` ### `getState` Gets the current state of the basket. ```javascript // You can either await the result of the command const result = await instance.basket.getState(); // OR pass a callback instance.basket.getState((result) => { // YOUR CODE HERE }); ``` The command will return an object with the following properties: | Property | Type | Description | | -------- | --------- | ---------------------------- | | `isOpen` | `boolean` | Is the basket currently open | ### `addProduct` Adds a product to the basket. The command accepts a single argument, consisting of the properties below: | Property | Type | Description | | ------------- | -------- | ------------------------------------ | | `title` | `string` | Product title | | `description` | `string` | Product description | | `productId` | `string` | Product Id | | `price` | `number` | Product price | | `originPage` | `number` | Page where the product is located on | | `quantity` | `number` | Quanity of product to add | Below is an example use: ```javascript instance.basket.addProduct({ title: 'My product', description: 'Product description', productId: 'PROD-25B', price: '29.95', originPage: 6, quantity: 1 }); ``` ## Events ### `onOpened` This subscription will trigger every time the basket is opened. 
instance.basket.onOpened(() => {
    // YOUR CODE HERE
});
### `onClosed` This subscription will trigger every time the basket is closed. 
instance.basket.onClosed(() => {
    // YOUR CODE HERE
});
### `onToggled` This subscription will trigger every time the basket is toggled between open and closed state. 
instance.basket.onToggled(() => {
    // YOUR CODE HERE
});
### `onProductAdd` This subscription will trigger whenever a product is added to the basket. {% hint style="warning" %} **Note:** Products added through the `addProduct` API command will not trigger this subscription. {% endhint %} ```javascript instance.basket.onProductAdd((product) => { // YOUR CODE HERE }); ``` The callback contains a value/result of the product that was added, containing the following properties: | Property | Type | Description | | ------------- | -------- | ---------------------------------------------------- | | `title` | `string` | Product title | | `description` | `string` | Product description | | `productId` | `string` | Product ID | | `price` | `number` | Product price | | `pageIndex` | `number` | Page index where the product is located\* (see note) | | `originPage` | `number` | Page where the product is located on | | `quantity` | `number` | Quanity of product added | | `packageSize` | `number` | Number of items per package | {% hint style="info" %} **Note:** Please note that `pageIndex` starts at `0`. So the 1st page of your flipbook will have a `pageIndex` of `0`, page 2 a `pageIndex` of `1` and so on. To get the actual pagenumber you should use `originPage` instead. {% endhint %} # Consent Through the JS API, you can manage the cookie consent set for the flipbook. This is particularly useful if you want to implement your own cookie solution or a 3rd party one. {% hint style="info" %} **Note:** Prior to implementing custom cookie solutions, please make sure that your Flipbook cookie policy is set to ‘Integration’. {% endhint %} {% hint style="info" %} #### Note: When using a 3rd party cookie solution, please make sure that the scripts for the solution are fully loaded before you reference it/use it inside any of the consent API methods. In order to avoid issues, we also recommend that you do not load the 3rd party script asynchronously (i.e. using the async keyword in the tag). {% endhint %} ## Commands ### `get` Retrieves the active/current cookie consent of a Flipbook. ```javascript // You can either await the result of the command const result = await instance.consent.get(); // OR pass a callback instance.consent.get((result) => { // YOUR CODE HERE }); ``` The command will return an object with the following properties:
PropertyTypeDescription
allowPerformanceCookiesbooleanAre performance cookies enabled/allowed
allowFunctionalCookiesbooleanAre functional cookies enabled/allowed
allowAdvertisingCookiesbooleanAre advertising cookies enabled/allowed
allowStrictlyNecessaryCookiesbooleanAre strictly necessary cookies enabled/allowed (always true)
hasPreviousCookieConsentbooleanHas user previously given explicit consent
### `set` This command allows you to set/update the cookie consent for a flipbook. The command requires one argument, consisting of the properties below:
PropertyTypeDescription
allowPerformanceCookiesbooleanShould performance cookies be allowed
allowFunctionalCookiesbooleanShould functional cookies be allowed
allowAdvertisingCookiesbooleanShould advertising cookies be allowed
```javascript instance.consent.set({ allowPerformanceCookies: true, allowFunctionalCookies: true, allowAdvertisingCookies: true }); ``` Optionally, you can add a callback to this command which will run once the consent has been sucesfully updated: ```javascript function consentUpdated(result){ // YOUR CODE HERE }; instance.consent.set({ allowPerformanceCookies: true, allowFunctionalCookies: true, allowAdvertisingCookies: true }, consentUpdated); ``` The callback contains a value/result of what the cookie consent was sucessfully updated to:
PropertyTypeDescription
allowPerformanceCookiesbooleanAre performance cookies enabled/allowed
allowFunctionalCookiesbooleanAre functional cookies enabled/allowed
allowAdvertisingCookiesbooleanAre advertising cookies enabled/allowed
allowStrictlyNecessaryCookiesbooleanAre strictly necessary cookies enabled/allowed (always true)
hasPreviousCookieConsentbooleanHas user previously given explicit consent
### `show` If you are using iPaper's built-in basic cookie banner, you can toggle the banner to be shown via this command. ```javascript instance.consent.show(); ``` ## Events ### `onChange` This subscription will trigger every time the cookie consent is changed/updated. ```javascript instance.consent.onChange((result) => { // YOUR CODE HERE }); ``` The callback contains a value/result with the following properties:
PropertyTypeDescription
allowPerformanceCookiesbooleanAre performance cookies enabled/allowed
allowFunctionalCookiesbooleanAre functional cookies enabled/allowed
allowAdvertisingCookiesbooleanAre advertising cookies enabled/allowed
allowStrictlyNecessaryCookiesbooleanAre strictly necessary cookies enabled/allowed (always true)
hasPreviousCookieConsentbooleanHas user previously given explicit consent
### `onShow` By listening to this event you can define a callback function that runs when either the `show` API command has been run, or when the “Cookie Policy” button/link in the Flipbook viewer header is clicked. This could for example be used to trigger showing a 3rd party cookie banner. ```javascript instance.consent.onShow(() => { // YOUR CODE HERE }); ``` # Example Implementations To get you started with implementing your own cookie consent solution for your Flipbooks, we have created a couple of example implementations for some of the biggest 3rd party cookie consent solutions. {% content-ref url="/pages/NoRLoomb9R6qzMLZ1PTY" %} [UserCentrics](/flipbook-javascript-api/commands-and-events/consent/example-implementations/usercentrics) {% endcontent-ref %} {% content-ref url="/pages/A0ceenNQ8Q9WUzXBpfPn" %} [OneTrust](/flipbook-javascript-api/commands-and-events/consent/example-implementations/onetrust) {% endcontent-ref %} {% content-ref url="/pages/n9jxCydlHVyBfrLyTOeO" %} [CookieInformation](/flipbook-javascript-api/commands-and-events/consent/example-implementations/cookieinformation) {% endcontent-ref %} {% content-ref url="/pages/D1wKLBDmlhZFawiKzeJO" %} [Cookiebot](/flipbook-javascript-api/commands-and-events/consent/example-implementations/cookiebot) {% endcontent-ref %} # UserCentrics {% hint style="warning" %} **Note:** While the implementations below work as intended during the time of writing, we unfortunately cannot guarantee that they will always work for you as-is. Since this is not an official integration with UserCentrics, changes they make to their code base may also have an impact on the snippets below. {% endhint %} {% hint style="info" %} **Note:** The snippets below are all intended to be used through the Custom Scripting module. If you wish to use them with the Flipbook JavaScript API instead they will require some adjustment. **Before inserting new ` ``` # Migration guide This page will help you through the process of migrating an existing V2 implementation to the new V3 Flipbook JavaScript API. The new V3 API contains all the features from V2 as well as new ones. ## Why you should consider migrating ### New commands & events The V3 JS API comes with new functionality that could be useful to you. In addition, more functionality will be added over time, which won't be the case with V2. Some of the new functionality in V3 include: * The ability to check the current state of paging, basket, search, and table of contents * The ability to explicitly close or open basket, search, and table of contents * The ability to retrieve the details of the flipbook via [publication.getDetails](/flipbook-javascript-api/commands-and-events/publication#getdetails) * The ability to execute a search directly via [search.query](/flipbook-javascript-api/commands-and-events/search#query) ### Improved stability and performance The way the V3 JS API has been built improves both stability and general performance of commands and events. Another thing that has been particularly streamlined and improved is the initialization process. ### Better integration with multiple flipbooks Due to the improvements made to the initialization process, it is now much easier to work with pages containing multiple embedded flipbooks. For more on this, [see this page](/flipbook-javascript-api/advanced-usage#multiple-embedded-flipbooks). ### The API can now be used via Custom Scripting Unlike the V2 JS API, the V3 JS API can be used directly inside Custom Scripting with feature parity to when used externally. For how to get started with this, [see this page](/flipbook-javascript-api/getting-started#setting-up-the-api-in-custom-scripting). ## Step 1: Migrate API initialization #### Updating the API embed script To migrate to the new V3 API, you will need to update the API embed script on your page. Your current embed script should look something like this: {% code title="Example of V2 API embed script" %} ```html ``` {% endcode %} The new embed script for V3 can be seen below: {% code title="New V3 API embed script" %} ```html ``` {% endcode %} Once you have the added the new embed script, simply remove/delete the old one from the page. #### Updating existing script to initialize API instance The way of initializing the API has changed a bit in V3. Instead of relying on an automatic process of detecting the iframe containing a flipbook and instantiating the API with this iframe, you will now need to instantiate the API manually by passing in the iframe and an API version as parameters. So, where you previously may have had something like this: 
<iframe src="https://demo.ipaper.io"></iframe>

<script>
    function iPaperInit() {
        // Your API commands and events here
    }
</script>
Or something like this: {% code title="Example V2 initialization via event listener" %} ```markup ``` {% endcode %} You will now need this instead: {% code title="Example V3 initialization" %} ```html ``` {% endcode %} {% hint style="info" %} **Note:** This way of instantiating the API will only work for V3 and later. {% endhint %} Once this has been done, you can use/access API commands and events directly on the created `instance` variable (FX. `myApiInstance.basket.open()`). **Are you using multiple embedded flipbooks on the same page?** The change to initialization will also make it much easier to work with pages containing multiple embedded Flipbooks. For more on how to create multiple API instances on the same page, [see here.](/flipbook-javascript-api/advanced-usage) If you are currently using the V2 way of having multiple embedded flipbooks, you will need to update this to be done in the new V3 way, as can be seen in the link above. The V2 way is not supported in V3. ## Step 2: Migrate API commands API commands generally work the same in V3 as they did in V2. They have, however, been split into more detailed categories, and some have been renamed or altered slightly. Below, you can see the V2 API commands and their V3 equivalents. {% hint style="danger" %} **Note:** [Command triggers](/flipbook-javascript-api/legacy-javascript-api-v2/advanced-usage#event-listeners-and-command-triggers) are no longer supported with V3. Any usage of these will have to be updated. {% endhint %} ### `updateEventSettings` This command has been changed a bit in V3. It has been converted to be a more universal command for updating an API instance's configuration. So, where you may have had something like this before: ```javascript iPaperAPI.updateEventSettings({ onBasketClick: { preventDefault: true }, onItemAdd: { preventDefault: true } }); ``` You will now need something like this instead: 
myApiInstance.updateConfig({
    preventAction: {
        basketClick: true,
        itemAdd: true
    }
});
`basketClick` is equivalent to V2's `onBasketClick` and `itemAdd` is equivalent to `onItemAdd`. ### `goToPage` The **location** for this command has been changed. It can now be accessed with: ```javascript myApiInstance.paging.goToPage(4); ``` ### `goToPreviousPage` The **location** and **naming** for this command has been changed. It can now be accessed with: ```javascript myApiInstance.paging.goToPrevPage(); ``` ### `goToNextPage` The **location** for this **command** has been changed. It can now be accessed with: ```javascript myApiInstance.paging.goToNextPage(); ``` ### `addItem` {% hint style="warning" %} **Be aware:** The `productID` property has been renamed `productId` in V3. {% endhint %} The **location** and **naming** for this command has been changed. It can now be accessed with: ```javascript myApiInstance.basket.addProduct({ title: 'My product', description: 'Product description', productId: 'PROD-25B', price: '29.95', originPage: 6, quantity: 1 }); ``` ### `getCookieConsent` The **location** and **naming** for this command has been changed. It can now be accessed with: ```javascript // You can either await the result of the command const result = await myApiInstance.consent.get(); // OR pass a callback myApiInstance.consent.get((result) => { // YOUR CODE HERE }); ``` ### `updateCookieConsent` The **location** and **naming** for this command has been changed. It can now be accessed with: ```javascript myApiInstance.consent.set({ allowPerformanceCookies: true, allowFunctionalCookies: true, allowAdvertisingCookies: true }); ``` ## Step 3: Migrate API events In V3, events have been streamlined and updated to run as subscriptions. This makes it easier to add and remove these on demand. For more on this, [see this page](/flipbook-javascript-api/commands-and-events). Apart from this change, API events generally work the same in V3 as they did in V2. They have, however, been split into more detailed categories, and some have been renamed. Below, you can see the V2 API events and their V3 equivalents. {% hint style="danger" %} **Note:** [Event listeners](/flipbook-javascript-api/legacy-javascript-api-v2/advanced-usage#event-listeners-and-command-triggers) are no longer supported with V3. Any usage of these will have to be updated. {% endhint %} ### `onPageElementClick` The **location** for this event has been changed. It can now be subscribed to using: ```javascript myApiInstance.publication.onPageElementClick((result) => { // YOUR CALLBACK CODE HERE }); ``` ### `onSpreadChange` The **location** for this event has been changed. It can now be subscribed to using: ```javascript myApiInstance.publication.onSpreadChange((result) => { // YOUR CALLBACK CODE HERE }); ``` However, while this command is available in V3, we recommend that you consider upgrading to/using the new `paging.onChange` event instead. ### `onBasketClick` The **location** and **naming** for this event has been changed. It can now be subscribed to using: ```javascript myApiInstance.basket.onToggled(() => { // YOUR CALLBACK CODE HERE }); ``` ### `onItemAdd` The **location** and **naming** for this event has been changed. It can now be subscribed to using: ```javascript myApiInstance.basket.onProductAdd((product) => { // YOUR CALLBACK CODE HERE }); ``` ### `onCookieConsentShown` The **location** and **naming** for this event has been changed. It can now be subscribed to using: ```javascript myApiInstance.consent.onShow(() => { // YOUR CALLBACK CODE HERE }); ``` ### `onCookieConsentUpdate` The **location** and **naming** for this event has been changed. It can now be subscribed to using: ```javascript myApiInstance.consent.onChange((result) => { // YOUR CALLBACK CODE HERE }); ``` # Legacy Javascript API (v2) {% hint style="warning" %} **Note:** If you are just getting started with the Flipbook JS API, we strongly advice that you use the latest version (v3) instead. If you are already using the v2 JS API, we encourage you to upgrade to v3 if possible. {% endhint %} Here you will find the legacy documentation for the v2 Flipbook JavaScript API. # Quick Start The v2 Flipbook JavaScript API allows for streamlined interaction with iframed flipbooks using cross-origin communications available in modern browsers. ## Overview {% hint style="info" %} **Note:** The legacy v2 JS API is now superseded by v3 Flipbook JS API. {% endhint %} The v2 Flipbook JavaScript API uses the [`window.postMessage` API](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) for two-way communications between the parent window and one or more flipbooks embedded in the parent window inside ` ``` {% hint style="info" %} **Note:** If you are using multiple flipbooks, additional configuration is required: please refer to the [**Multiple flipbooks**](#multiple-flipbooks) section for further information. {% endhint %} ## Interacting with iframed flipbook The embedded script will call the `iPaperInit()` method that is defined globally in the parent window, and you can then interact with the iframed flipbook via the `iPaperAPI` instance created by default: ```html Example Flipbook JS API use ``` The `iPaperAPI` object exposes several methods that can be grouped into two categories: [**magic event callbacks**](/flipbook-javascript-api/legacy-javascript-api-v2/events) and [**magic commands**](/flipbook-javascript-api/legacy-javascript-api-v2/commands). * **Events happen on the flipbook and are emitted to the parent window**, which trigger magic callbacks. An example of a flipbook event is the [`onSpreadChange`](/flipbook-javascript-api/legacy-javascript-api-v2/events#onspreadchange) event. [Read more](/flipbook-javascript-api/legacy-javascript-api-v2/events) about how to listen to these events and react to them accordingly. * **Commands are instructions issued from the parent window to the flipbook**, done via invoking magic commands. An example of a flipbook command is the [`goToPage`](/flipbook-javascript-api/legacy-javascript-api-v2/commands#gotopage) method. [Read more](/flipbook-javascript-api/legacy-javascript-api-v2/commands) about how to issue commands to instruct your iframed flipbook to perform specified actions. As an alternative to using the `iPaperInit` function like in the snippet above, you can also use an event listener for `iPaperInit` instead: ```html Example Flipbook JS API use ``` ## Multiple flipbooks In the event that multiple flipbooks are to be embedded via ` ``` This iframed flipbook will then be accessible via the globally defined API instance `iPaperAPI`, just like in the single flipbook use case outlined in [quick-start](/flipbook-javascript-api/legacy-javascript-api-v2/quick-start). {% hint style="warning" %} **Warning:** If `data-ipaper` attribute is not added, then the default API instance will simply select the **first** ` ``` ## Event listeners and command triggers If you are more accustomed to working with event listeners and command triggers, and do not want to use magic callbacks and commands that are available via the API instance, you can simply: * add event listeners to the ` ``` # Cookie Information ## Cookies set by iPaper The following cookies are set when visiting a flipbook on the iPaper platform, we put high effort into ensuring that we follow best practices and actions that could be categorized differently unless the user gives consent.
NameValuePurposeSameSiteHttpOnlySecureCategoryExpiry
ASP.NET_SessionIdUnique random stringSession cookie to ensure that the visitor is given access to the respective flipbook, and it's needed assets.NoneTrueTrueStrictly necessarySession
### Why does the `ASP.NET_SessionId` have SameSite: None? To ensure our system works correctly when embedded in an iframe or app, we explicitly allow our session cookie to be read by other domains. If we were to change this, things such as basket content, wouldn't be persisted between page refreshes. ## Cookie categories If you enable the iPaper cookie banner, or you are using a 3rd party consent management platform through our integration option, this is how the four categories of cookies affect the iPaper solution. Note that we only ever set the cookies defined under “Cookies set by iPaper”, however, their use changes depending on the cookie permissions granted by the user. ### Strictly necessary This category is always allowed and makes sure the basic iPaper experience works. This is what ensures products stay in the basket and that basic features in the Flipbook works. ### Performance If we do not get the performance permission, iPaper only tracks basic statistics that are not correlated with the actual session in any way. This is data such as PDF downloads, logo clicks, time of day, etc. With the performance permission granted, iPaper furthermore also tracks page views & time spent. ### Functionality This category has no impact on the iPaper solution and is only there for future proofing. ### Advertising All iPaper integrations are disabled if we do not get advertising permission. This includes Google Analytics, Google Tag Manager, Facebook and other integrations. ## Technologies used As mentioned above in the [#cookies-set-by-ipaper](#cookies-set-by-ipaper "mention") section, we use cookies for storing sessions. When it comes to the storage of the current cookie category consent given, this is currently stored in [localStorage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage). This is however subject to change and could in the future be moved to use a different technology if we deem it more suitable. The technology used may also differ dependent on the browser used. The stored item in localStorage follows the naming scheme `userCookieConsent_[LicenseID]_[CookieBannerType]` and has a value consisting of an object with the following properties:
NameValuePurpose
shouldAllowPerformanceCookiesbooleanDetermines if user has consented to "Performance" cookies
shouldAllowFunctionalCookiesbooleanDetermines if user has consented to "Functional" cookies
shouldAllowAdvertisingCookiesbooleanDetermines if user has consented to "Advertising" cookies
expiresdateDate when the stored item will expire
{% hint style="info" %} **Note:** Please do not attempt to manipulate/update this localStorage value manually, but instead rely on the [JS API for updating consent](/flipbook-javascript-api/commands-and-events/consent). {% endhint %} # Common security questions ## Should I security test the Flipbook viewer? While it's good practice to verify the security of the tools you use, our Flipbook viewer is a hosted solution and therefore has no impact on your other websites. As such, it does not make sense to run a full suite of security tests against our system, as our Flipbook viewer is designed to conform to the broad security needs of our customer base, rather than the specific requirements for individual customers. ## Why are there no strict CSP headers in the Flipbook viewer? We offer many ways to enrich our Flipbooks, and many of these allow scripts to be loaded from the internet, such as Google, GTM, and any other script you, as a customer, would like to embed in your flipbook. We also offer a feature called Custom Scripting, where you can write any JavaScript you want, and it'll run when your Flipbook loads. As such, our CSP header cannot be strict, as it would prevent the above features from working. ## Why we don’t use PFS (Perfect Forward Secrecy) iPaper is a company with customers in all parts of the world, and as such we're accessed by a broad range of devices. Introducing PFS would prevent older devices from accessing Flipbooks, and with the current device palette, we're seeing accessing our system, we're not at a point where we want to introduce PFS. ## Why is the HSTS header only 7 days Our system allows customers to set up branded domains for their publications, and we provide SSL certificates as part of this service. The configuration of branded domains and SSL is managed by the individual companies, and to give our customers some leeway in the configuration of SSL, we've opted for a shorter HSTS header, so there's room for human errors. ## What is the "**IPF\_\_SUPPORT\_TEST\_KEY" key in local storage** To detect if a device supports Local Storage, we try to set a temporary key called `IPF__SUPPORT_TEST_KEY`. The key is removed immediately after support has been detected. # Open Source At iPaper we are fond of Open Source and we do our best to use libraries that are proven and well maintained. Due to the nature of always keeping an eye on industry standards and most battle-hardened libraries, this list will never be static as we might switch to a more modern or up to date library later on. We do a thorough assesment when we include a new library both in the aspects of their license, their security model and last but not least how well supported is the library. The list below includes all of the libraries we are currently using and a notation of where in our system they are used. We do not list individual packages for Microsoft .NET Framework as that is core for all of our systems to be running. ## Usage description | Name | Description | | -------- | --------------------------------------------------------------------------------------------------------------- | | Backend | Libraries listed with this usage is used to serve all frontend related output | | Frontend | These libraries are directly used inside of the visitors browsers | | Services | The libraries listed here are backend supporting services that could be nightly scheduling, PDF processing etc. | ## Current library usage | Name | License | Repository | Usage | | ------------------------------------------------------- | ------------------- | -------------------------------------------------------------- | ---------------- | | AjaxMin | Apache 2.0 | | Backend | | Akka | Apache 2.0 | | Services | | Akka.Quartz.Actor | Apache 2.0 | | Services | | Akka.Serialization.Hyperion | Apache 2.0 | | Services | | AngleSharp | MIT | | Services | | animejs | MIT | | Frontend | | Antlr | BSD | | Backend | | autoprefixer | MIT | | Frontend | | aws-sdk | Apache 2.0 | | Frontend | | AWSSDK.CloudWatch | Apache 2.0 | | Backend | | AWSSDK.Core | Apache 2.0 | | Backend Services | | AWSSDK.S3 | Apache 2.0 | | Backend Services | | AWSSDK.SimpleEmail | Apache 2.0 | | Backend | | AWSSDK.SimpleNotificationService | Apache 2.0 | | Backend | | AWSSDK.SQS | Apache 2.0 | | Backend Services | | backbone | MIT | | Frontend | | cache-loader | MIT | | Frontend | | Certes | MIT | | Backend | | clipboard | MIT | | Frontend | | css-loader | MIT | | Frontend | | cssnano | MIT | | Frontend | | CsvHelper | MS-PL OR Apache 2.0 | | Backend | | direct-vuex | CC0-1.0 | | Frontend | | DnsClient | Apache 2.0 | | Backend | | dotless | Apache 2.0 | | Backend | | EPPlus | LGPL | | Services Backend | | exports-loader | MIT | | Frontend | | Expressmapper | Apache 2.0 | | Backend | | file-loader | MIT | | Frontend | | fork-ts-checker-webpack-plugin | MIT | | Frontend | | fscreen | MIT | | Frontend | | hammerjs | MIT | | Frontend | | Hashids.net | MIT | | Backend | | HtmlAgilityPack | MIT | | Backend Services | | Intercom.Dotnet.Client | Apache 2.0 | | Backend | | iTextSharp.LGPLv2.Core | LGPL 2.0 | | Backend Services | | Jint | BSD-2-Clause | | Backend | | jquery | MIT | | Frontend | | js-cookie | MIT | | Frontend | | lodash.clonedeep | MIT | | Frontend | | lodash.debounce | MIT | | Frontend | | lodash.merge | MIT | | Frontend | | lodash.mergewith | MIT | | Frontend | | Markdig | BSD-2-Clause | | Backend | | MaxMind.GeoIP2 | Apache 2.0 | | Backend | | mini-css-extract-plugin | MIT | | Frontend | | Newtonsoft.Json | MIT | | Backend | | NHttp | LGPL | | Services | | Pipelines.Sockets.Unofficial | MIT | | Backend | | portal-vue | MIT | | Frontend | | postcss-loader | MIT | | Frontend | | PreMailer.Net | MIT | | Backend | | qrcode-svg | MIT | | Frontend | | Quartz | Apache 2.0 | | Services | | query-string | MIT | | Frontend | | quill | BSD-3-Clause | | Frontend | | quill-delta | MIT | | Frontend | | R7Insight.Core | MIT | | Services Backend | | RestSharp | Apache 2.0 | | Backend | | sass | MIT | | Frontend | | sass-loader | MIT | | Frontend | | sortablejs | MIT | | Frontend | | StackExchange.Redis | MIT | | Backend | | Stripe.net | Apache 2.0 | | Backend | | svgo | MIT | | Frontend | | svgo-loader | MIT | | Frontend | | terser-webpack-plugin | MIT | | Frontend | | tinycolor2 | MIT | | Frontend | | Topshelf | Apache 2.0 | | Services | | ts-keycode-enum | MIT | | Frontend | | ts-loader | MIT | | Frontend | | tslib | Apache 2.0 | | Frontend | | tween.js | MIT | | Frontend | | TwoFactorAuth.Net | MIT | | Backend | | typescript | Apache 2.0 | | Frontend | | underscore | MIT | | Frontend | | unQuery | MIT | | Backend Services | | uuid | MIT | | Frontend | | vue | MIT | | Frontend | | vue-class-component | MIT | | Frontend | | vue-implicit-css-modules | MIT | | Frontend | | vue-loader | MIT | | Frontend | | vue-property-decorator | MIT | | Frontend | | vue-router | MIT | | Frontend | | vue-style-loader | MIT | | Frontend | | vue-svg-loader | MIT | | Frontend | | vue-template-compiler | MIT | | Frontend | | vuedraggable | MIT | | Frontend | | vuex | MIT | | Frontend | | vuex-class | MIT | | Frontend | | webfontloader | Apache 2.0 | | Frontend | | webpack | MIT | | Frontend | | @vuelidate/core | MIT | | Frontend | | @vuelidate/validators | MIT | | Frontend | | luxon | MIT | | Frontend | | @intervolga/optimize-cssnano-plugin | MIT | | Frontend | | mini-css-extract-plugin | MIT | | Frontend | | query-string-for-all | MIT | | Frontend | | @tweenjs/tween.js | MIT | | Frontend | | @vimeo/player | Apache 2.0 | | Frontend | | @webcomponents/custom-elements | MIT | | Frontend | | construct-style-sheets-polyfill | MIT | | Frontend | | r7insight\_js | MIT | | Frontend | | zapier-platform-core | Apache 2.0 | | Services | | ZiggyCreatures.FusionCache | MIT | | Backend | | ZiggyCreatures.FusionCache.Serialization.NewtonsoftJson | MIT | | Backend | | KubernetesClient | Apache 2.0 | | Backend | | Octokit | MIT | | Backend | | SixLabors.Fonts | Apache 2.0 | | Backend | | SixLabors.ImageSharp | Apache 2.0 | | Backend | | SixLabors.ImageSharp.Drawing | Apache 2.0 | | Backend | | NuGet.Core | Apache 2.0 | | Backend | | Scriban | MIT | | Backend | | Argotic.Core | Apache 2.0 | | Backend | | Ctl.Data | MIT | | Backend | | EcmaScript.Net | MIT | | Backend | | iTextSharp-LGPL | LGPL 2.1 | | Backend | | logentries.core | MIT | | Backend | | Zyborg.Logentries | MIT | | Backend | | FileHelpers | MIT | | Backend | | LumenWorksCsvReader | MIT | | Backend | | StronglyTypedId | MIT | | Backend | | LumenWorks.Framework.IO | MIT | | Backend | | WebGrease | Apache 2.0 | | Backend | | AWSSDK.SecretsManager.Caching | Apache 2.0 | | Backend | | MudBlazor | MIT | | Frontend | | DarkUIReborn | MIT | | Frontend | | jacobslusser.ScintillaNET | BSD-3-Clause | | Frontend | | StackExchange.Redis.StrongName | MIT | | Backend |