affise-attribution-lib 1.6.18 → 1.6.20

package/src/module/subscription/AffiseProduct.ts

@@ -0,0 +1,46 @@
+import type {AffiseProductType} from "./AffiseProductType";
+import type {AffiseProductPrice} from "./AffiseProductPrice";
+import type {AffiseProductSubscriptionDetail} from "./AffiseProductSubscriptionDetail";
+
+export class AffiseProduct {
+    public productId: string;
+    public title: string;
+    public description: string;
+
+    public productType: AffiseProductType;
+
+    public price?: AffiseProductPrice | null;
+
+    public subscription?: AffiseProductSubscriptionDetail | null;
+
+    // public productDetails?: string | null;
+
+    constructor(
+        {
+            productId,
+            title,
+            description,
+            productType,
+            price,
+            subscription,
+        }: {
+            productId: string,
+            title: string,
+            description: string,
+            productType: AffiseProductType,
+            price?: AffiseProductPrice | null,
+            subscription?: AffiseProductSubscriptionDetail | null,
+        }
+    ) {
+        this.productId = productId;
+        this.title = title;
+        this.description = description;
+        this.productType = productType;
+        this.price = price;
+        this.subscription = subscription;
+    }
+
+    toString(): string {
+        return `AffiseProduct(productId=${this.productId}, title=${this.title}, description=${this.description}, productType=${this.productType}, price=${this.price?.toString()}, subscription=${this.subscription?.toString()})`;
+    }
+}

package/src/module/subscription/AffiseProductPrice.ts

@@ -0,0 +1,25 @@
+export class AffiseProductPrice {
+    public readonly value: number;
+    public readonly currencyCode: string;
+    public readonly formattedPrice: string;
+
+    constructor(
+        {
+            value,
+            currencyCode,
+            formattedPrice,
+        }: {
+            value: number,
+            currencyCode: string,
+            formattedPrice: string,
+        }
+    ) {
+        this.value = value;
+        this.currencyCode = currencyCode;
+        this.formattedPrice = formattedPrice;
+    }
+
+    toString(): string {
+        return `AffiseProductPrice(value=${this.value}, currencyCode=${this.currencyCode}, formattedPrice=${this.formattedPrice})`;
+    }
+}

package/src/module/subscription/AffiseProductSubscriptionDetail.ts

@@ -0,0 +1,31 @@
+import type {TimeUnitType} from "./TimeUnitType";
+
+export class AffiseProductSubscriptionDetail {
+    public readonly offerToken?: string | null;
+    public readonly offerId?: string | null;
+    public readonly timeUnit?: TimeUnitType | null;
+    public readonly numberOfUnits?: number | null;
+
+    constructor(
+        {
+            offerToken,
+            offerId,
+            timeUnit,
+            numberOfUnits,
+        }: {
+            offerToken?: string | null,
+            offerId?: string | null,
+            timeUnit?: TimeUnitType | null,
+            numberOfUnits?: number | null,
+        }
+    ) {
+        this.offerToken = offerToken;
+        this.offerId = offerId;
+        this.timeUnit = timeUnit;
+        this.numberOfUnits = numberOfUnits;
+    }
+
+    toString(): string {
+        return `AffiseProductSubscriptionDetail(offerToken=${this.offerToken}, offerId=${this.offerId}, timeUnit=${this.timeUnit}, numberOfUnits=${this.numberOfUnits})`;
+    }
+}

package/src/module/subscription/AffiseProductType.ts

@@ -0,0 +1,13 @@
+import {getEnumFromString} from "../../utils/EnumUtils";
+
+export enum AffiseProductType {
+    CONSUMABLE = "consumable",
+    NON_CONSUMABLE = "non_consumable",
+    RENEWABLE_SUBSCRIPTION = "renewable_subscription",
+    NON_RENEWABLE_SUBSCRIPTION = "non_renewable_subscription",
+}
+
+export function affiseProductTypeFrom(name: string | null): AffiseProductType | null {
+    if (name == null) return null;
+    return getEnumFromString(AffiseProductType, name);
+}

package/src/module/subscription/AffiseProductsResult.ts

@@ -0,0 +1,24 @@
+import type {AffiseProduct} from "./AffiseProduct";
+
+export class AffiseProductsResult {
+    public readonly products: AffiseProduct[];
+    public readonly invalidIds: string[];
+
+    constructor(
+        {
+            products,
+            invalidIds,
+        }: {
+            products: AffiseProduct[],
+            invalidIds: string[],
+        }
+    ) {
+        this.products = products || [];
+        this.invalidIds = invalidIds || [];
+    }
+
+
+    toString(): string {
+        return `AffiseProductsResult(products=[${this.products.join(", ")}], invalidIds=[${this.invalidIds.join(", ")}])`;
+    }
+}

package/src/module/subscription/AffisePurchasedInfo.ts

@@ -0,0 +1,31 @@
+import type {AffiseProduct} from "./AffiseProduct";
+
+export class AffisePurchasedInfo {
+    public readonly product?: AffiseProduct | null;
+    public readonly orderId?: string | null;
+    public readonly originalOrderId?: string | null;
+    public readonly purchase?: string | null;
+
+    constructor(
+        {
+            product,
+            orderId,
+            originalOrderId,
+            purchase,
+        }: {
+            product?: AffiseProduct | null,
+            orderId?: string | null,
+            originalOrderId?: string | null,
+            purchase?: string | null,
+        }
+    ) {
+        this.product = product;
+        this.orderId = orderId;
+        this.originalOrderId = originalOrderId;
+        this.purchase = purchase;
+    }
+
+    toString(): string {
+        return `AffisePurchasedInfo(product=${this.product}, orderId=${this.orderId}, originalOrderId=${this.originalOrderId}, purchase=${this.purchase})`;
+    }
+}

package/src/module/subscription/AffiseResultCallback.ts

@@ -0,0 +1,3 @@
+import type {AffiseResult} from "../AffiseResult";
+
+export type AffiseResultCallback<T> = (result: AffiseResult<T>) => void;

package/src/module/subscription/TimeUnitType.ts

@@ -0,0 +1,13 @@
+import {getEnumFromString} from "../../utils/EnumUtils";
+
+export enum TimeUnitType {
+    DAY = "day",
+    WEEK = "week",
+    MONTH = "month",
+    YEAR = "year",
+}
+
+export function timeUnitTypeFrom(name: string | null): TimeUnitType | null {
+    if (name == null) return null;
+    return getEnumFromString(TimeUnitType, name);
+}

package/src/native/AffiseApiMethod.ts

@@ -25,8 +25,10 @@ export enum AffiseApiMethod {
     IS_FIRST_RUN = "is_first_run",
 
     // callback methods
-    GET_REFERRER_CALLBACK = "get_referrer_callback",
-    GET_REFERRER_VALUE_CALLBACK = "get_referrer_value_callback",
+    GET_REFERRER_URL_CALLBACK = "get_referrer_url_callback",
+    GET_REFERRER_URL_VALUE_CALLBACK = "get_referrer_url_value_callback",
+    GET_REFERRER_ON_SERVER_CALLBACK = "get_referrer_on_server_callback",
+    GET_REFERRER_ON_SERVER_VALUE_CALLBACK = "get_referrer_on_server_value_callback",
     REGISTER_DEEPLINK_CALLBACK = "register_deeplink_callback",
     SKAD_REGISTER_ERROR_CALLBACK = "skad_register_error_callback",
     SKAD_POSTBACK_ERROR_CALLBACK = "skad_postback_error_callback",
@@ -43,11 +45,15 @@ export enum AffiseApiMethod {
     GET_STATUS_CALLBACK = "get_status_callback",
     // Link Module
     MODULE_LINK_LINK_RESOLVE_CALLBACK = "module_link_link_resolve_callback",
+    // Subscription Module
+    MODULE_SUBS_FETCH_PRODUCTS_CALLBACK = "module_subs_fetch_products_callback",
+    MODULE_SUBS_PURCHASE_CALLBACK = "module_subs_purchase_callback",
     ////////////////////////////////////////
     // modules
     ////////////////////////////////////////
 }
 
-export function apiMethodFrom(name: string): AffiseApiMethod | null {
+export function apiMethodFrom(name: string | null): AffiseApiMethod | null {
+    if (name == null) return null;
     return getEnumFromString(AffiseApiMethod, name);
 }

package/src/native/AffiseNative.ts

@@ -18,17 +18,16 @@ import {DebugUtils} from "./utils/DebugUtils";
 import type {OnSendSuccessCallback} from "../events/OnSendSuccessCallback";
 import type {OnSendFailedCallback} from "../events/OnSendFailedCallback";
 import type {AffiseLinkCallback} from "../module/link/AffiseLinkCallback";
-import {DataMapper} from "./utils/DataMapper";
+import {DataMapper} from "./data/DataMapper";
+import type {AffiseResultCallback} from "../module/subscription/AffiseResultCallback";
+import type {AffiseProductsResult} from "../module/subscription/AffiseProductsResult";
+import type {AffiseProduct} from "../module/subscription/AffiseProduct";
+import type {AffiseProductType} from "../module/subscription/AffiseProductType";
+import type {AffisePurchasedInfo} from "../module/subscription/AffisePurchasedInfo";
+import {DataName} from "./data/DataName";
 
 export class AffiseNative extends NativeBase {
 
-    protected FINE_VALUE = "fineValue";
-    protected COARSE_VALUE = "coarseValue";
-    protected SUCCESS: string = "success";
-    protected FAILED: string = "failed";
-    protected REQUEST: string = "request";
-    protected RESPONSE: string = "response";
-
     init(initProperties: AffiseInitProperties | AffiseInitPropertiesType) {
         let option: AffiseInitProperties;
         if (isAffiseInitPropertiesType(initProperties)) {
@@ -52,8 +51,8 @@ export class AffiseNative extends NativeBase {
         this.nativeCallbackGroup(
             AffiseApiMethod.SEND_EVENT_NOW,
             new Map([
-                [this.SUCCESS, success],
-                [this.FAILED, failed],
+                [DataName.SUCCESS, success],
+                [DataName.FAILED, failed],
             ]),
             event.toRecord()
         );
@@ -112,12 +111,20 @@ export class AffiseNative extends NativeBase {
         this.native(AffiseApiMethod.CRASH_APPLICATION);
     }
 
-    getReferrer(callback: ReferrerCallback) {
-        this.nativeCallbackOnce(AffiseApiMethod.GET_REFERRER_CALLBACK, callback);
+    getReferrerUrl(callback: ReferrerCallback) {
+        this.nativeCallbackOnce(AffiseApiMethod.GET_REFERRER_URL_CALLBACK, callback);
+    }
+
+    getReferrerUrlValue(key: ReferrerKey, callback: ReferrerCallback) {
+        this.nativeCallbackOnce(AffiseApiMethod.GET_REFERRER_URL_VALUE_CALLBACK, callback, key);
     }
 
-    getReferrerValue(key: ReferrerKey, callback: ReferrerCallback) {
-        this.nativeCallbackOnce(AffiseApiMethod.GET_REFERRER_VALUE_CALLBACK, callback, key);
+    getReferrerOnServer(callback: ReferrerCallback) {
+        this.nativeCallbackOnce(AffiseApiMethod.GET_REFERRER_ON_SERVER_CALLBACK, callback);
+    }
+
+    getReferrerOnServerValue(key: ReferrerKey, callback: ReferrerCallback) {
+        this.nativeCallbackOnce(AffiseApiMethod.GET_REFERRER_ON_SERVER_VALUE_CALLBACK, callback, key);
     }
 
     isFirstRun(): Promise<boolean> {
@@ -142,8 +149,8 @@ export class AffiseNative extends NativeBase {
 
     updatePostbackConversionValue(fineValue: bigint, coarseValue: CoarseValue, completionHandler: ErrorCallback) {
         const value: Record<string, any> = {};
-        value[this.FINE_VALUE] = Number(fineValue);
-        value[this.COARSE_VALUE] = coarseValue.value;
+        value[DataName.FINE_VALUE] = Number(fineValue);
+        value[DataName.COARSE_VALUE] = coarseValue.value;
         this.nativeCallbackOnce(AffiseApiMethod.SKAD_POSTBACK_ERROR_CALLBACK, completionHandler, value);
     }
 
@@ -170,6 +177,7 @@ export class AffiseNative extends NativeBase {
         return this.nativeResult(AffiseApiMethod.GET_MODULES_INSTALLED);
     }
 
+    // Link Module
     linkResolve(url: string, callback: AffiseLinkCallback) {
         this.nativeCallbackOnce(
             AffiseApiMethod.MODULE_LINK_LINK_RESOLVE_CALLBACK,
@@ -177,6 +185,28 @@ export class AffiseNative extends NativeBase {
             url
         );
     }
+
+    // Subscription Module
+    fetchProducts(ids: string[], callback: AffiseResultCallback<AffiseProductsResult>) {
+        this.nativeCallbackOnce(
+            AffiseApiMethod.MODULE_SUBS_FETCH_PRODUCTS_CALLBACK,
+            callback,
+            ids,
+        );
+    }
+
+    // Subscription Module
+    purchase(product: AffiseProduct, type: AffiseProductType, callback: AffiseResultCallback<AffisePurchasedInfo>) {
+        const data: Record<string, any> = {};
+        data[DataName.PRODUCT] = DataMapper.fromProduct(product);
+        data[DataName.TYPE] = type;
+
+        this.nativeCallbackOnce(
+            AffiseApiMethod.MODULE_SUBS_PURCHASE_CALLBACK,
+            callback,
+            data,
+        );
+    }
     ////////////////////////////////////////
     // modules
     ////////////////////////////////////////
@@ -185,20 +215,26 @@ export class AffiseNative extends NativeBase {
         switch (api) {
             case AffiseApiMethod.SEND_EVENT_NOW:
                 switch (tag) {
-                    case this.SUCCESS:
+                    case DataName.SUCCESS:
                         tryCast<OnSendSuccessCallback>(callback)?.();
                         break;
-                    case this.FAILED:
+                    case DataName.FAILED:
                         tryCast<OnSendFailedCallback>(callback)?.(DebugUtils.toResponse(data));
                         break;
                     default:
                         break;
                 }
                 break;
-            case AffiseApiMethod.GET_REFERRER_CALLBACK:
+            case AffiseApiMethod.GET_REFERRER_URL_CALLBACK:
                 tryCast<ReferrerCallback>(callback)?.(DataMapper.toNonNullString(data));
                 break;
-            case AffiseApiMethod.GET_REFERRER_VALUE_CALLBACK:
+            case AffiseApiMethod.GET_REFERRER_URL_VALUE_CALLBACK:
+                tryCast<ReferrerCallback>(callback)?.(DataMapper.toNonNullString(data));
+                break;
+            case AffiseApiMethod.GET_REFERRER_ON_SERVER_CALLBACK:
+                tryCast<ReferrerCallback>(callback)?.(DataMapper.toNonNullString(data));
+                break;
+            case AffiseApiMethod.GET_REFERRER_ON_SERVER_VALUE_CALLBACK:
                 tryCast<ReferrerCallback>(callback)?.(DataMapper.toNonNullString(data));
                 break;
             case AffiseApiMethod.REGISTER_DEEPLINK_CALLBACK:
@@ -215,8 +251,8 @@ export class AffiseNative extends NativeBase {
                 break;
             case AffiseApiMethod.DEBUG_NETWORK_CALLBACK:
                 tryCast<DebugOnNetworkCallback>(callback)?.(
-                    DebugUtils.toRequestWithKey(data, this.REQUEST),
-                    DebugUtils.toResponseWithKey(data, this.RESPONSE)
+                    DebugUtils.toRequestWithKey(data, DataName.REQUEST),
+                    DebugUtils.toResponseWithKey(data, DataName.RESPONSE)
                 );
                 break;
             ////////////////////////////////////////
@@ -228,6 +264,15 @@ export class AffiseNative extends NativeBase {
             case AffiseApiMethod.MODULE_LINK_LINK_RESOLVE_CALLBACK:
                 tryCast<AffiseLinkCallback>(callback)?.(DataMapper.toNonNullString(data));
                 break;
+            // Subscription Module
+            case AffiseApiMethod.MODULE_SUBS_FETCH_PRODUCTS_CALLBACK:
+                tryCast<AffiseResultCallback<AffiseProductsResult>>(callback)
+                    ?.(DataMapper.toResultAffiseProductsResult(data));
+                break;
+            case AffiseApiMethod.MODULE_SUBS_PURCHASE_CALLBACK:
+                tryCast<AffiseResultCallback<AffisePurchasedInfo>>(callback)
+                    ?.(DataMapper.toResultAffisePurchasedInfo(data));
+                break;
             ////////////////////////////////////////
             // modules
             ////////////////////////////////////////

package/src/native/data/DataMapper.ts

@@ -0,0 +1,193 @@
+import {AffiseKeyValue} from "../../module/AffiseKeyValue";
+import {tryCast} from "../../utils/TryCast";
+import {DeeplinkValue} from "../../deeplink/DeeplinkValue";
+import {AffiseProduct} from "../../module/subscription/AffiseProduct";
+import {DataName} from "./DataName";
+import {AffiseProductPrice} from "../../module/subscription/AffiseProductPrice";
+import {AffiseProductSubscriptionDetail} from "../../module/subscription/AffiseProductSubscriptionDetail";
+import {AffisePurchasedInfo} from "../../module/subscription/AffisePurchasedInfo";
+import {AffiseResult} from "../../module/AffiseResult";
+import {AffiseProductsResult} from "../../module/subscription/AffiseProductsResult";
+import {AffiseProductType, affiseProductTypeFrom} from "../../module/subscription/AffiseProductType";
+import {timeUnitTypeFrom} from "../../module/subscription/TimeUnitType";
+
+type Transform<T> = (from: any) => T;
+
+export class DataMapper {
+    static toNonNullString(from: any): string {
+        return from as string || "";
+    }
+
+    static toAffiseKeyValueList(from: any): AffiseKeyValue[] {
+        const data = tryCast<Array<any>>(from) || [];
+        const result: AffiseKeyValue[] = [];
+        for (const item of data) {
+            const cast: Record<string, string> = item as Record<string, string>;
+            const key = cast["key"];
+            const value = cast["value"];
+
+            if (!(key && value)) continue;
+
+            result.push(new AffiseKeyValue(key, value));
+        }
+
+        return result;
+    }
+
+    static toDeeplinkValue(from: any): DeeplinkValue {
+        const data = tryCast<Record<string, any>>(from) || {};
+        const parameters = tryCast<Record<string, string[]>>(data[DataName.PARAMETERS]) || {};
+        return new DeeplinkValue(
+            data[DataName.DEEPLINK],
+            data[DataName.SCHEME],
+            data[DataName.HOST],
+            data[DataName.PATH],
+            parameters
+        );
+    }
+
+    static fromProduct(product: AffiseProduct): Record<string, any> {
+        return {
+            [DataName.PRODUCT_ID]: product.productId,
+            [DataName.TITLE]: product.title,
+            [DataName.DESCRIPTION]: product.description,
+            [DataName.PRODUCT_TYPE]: product.productType,
+            [DataName.PRICE]: this.fromPrice(product.price),
+            [DataName.SUBSCRIPTION]: this.fromSubscription(product.subscription),
+        };
+    }
+
+    static fromPrice(price: AffiseProductPrice | null | undefined): Record<string, any> | null {
+        if (price == null) return null;
+
+        return {
+            [DataName.VALUE]: price.value,
+            [DataName.CURRENCY_CODE]: price.currencyCode,
+            [DataName.FORMATTED_PRICE]: price.formattedPrice,
+        };
+    }
+
+    static fromSubscription(subscription: AffiseProductSubscriptionDetail | null | undefined): Record<string, any> | null {
+        if (subscription == null) return null;
+
+        return {
+            [DataName.OFFER_TOKEN]: subscription.offerToken,
+            [DataName.OFFER_ID]: subscription.offerId,
+            [DataName.TIME_UNIT]: subscription.timeUnit,
+            [DataName.NUMBER_OF_UNITS]: subscription.numberOfUnits,
+        };
+    }
+
+    static toResultAffiseProductsResult(from: any): AffiseResult<AffiseProductsResult> {
+        return this.toResult(from, this.toAffiseProductsResult);
+    }
+
+    static toResultAffisePurchasedInfo(from: any): AffiseResult<AffisePurchasedInfo> {
+        return this.toResult(from, this.toAffisePurchasedInfo);
+    }
+
+    private static toResult<T>(from: any, transformer: Transform<T | null>): AffiseResult<T> {
+        const json = tryCast<Record<string, any>>(from) || {};
+
+        const error = json[DataName.ERROR];
+        const success = json[DataName.SUCCESS];
+
+        if (error != null) {
+            return AffiseResult.Failure(error);
+        }
+
+        const data = transformer(success);
+        if (data == null) {
+            return AffiseResult.Failure(`serialization error. Data: ${from}`);
+        }
+
+        return AffiseResult.Success(data);
+    }
+
+    static toAffiseProductsResult(from: any): AffiseProductsResult | null {
+        const data = tryCast<Record<string, any>>(from);
+        if (data == null) return null;
+
+        const invalidIds = tryCast<string[]>(data[DataName.INVALID_IDS]) || [];
+
+        return new AffiseProductsResult({
+            products: DataMapper.toProductsList(data[DataName.PRODUCTS]),
+            invalidIds: invalidIds,
+        });
+    }
+
+    static toAffisePurchasedInfo(from: any): AffisePurchasedInfo | null {
+        const data = tryCast<Record<string, any>>(from);
+        if (data == null) return null;
+
+        return new AffisePurchasedInfo({
+            product: DataMapper.toProduct(data[DataName.PRODUCT]),
+            orderId: data[DataName.ORDER_ID],
+            originalOrderId: data[DataName.ORIGINAL_ORDER_ID],
+            purchase: data[DataName.PURCHASE],
+        });
+    }
+
+
+    private static toProductsList(from: any): AffiseProduct[] {
+        const result: AffiseProduct[] = [];
+
+        const array = tryCast<Array<string>>(from) || [];
+        for (const obj of array) {
+            const product = this.toProduct(obj);
+            if (product != null) {
+                result.push(product);
+            }
+        }
+
+        return result;
+    }
+
+    static toProduct(from: any): AffiseProduct | null {
+        const data = tryCast<Record<string, any>>(from);
+        if (data == null) return null;
+
+        const productType = affiseProductTypeFrom(data[DataName.PRODUCT_TYPE]);
+
+        const productId = data[DataName.PRODUCT_ID];
+        const title = data[DataName.TITLE];
+        const description = data[DataName.DESCRIPTION];
+
+        if (productId == null) {
+            return null;
+        }
+
+        return new AffiseProduct({
+            productId: productId,
+            title: title,
+            description: description,
+            productType: productType || AffiseProductType.CONSUMABLE,
+            price: this.toPrice(data[DataName.PRICE]),
+            subscription: this.toSubscriptionDetail(data[DataName.SUBSCRIPTION]),
+            // productDetails: data[DataName.PRODUCT_DETAILS],
+        });
+    }
+
+    static toPrice(from: any): AffiseProductPrice | null {
+        const data = tryCast<Record<string, any>>(from);
+        if (data == null) return null;
+
+        return new AffiseProductPrice({
+            value: Number(data[DataName.VALUE]) || 0.0,
+            currencyCode: data[DataName.CURRENCY_CODE] || "",
+            formattedPrice: data[DataName.FORMATTED_PRICE] || ""
+        });
+    }
+
+    static toSubscriptionDetail(from: any): AffiseProductSubscriptionDetail | null {
+        const data = tryCast<Record<string, any>>(from);
+        if (data == null) return null;
+
+        return new AffiseProductSubscriptionDetail({
+            offerToken: data[DataName.OFFER_TOKEN],
+            offerId: data[DataName.OFFER_ID],
+            timeUnit: timeUnitTypeFrom(data[DataName.TIME_UNIT]),
+            numberOfUnits: Number(data[DataName.NUMBER_OF_UNITS]) || null,
+        });
+    }
+}

package/src/native/data/DataName.ts

@@ -0,0 +1,46 @@
+export class DataName {
+    static FINE_VALUE = "fineValue";
+    static COARSE_VALUE = "coarseValue";
+    static TYPE = "type";
+    static REQUEST = "request";
+    static RESPONSE = "response";
+
+    static FAILED = "failed";
+    static SUCCESS = "success";
+    static ERROR = "error";
+
+    static PRODUCTS = "products";
+    static INVALID_IDS = "invalidIds";
+    static PRODUCT = "product";
+    static ORDER_ID = "orderId";
+    static ORIGINAL_ORDER_ID = "originalOrderId";
+    static PURCHASE = "purchase";
+
+    static DEEPLINK = "deeplink";
+    static SCHEME = "scheme";
+    static HOST = "host";
+    static PATH = "path";
+    static PARAMETERS = "parameters";
+
+    static METHOD = "method";
+    static URL = "url";
+    static CODE = "code";
+    static MESSAGE = "message";
+    static HEADERS = "headers";
+    static BODY = "body";
+
+    static PRODUCT_ID = "productId";
+    static TITLE = "title";
+    static DESCRIPTION = "description";
+    static PRODUCT_TYPE = "productType";
+    static PRICE = "price";
+    static VALUE = "value";
+    static CURRENCY_CODE = "currencyCode";
+    static FORMATTED_PRICE = "formattedPrice";
+    static SUBSCRIPTION = "subscription";
+    static OFFER_TOKEN = "offerToken";
+    static OFFER_ID = "offerId";
+    static TIME_UNIT = "timeUnit";
+    static NUMBER_OF_UNITS = "numberOfUnits";
+    static PRODUCT_DETAILS = "productDetails";
+}

package/src/network/HttpMethod.ts

@@ -5,7 +5,8 @@ export enum HttpMethod {
     POST = "POST",
 }
 
-export function httpMethodFrom(name: string): HttpMethod | null {
+export function httpMethodFrom(name: string | null): HttpMethod | null {
+    if (name == null) return null;
     return getEnumFromString(HttpMethod, name);
 }
 

package/lib/commonjs/native/utils/DataMapper.js

@@ -1,33 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.DataMapper = void 0;
-var _AffiseKeyValue = require("../../module/AffiseKeyValue");
-var _TryCast = require("../../utils/TryCast");
-var _DeeplinkValue = require("../../deeplink/DeeplinkValue");
-class DataMapper {
-  static toNonNullString(from) {
-    return from || "";
-  }
-  static toAffiseKeyValueList(from) {
-    const data = (0, _TryCast.tryCast)(from) || [];
-    const result = [];
-    for (const item of data) {
-      const cast = item;
-      const key = cast["key"];
-      const value = cast["value"];
-      if (!(key && value)) continue;
-      result.push(new _AffiseKeyValue.AffiseKeyValue(key, value));
-    }
-    return result;
-  }
-  static toDeeplinkValue(from) {
-    const data = (0, _TryCast.tryCast)(from) || {};
-    const parameters = (0, _TryCast.tryCast)(data["parameters"]) || {};
-    return new _DeeplinkValue.DeeplinkValue(data["deeplink"], data["scheme"], data["host"], data["path"], parameters);
-  }
-}
-exports.DataMapper = DataMapper;
-//# sourceMappingURL=DataMapper.js.map