web3-banking-system-sdk 1.0.0

package/dist/api/data/user/user.js

@@ -0,0 +1,119 @@
+import { DeviceType, EntityStatus, EntityVerificationStatus, DocumentType, SecurityAuthenticationTypes, SecurityLoginType, } from "../../../constant";
+import { ClientHelper, DateTimeHelper, UserHelper } from "../../../helper";
+import { getBase64 } from "../../../utils";
+import { createDefaultUserData } from "./userDefaults";
+export { createDefaultUserData, fillCreateUserData, fillCreateUserWithGoogleData };
+const fillCreateUserData = (data) => {
+    const clientHelper = new ClientHelper();
+    const personalInfo = {
+        title: data.title,
+        first_name: data.firstName,
+        last_name: data.lastName,
+        date_of_birth: data.dateOfBirth,
+        gender: String(data.gender),
+        verification_status: EntityVerificationStatus.Verified,
+    };
+    const address = {
+        country_code: data.country,
+        state_region: data.state,
+        verification_status: EntityVerificationStatus.Not_Verified,
+    };
+    const device = {
+        type: DeviceType.Browser,
+        brand: `${clientHelper.getBrowser()}-${clientHelper.getBrowserVersion()}`,
+        os: clientHelper.getOS(),
+        status: EntityStatus.Active,
+        verification_status: data.deviceVerificationStatus,
+        installation_id: data.installationID,
+        extended_info: {
+            cpu: clientHelper.getCPU(),
+            system_language: clientHelper.getSystemLanguage(),
+            user_agent: clientHelper.getUserAgent(),
+        },
+    };
+    const userData = createDefaultUserData({
+        personal_info: personalInfo,
+        address: address,
+        email: [
+            {
+                id: 0,
+                address: data.email,
+                is_primary: 1,
+                verification_status: EntityVerificationStatus.Verified,
+            },
+        ],
+        authentication: [],
+        security: {
+            password: data.password,
+        },
+        preferences: {
+            preferred_language_code: data.preferredLanguageCode,
+            enable_promotion_notification: "1",
+            enable_email_notification: "1",
+            enable_sms_notification: "1",
+            enable_push_notification: "1",
+            enable_device_authentication: "1",
+            time_zone: DateTimeHelper.getClientTimeZone(),
+        },
+        currency: [
+            {
+                id: 0,
+                code: data.currency,
+                is_primary: 0,
+            },
+        ],
+        terms_conditions: {
+            id: 0,
+            acceptance: "1",
+        },
+        device: [device],
+        custom_field: UserHelper.fillPromotionData({
+            giftData: data.giftData,
+            referralCode: data.referralCode,
+            referralCodeType: data.referralCodeType,
+        }),
+    });
+    // if (data.isMobileConfirmed && data.mobileAuthenticationCode) {
+    //   userData.authentication.push({
+    //     type: SecurityAuthenticationTypes.SMS_Code,
+    //     code: data.mobileAuthenticationCode,
+    //   });
+    // }
+    if (data.emailAuthenticationCode) {
+        userData.authentication.push({
+            type: SecurityAuthenticationTypes.Email_Code,
+            code: data.emailAuthenticationCode,
+        });
+    }
+    return userData;
+};
+const fillCreateUserWithGoogleData = async (data) => {
+    const base64 = await getBase64(data.picture);
+    const userData = fillCreateUserData(data);
+    const externalAuth = {
+        id: 0,
+        login_id: data.loginId,
+        token: data.token,
+        status: EntityStatus.Active,
+        type: SecurityLoginType.Google,
+        verification_status: EntityVerificationStatus.Verified,
+    };
+    userData.external_auth = [externalAuth];
+    if (base64) {
+        const documentData = {
+            info: {
+                type: DocumentType.Profile_Picture,
+                subject: "Profile Picture",
+            },
+            attachment: [
+                {
+                    file_name: data.loginId,
+                    file_extension: ".jpg",
+                    content: base64,
+                },
+            ],
+        };
+        userData.documents = [documentData];
+    }
+    return userData;
+};

package/dist/api/data/user/userDefaults.d.ts

@@ -0,0 +1,3 @@
+import type { UserData } from "../../../types";
+declare const createDefaultUserData: (overrides?: Partial<UserData>) => UserData;
+export { createDefaultUserData };

package/dist/api/data/user/userDefaults.js

@@ -0,0 +1,48 @@
+const createDefaultUserData = (overrides) => ({
+    result: null,
+    notes: null,
+    last_activity: null,
+    authentication: null,
+    validate: null,
+    function_code: null,
+    response_time: null,
+    time_zone: null,
+    time_zone_name: null,
+    info: null,
+    personal_info: null,
+    address: null,
+    addresses: [],
+    email: [],
+    phone: [],
+    security: null,
+    preferences: null,
+    identification: [],
+    bank_account: [],
+    credit_card: null,
+    notification: null,
+    documents: [],
+    currency: [],
+    credit_limit: null,
+    account: [],
+    group: null,
+    terms_conditions: null,
+    device_info: null,
+    device: [],
+    device_history: [],
+    commerce: null,
+    external_auth: null,
+    validation_data: null,
+    relationship: null,
+    custom_field: null,
+    history: null,
+    access_rule: null,
+    ticket: null,
+    general_requirements: null,
+    organization: [],
+    authentication_data: [],
+    crypto_address: null,
+    activity: null,
+    geo_coordinates: null,
+    ...overrides,
+});
+export { createDefaultUserData };

package/dist/api/data/user/validateLimitedSecurity.d.ts

@@ -0,0 +1,3 @@
+import type { ValidateLimitedSecurity } from "../../../types";
+declare const createDefaultValidateLimitedSecurity: (overrides?: Partial<ValidateLimitedSecurity>) => ValidateLimitedSecurity;
+export { createDefaultValidateLimitedSecurity };

package/dist/api/data/user/validateLimitedSecurity.js

@@ -0,0 +1,16 @@
+const createDefaultValidateLimitedSecurity = (overrides) => ({
+    result: null,
+    notes: null,
+    last_activity: null,
+    authentication: null,
+    validate: null,
+    function_code: null,
+    response_time: null,
+    time_zone: null,
+    time_zone_name: null,
+    info: null,
+    validate_data: null,
+    geo_coordinates: null,
+    ...overrides,
+});
+export { createDefaultValidateLimitedSecurity };

package/dist/api/data/user/validateSecurityData.d.ts

@@ -0,0 +1,3 @@
+import type { ValidateUserSecurity } from "../../../types";
+declare const createDefaultValidateUserSecurity: (overrides?: Partial<ValidateUserSecurity>) => ValidateUserSecurity;
+export { createDefaultValidateUserSecurity };

package/dist/api/data/user/validateSecurityData.js

@@ -0,0 +1,16 @@
+const createDefaultValidateUserSecurity = (overrides) => ({
+    result: null,
+    notes: null,
+    last_activity: null,
+    authentication: null,
+    validate: null,
+    function_code: null,
+    response_time: null,
+    time_zone: null,
+    time_zone_name: null,
+    info: null,
+    validate_data: null,
+    geo_coordinates: null,
+    ...overrides,
+});
+export { createDefaultValidateUserSecurity };

package/dist/api/data/user/verifyUserSecurity.d.ts

@@ -0,0 +1,3 @@
+import type { VerifyUserSecurity } from "../../../types";
+declare const createDefaultVerifyUserSecurity: (overrides?: Partial<VerifyUserSecurity>) => VerifyUserSecurity;
+export { createDefaultVerifyUserSecurity };

package/dist/api/data/user/verifyUserSecurity.js

@@ -0,0 +1,16 @@
+const createDefaultVerifyUserSecurity = (overrides) => ({
+    result: null,
+    notes: null,
+    last_activity: null,
+    authentication: null,
+    validate: null,
+    function_code: null,
+    response_time: null,
+    time_zone: null,
+    time_zone_name: null,
+    info: null,
+    verify_data: null,
+    geo_coordinates: null,
+    ...overrides,
+});
+export { createDefaultVerifyUserSecurity };

package/dist/api/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./api";
+export * from "./bc-api";
+export * from "./proxy";
+export * from "./context";
+export * from "./data";
+export * from "./service";

package/dist/api/index.js

@@ -0,0 +1,6 @@
+export * from "./api";
+export * from "./bc-api";
+export * from "./proxy";
+export * from "./context";
+export * from "./data";
+export * from "./service";

package/dist/api/proxy/accountProxy.d.ts

@@ -0,0 +1,9 @@
+import type { BaseProxyParameters } from "../../types";
+import { BaseProxy } from "./baseProxy";
+declare class AccountProxy extends BaseProxy {
+    private accountService;
+    constructor(data: BaseProxyParameters);
+    get: (accountId: number) => Promise<import("../..").ApiResponse<import("../..").AccountData>>;
+    getLimits: (accountId: number) => Promise<import("../..").ApiResponse<import("../..").AccountData>>;
+}
+export { AccountProxy };

package/dist/api/proxy/accountProxy.js

@@ -0,0 +1,17 @@
+import { AccountService } from "../service/accountService";
+import { BaseProxy } from "./baseProxy";
+class AccountProxy extends BaseProxy {
+    accountService;
+    constructor(data) {
+        super(data);
+        this.accountService = new AccountService(data);
+    }
+    // #region "GET"
+    get = async (accountId) => {
+        return this.accountService.get(accountId);
+    };
+    getLimits = async (accountId) => {
+        return this.accountService.getLimits(accountId);
+    };
+}
+export { AccountProxy };

package/dist/api/proxy/authProxy.d.ts

@@ -0,0 +1,13 @@
+import type { IGenerateLimitedTokenData } from "../../types/api/data/auth";
+import type { BaseProxyParameters, ILoginDeviceCredentialsData, ILoginGoogleCredentialsData, ILoginUserCredentialsData } from "../../types";
+import { BaseProxy } from "./baseProxy";
+declare class AuthProxy extends BaseProxy {
+    private authService;
+    constructor(data: BaseProxyParameters);
+    private login;
+    loginUserCredentials(data: ILoginUserCredentialsData): Promise<import("../..").ApiResponse<import("../..").LoginTokenData>>;
+    loginDeviceCredentials(data: ILoginDeviceCredentialsData): Promise<import("../..").ApiResponse<import("../..").LoginTokenData>>;
+    loginGoogleCredentials(data: ILoginGoogleCredentialsData): Promise<import("../..").ApiResponse<import("../..").LoginTokenData>>;
+    generateLimitedToken(data: IGenerateLimitedTokenData): Promise<import("../..").ApiResponse<import("../..").NodeTokenData>>;
+}
+export { AuthProxy };

package/dist/api/proxy/authProxy.js

@@ -0,0 +1,34 @@
+import { AuthService } from "../service/authService";
+import { ResultHelper } from "../../helper/api/resultHelper";
+import { fillLoginDeviceCredentialsData, fillLoginGoogleCredentialsData, fillLoginUserCredentialsData, } from "../data";
+import { BaseProxy } from "./baseProxy";
+class AuthProxy extends BaseProxy {
+    authService;
+    constructor(data) {
+        super(data);
+        this.authService = new AuthService(data);
+    }
+    async login(data) {
+        const response = await this.authService.login(data);
+        if (ResultHelper.isApproved(response.data.result)) {
+            await this.cookiesHelper.setCredentialCookiesByTokenData(response.data);
+        }
+        return response;
+    }
+    loginUserCredentials(data) {
+        const credentials = fillLoginUserCredentialsData(this.context.getProgramId(), data);
+        return this.login(credentials);
+    }
+    loginDeviceCredentials(data) {
+        const credentials = fillLoginDeviceCredentialsData(this.context.getProgramId(), data);
+        return this.login(credentials);
+    }
+    loginGoogleCredentials(data) {
+        const credentials = fillLoginGoogleCredentialsData(this.context.getProgramId(), data);
+        return this.login(credentials);
+    }
+    generateLimitedToken(data) {
+        return this.authService.generateLimitedToken(data);
+    }
+}
+export { AuthProxy };

package/dist/api/proxy/baseProxy.d.ts

@@ -0,0 +1,9 @@
+import { CookiesHelper } from "../..";
+import type { BaseProxyParameters, ClientContextProvider, ErrorHandler } from "../../types";
+declare abstract class BaseProxy {
+    protected context: ClientContextProvider;
+    protected errorHandler: ErrorHandler;
+    protected cookiesHelper: CookiesHelper;
+    constructor(data: BaseProxyParameters);
+}
+export { BaseProxy };

package/dist/api/proxy/baseProxy.js

@@ -0,0 +1,11 @@
+class BaseProxy {
+    context;
+    errorHandler;
+    cookiesHelper;
+    constructor(data) {
+        this.context = data.context;
+        this.errorHandler = data.errorHandler;
+        this.cookiesHelper = data.cookiesHelper;
+    }
+}
+export { BaseProxy };

package/dist/api/proxy/blockchainProxy.d.ts

@@ -0,0 +1,11 @@
+import type { BaseProxyParameters, IBlockchainDelegateRequestData, IBlockchainMultiSendRequestData, IBlockchainSendRequestData, IBlockchainUndelegateRequestData } from "../../types";
+import { BaseProxy } from "./baseProxy";
+declare class BlockchainProxy extends BaseProxy {
+    private blockchainService;
+    constructor(data: BaseProxyParameters);
+    send: (data: IBlockchainSendRequestData) => Promise<import("../..").ApiResponse<import("../..").BlockchainData>>;
+    multiSend: (data: IBlockchainMultiSendRequestData) => Promise<import("../..").ApiResponse<import("../..").BlockchainData>>;
+    delegate: (data: IBlockchainDelegateRequestData) => Promise<import("../..").ApiResponse<import("../..").BlockchainData>>;
+    undelegate: (data: IBlockchainUndelegateRequestData) => Promise<import("../..").ApiResponse<import("../..").BlockchainData>>;
+}
+export { BlockchainProxy };

package/dist/api/proxy/blockchainProxy.js

@@ -0,0 +1,28 @@
+import { fillBlockchainDelegateData, fillBlockchainMultiSendData, fillBlockchainSendData, fillBlockchainUndelegateData, } from "../data";
+import { BlockchainService } from "../service/blockchainService";
+import { BaseProxy } from "./baseProxy";
+class BlockchainProxy extends BaseProxy {
+    blockchainService;
+    constructor(data) {
+        super(data);
+        this.blockchainService = new BlockchainService(data);
+    }
+    // #region "POST"
+    send = async (data) => {
+        const blockchainData = fillBlockchainSendData(data);
+        return this.blockchainService.send(blockchainData);
+    };
+    multiSend = async (data) => {
+        const blockchainData = fillBlockchainMultiSendData(data);
+        return this.blockchainService.multiSend(blockchainData);
+    };
+    delegate = async (data) => {
+        const blockchainData = fillBlockchainDelegateData(data);
+        return this.blockchainService.delegate(blockchainData);
+    };
+    undelegate = async (data) => {
+        const blockchainData = fillBlockchainUndelegateData(data);
+        return this.blockchainService.undelegate(blockchainData);
+    };
+}
+export { BlockchainProxy };

package/dist/api/proxy/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./accountProxy";
+export * from "./authProxy";
+export * from "./blockchainProxy";
+export * from "./limitedProxy";
+export * from "./orderProxy";
+export * from "./organizationProxy";
+export * from "./programProxy";
+export * from "./promotionProxy";
+export * from "./transactionProxy";
+export * from "./userProxy";

package/dist/api/proxy/index.js

@@ -0,0 +1,10 @@
+export * from "./accountProxy";
+export * from "./authProxy";
+export * from "./blockchainProxy";
+export * from "./limitedProxy";
+export * from "./orderProxy";
+export * from "./organizationProxy";
+export * from "./programProxy";
+export * from "./promotionProxy";
+export * from "./transactionProxy";
+export * from "./userProxy";

package/dist/api/proxy/limitedProxy.d.ts

@@ -0,0 +1,16 @@
+import type { IConfirmEmailData, IConfirmPhoneData, IValidateEmailData, IValidatePhoneData, IVerifyEmailData, IVerifyPhoneData, IValidateForgetPasswordData, IConfirmForgetPasswordData, ICheckForgetPasswordData, BaseProxyParameters } from "../../types";
+import { BaseProxy } from "./baseProxy";
+declare class LimitedProxy extends BaseProxy {
+    private limitedService;
+    constructor(data: BaseProxyParameters);
+    checkForgetPassword: (data: ICheckForgetPasswordData) => Promise<import("../..").ApiResponse<import("../..").ForgetSecurityData>>;
+    validateForgetPassword: (data: IValidateForgetPasswordData) => Promise<import("../..").ApiResponse<import("../..").ForgetSecurityData>>;
+    confirmForgetPassword: (data: IConfirmForgetPasswordData) => Promise<import("../..").ApiResponse<import("../..").ForgetSecurityData>>;
+    validateEmail: (data: IValidateEmailData) => Promise<import("../..").ApiResponse<import("../..").ValidateLimitedSecurity>>;
+    validatePhone: (data: IValidatePhoneData) => Promise<import("../..").ApiResponse<import("../..").ValidateLimitedSecurity>>;
+    verifyEmail: (data: IVerifyEmailData) => Promise<import("../..").ApiResponse<import("../..").VerifyUserSecurity>>;
+    verifyPhone: (data: IVerifyPhoneData) => Promise<import("../..").ApiResponse<import("../..").VerifyUserSecurity>>;
+    confirmEmail: (data: IConfirmEmailData) => Promise<import("../..").ApiResponse<import("../..").ConfirmUserSecurity>>;
+    confirmPhone: (data: IConfirmPhoneData) => Promise<import("../..").ApiResponse<import("../..").ConfirmUserSecurity>>;
+}
+export { LimitedProxy };

package/dist/api/proxy/limitedProxy.js

@@ -0,0 +1,48 @@
+import { fillCheckForgetPasswordData, fillConfirmEmailData, fillConfirmForgetPasswordData, fillConfirmPhoneData, fillValidateEmailData, fillValidateForgetPasswordData, fillValidatePhoneData, fillVerifyEmailData, fillVerifyPhoneData, } from "../data";
+import { LimitedService } from "../service/limitedService";
+import { BaseProxy } from "./baseProxy";
+class LimitedProxy extends BaseProxy {
+    limitedService;
+    constructor(data) {
+        super(data);
+        this.limitedService = new LimitedService(data);
+    }
+    // #region "POST"
+    checkForgetPassword = async (data) => {
+        const forgetSecurityData = fillCheckForgetPasswordData(data);
+        return this.limitedService.checkForgetSecurityData(forgetSecurityData);
+    };
+    validateForgetPassword = async (data) => {
+        const forgetSecurityData = fillValidateForgetPasswordData(data);
+        return this.limitedService.validateForgetSecurityData(forgetSecurityData);
+    };
+    confirmForgetPassword = async (data) => {
+        const forgetSecurityData = fillConfirmForgetPasswordData(data);
+        return this.limitedService.confirmForgetSecurityData(forgetSecurityData);
+    };
+    validateEmail = async (data) => {
+        const validateSecurityData = fillValidateEmailData(data);
+        return this.limitedService.validateSecurityData(validateSecurityData);
+    };
+    validatePhone = async (data) => {
+        const validateSecurityData = fillValidatePhoneData(data);
+        return this.limitedService.validateSecurityData(validateSecurityData);
+    };
+    verifyEmail = async (data) => {
+        const verifySecurityData = fillVerifyEmailData(data);
+        return this.limitedService.verifySecurityData(verifySecurityData);
+    };
+    verifyPhone = async (data) => {
+        const verifySecurityData = fillVerifyPhoneData(data);
+        return this.limitedService.verifySecurityData(verifySecurityData);
+    };
+    confirmEmail = async (data) => {
+        const confirmSecurityData = fillConfirmEmailData(data);
+        return this.limitedService.confirmSecurityData(confirmSecurityData);
+    };
+    confirmPhone = async (data) => {
+        const confirmSecurityData = fillConfirmPhoneData(data);
+        return this.limitedService.confirmSecurityData(confirmSecurityData);
+    };
+}
+export { LimitedProxy };

package/dist/api/proxy/orderProxy.d.ts

@@ -0,0 +1,8 @@
+import type { BaseProxyParameters, ICreateOrderData } from "../../types";
+import { BaseProxy } from "./baseProxy";
+declare class OrderProxy extends BaseProxy {
+    private orderService;
+    constructor(data: BaseProxyParameters);
+    createOrder: (data: ICreateOrderData) => Promise<import("../..").ApiResponse<import("../..").OrderData>>;
+}
+export { OrderProxy };

package/dist/api/proxy/orderProxy.js

@@ -0,0 +1,16 @@
+import { fillCreateOrderData } from "../data";
+import { OrderService } from "../service/orderService";
+import { BaseProxy } from "./baseProxy";
+class OrderProxy extends BaseProxy {
+    orderService;
+    constructor(data) {
+        super(data);
+        this.orderService = new OrderService(data);
+    }
+    // #region "POST"
+    createOrder = async (data) => {
+        const orderData = fillCreateOrderData(data);
+        return this.orderService.create(orderData);
+    };
+}
+export { OrderProxy };

package/dist/api/proxy/organizationProxy.d.ts

@@ -0,0 +1,13 @@
+import type { BaseProxyParameters, ICreateOrganizationData, IUpdateOrganizationData, IUploadOrganizationDocumentData } from "../../types";
+import { BaseProxy } from "./baseProxy";
+declare class OrganizationProxy extends BaseProxy {
+    private organizationService;
+    constructor(data: BaseProxyParameters);
+    userId(): Promise<number>;
+    getOrganization: (id: number) => Promise<import("../..").ApiResponse<import("../..").OrganizationData>>;
+    createOrganization: (data: ICreateOrganizationData) => Promise<import("../..").ApiResponse<import("../..").OrganizationData>>;
+    uploadDocument: (data: IUploadOrganizationDocumentData) => Promise<import("../..").ApiResponse<import("../..").DocumentData>>;
+    updateOrganization: (data: IUpdateOrganizationData) => Promise<import("../..").ApiResponse<import("../..").OrganizationData>>;
+    deleteOrganization: (id: number) => Promise<import("../..").ApiResponse<import("../..").OrganizationData>>;
+}
+export { OrganizationProxy };

package/dist/api/proxy/organizationProxy.js

@@ -0,0 +1,39 @@
+import { fillCreateOrganizationData, fillCreateOrganizationDocumentData, fillUpdateOrganizationData, } from "../data/organization";
+import { OrganizationService } from "../service/organizationService";
+import { BaseProxy } from "./baseProxy";
+class OrganizationProxy extends BaseProxy {
+    organizationService;
+    constructor(data) {
+        super(data);
+        this.organizationService = new OrganizationService(data);
+    }
+    async userId() {
+        return this.cookiesHelper.getUserId();
+    }
+    // #region "GET"
+    getOrganization = async (id) => {
+        return this.organizationService.get(id);
+    };
+    // #endregion
+    // #region "POST"
+    createOrganization = async (data) => {
+        const organizationData = fillCreateOrganizationData(data, await this.userId());
+        return this.organizationService.create(organizationData);
+    };
+    uploadDocument = async (data) => {
+        const documentData = fillCreateOrganizationDocumentData(data);
+        return this.organizationService.createDocument(data.id, documentData);
+    };
+    // #endregion
+    // #region "PUT"
+    updateOrganization = async (data) => {
+        const organizationData = fillUpdateOrganizationData(data, await this.userId());
+        return this.organizationService.update(data.id, organizationData);
+    };
+    // #endregion
+    // #region "DELETE"
+    deleteOrganization = async (id) => {
+        return this.organizationService.delete(id);
+    };
+}
+export { OrganizationProxy };

package/dist/api/proxy/programProxy.d.ts

@@ -0,0 +1,12 @@
+import type { BaseProxyParameters } from "../../types";
+import { BaseProxy } from "./baseProxy";
+declare class ProgramProxy extends BaseProxy {
+    private programService;
+    constructor(data: BaseProxyParameters);
+    get: () => Promise<import("../..").ApiResponse<import("../../types/banking/program").ProgramData>>;
+    getSystemFeatures: () => Promise<import("../..").ApiResponse<import("../../types/banking/program").ProgramData>>;
+    getBin: () => Promise<import("../..").ApiResponse<import("../../types/banking/program").ProgramData>>;
+    getSignUp: () => Promise<import("../..").ApiResponse<import("../../types/banking/program").SignupRequirements>>;
+    getProgramSecurity: () => Promise<import("../..").ApiResponse<import("../../types/banking/program").ProgramData>>;
+}
+export { ProgramProxy };

package/dist/api/proxy/programProxy.js

@@ -0,0 +1,16 @@
+import { ProgramService } from "../service/programService";
+import { BaseProxy } from "./baseProxy";
+class ProgramProxy extends BaseProxy {
+    programService;
+    constructor(data) {
+        super(data);
+        this.programService = new ProgramService(data);
+    }
+    // #region "GET"
+    get = async () => this.programService.get();
+    getSystemFeatures = async () => this.programService.getSystemFeatures();
+    getBin = async () => this.programService.getBin();
+    getSignUp = async () => this.programService.getSignUp();
+    getProgramSecurity = async () => this.programService.getProgramSecurity();
+}
+export { ProgramProxy };

package/dist/api/proxy/promotionProxy.d.ts

@@ -0,0 +1,10 @@
+import type { BaseProxyParameters, GGEZGiftRewards } from "../../types";
+import { BaseProxy } from "./baseProxy";
+declare class PromotionProxy extends BaseProxy {
+    private promotionService;
+    constructor(data: BaseProxyParameters);
+    getPromotionByCode: (code: string) => Promise<import("../..").ApiResponse<import("../..").PromotionDetails>>;
+    getTwitterSpotlightPostIds: () => Promise<import("../..").ApiResponse<import("../..").TwitterSpotlightPostIdsResult>>;
+    incrementPromotionParticipants: (data: GGEZGiftRewards) => Promise<import("../..").ApiResponse<import("../..").PromotionIncrementResult>>;
+}
+export { PromotionProxy };

package/dist/api/proxy/promotionProxy.js

@@ -0,0 +1,23 @@
+import { PromotionService } from "../service/promotionService";
+import { BaseProxy } from "./baseProxy";
+class PromotionProxy extends BaseProxy {
+    promotionService;
+    constructor(data) {
+        super(data);
+        this.promotionService = new PromotionService(data);
+    }
+    // #region "GET"
+    getPromotionByCode = async (code) => {
+        return this.promotionService.getPromotionByCode(code);
+    };
+    getTwitterSpotlightPostIds = async () => {
+        return this.promotionService.getTwitterSpotlightPostIds();
+    };
+    // #endregion
+    // #region "PUT"
+    incrementPromotionParticipants = async (data) => {
+        const giftRewards = data;
+        return this.promotionService.incrementPromotionParticipants(giftRewards);
+    };
+}
+export { PromotionProxy };