@esolve/ng-esolve-connect 0.108.0 → 0.109.0

package/esm2022/index.mjs

@@ -71,4 +71,6 @@ export * from './lib/reviews';
 export * from './lib/albums';
 // Captcha
 export * from './lib/captcha';
-//# sourceMappingURL=data:application/json;base64,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
+// Affiliates
+export * from './lib/affiliates';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/account/registration/esolve-registration-data.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLXJlZ2lzdHJhdGlvbi1kYXRhLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmctZXNvbHZlLWNvbm5lY3Qvc3JjL2xpYi9hY2NvdW50L3JlZ2lzdHJhdGlvbi9lc29sdmUtcmVnaXN0cmF0aW9uLWRhdGEuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIEVzb2x2ZVJlZ2lzdHJhdGlvbkRhdGEge1xuICAgIGVtYWlsOiBzdHJpbmc7XG4gICAgcGFzc3dvcmQ6IHN0cmluZztcbiAgICBjb25maXJtX3Bhc3N3b3JkPzogc3RyaW5nO1xuICAgIHRpdGxlPzogc3RyaW5nO1xuICAgIGZpcnN0bmFtZT86IHN0cmluZztcbiAgICBzdXJuYW1lPzogc3RyaW5nO1xuICAgIGxveWFsdHludW1iZXI/OiBzdHJpbmc7XG4gICAgaWRudW1iZXI/OiBzdHJpbmc7XG4gICAgdGVsbnVtYmVyPzogc3RyaW5nO1xuICAgIGNlbGxudW1iZXI/OiBzdHJpbmc7XG4gICAgcmVnaXN0cmF0aW9uX3R5cGU/OiBzdHJpbmc7XG4gICAgYnVzaW5lc3NfbmFtZT86IHN0cmluZztcbiAgICB2YXRfbnVtYmVyPzogc3RyaW5nO1xuICAgIGFjY291bnQ/OiBzdHJpbmc7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLXJlZ2lzdHJhdGlvbi1kYXRhLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmctZXNvbHZlLWNvbm5lY3Qvc3JjL2xpYi9hY2NvdW50L3JlZ2lzdHJhdGlvbi9lc29sdmUtcmVnaXN0cmF0aW9uLWRhdGEuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIEVzb2x2ZVJlZ2lzdHJhdGlvbkRhdGEge1xuICAgIGVtYWlsOiBzdHJpbmc7XG4gICAgcGFzc3dvcmQ6IHN0cmluZztcbiAgICBjb25maXJtX3Bhc3N3b3JkPzogc3RyaW5nO1xuICAgIHRpdGxlPzogc3RyaW5nO1xuICAgIGZpcnN0bmFtZT86IHN0cmluZztcbiAgICBzdXJuYW1lPzogc3RyaW5nO1xuICAgIGxveWFsdHludW1iZXI/OiBzdHJpbmc7XG4gICAgaWRudW1iZXI/OiBzdHJpbmc7XG4gICAgdGVsbnVtYmVyPzogc3RyaW5nO1xuICAgIGNlbGxudW1iZXI/OiBzdHJpbmc7XG4gICAgcmVnaXN0cmF0aW9uX3R5cGU/OiBzdHJpbmc7XG4gICAgYnVzaW5lc3NfbmFtZT86IHN0cmluZztcbiAgICB2YXRfbnVtYmVyPzogc3RyaW5nO1xuICAgIGFjY291bnQ/OiBzdHJpbmc7XG4gICAgY2FwdGNoYV9rZXk/OiBzdHJpbmc7XG4gICAgY2FwdGNoYV9jb2RlPzogc3RyaW5nO1xufVxuIl19

package/esm2022/lib/affiliates/classes/esolve-affiliate-check-result.model.mjs

@@ -0,0 +1,43 @@
+import { EsolveAffiliate } from './esolve-affiliate.model';
+/**
+ * Represents the result of an affiliate-related API call.
+ *
+ * @remarks
+ * This class is used to encapsulate the result of an affiliate-related API call,
+ * providing access to the affiliate, linked affiliates, and additional data.
+ */
+export class EsolveAffiliateCheckResult {
+    constructor(record) {
+        /**
+         * Indicates whether user confirmation is required for the affiliate linking.
+         * @default false
+         */
+        this.confirmation_required = false;
+        /**
+         * An array of linked affiliates associated with the current user.
+         * @default []
+         */
+        this.linked_affiliates = [];
+        /**
+         * The total number of linked affiliates associated with the current user.
+         * @default 0
+         */
+        this.total_linked_affiliates = 0;
+        if (record) {
+            this.affiliate = new EsolveAffiliate(record.affiliate);
+            this.confirmation_required = !!record.confirmation_required;
+            this.linked_affiliates = this.processAffiliates(record.linked_affiliates ?? []);
+            this.total_linked_affiliates = +(record.total_linked_affiliates ?? 0);
+        }
+    }
+    /**
+     * Processes an array of affiliate records and returns an array of EsolveAffiliate instances.
+     *
+     * @param affiliate_records - The affiliate records to process.
+     * @returns An array of EsolveAffiliate instances.
+     */
+    processAffiliates(affiliate_records) {
+        return affiliate_records.map((record) => new EsolveAffiliate(record));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/affiliates/classes/esolve-affiliate-link-result.model.mjs

@@ -0,0 +1,9 @@
+import { EsolveResponseResult } from '../../shared/response';
+export class EsolveAffiliateLinkResult extends EsolveResponseResult {
+    constructor(response) {
+        super(response);
+        this.id = 0;
+        this.id = +response.esolve_id;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWFmZmlsaWF0ZS1saW5rLXJlc3VsdC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmctZXNvbHZlLWNvbm5lY3Qvc3JjL2xpYi9hZmZpbGlhdGVzL2NsYXNzZXMvZXNvbHZlLWFmZmlsaWF0ZS1saW5rLXJlc3VsdC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUk3RCxNQUFNLE9BQU8seUJBQTBCLFNBQVEsb0JBQW9CO0lBRy9ELFlBQVksUUFBcUM7UUFDN0MsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBSGIsT0FBRSxHQUFHLENBQUMsQ0FBQztRQUtWLElBQUksQ0FBQyxFQUFFLEdBQUcsQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDO0lBQ2xDLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVzb2x2ZVJlc3BvbnNlUmVzdWx0IH0gZnJvbSAnLi4vLi4vc2hhcmVkL3Jlc3BvbnNlJztcblxuaW1wb3J0IHsgRXNvbHZlQWZmaWxpYXRlTGlua1Jlc3BvbnNlIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG5leHBvcnQgY2xhc3MgRXNvbHZlQWZmaWxpYXRlTGlua1Jlc3VsdCBleHRlbmRzIEVzb2x2ZVJlc3BvbnNlUmVzdWx0IHtcbiAgICBwdWJsaWMgaWQgPSAwO1xuXG4gICAgY29uc3RydWN0b3IocmVzcG9uc2U6IEVzb2x2ZUFmZmlsaWF0ZUxpbmtSZXNwb25zZSkge1xuICAgICAgICBzdXBlcihyZXNwb25zZSk7XG5cbiAgICAgICAgdGhpcy5pZCA9ICtyZXNwb25zZS5lc29sdmVfaWQ7XG4gICAgfVxufVxuIl19

package/esm2022/lib/affiliates/classes/esolve-affiliate.model.mjs

@@ -0,0 +1,47 @@
+/**
+ * Represents an Esolve Affiliate with properties and a constructor to initialize from a record.
+ */
+export class EsolveAffiliate {
+    /**
+     * Constructs a new EsolveAffiliate instance.
+     *
+     * @param record - An optional partial EsolveAffiliateRecord to initialize the instance from.
+     *
+     * @remarks
+     * If a record is provided, the instance properties are populated from the record.
+     * If a record property is missing or null, the corresponding instance property is set to its default value.
+     *
+     * @example
+     * ```typescript
+     * const record: Partial<EsolveAffiliateRecord> = {
+     *     id: '123',
+     *     affiliate_name: 'Example Affiliate',
+     *     affiliate_domain: 'example.com'
+     *     affiliate_key: 'example-key',
+     *     default: true
+     * };
+     *
+     * const affiliate = new EsolveAffiliate(record);
+     * console.log(affiliate.id); // Output: 123
+     * console.log(affiliate.name); // Output: Example Affiliate
+     * console.log(affiliate.key); // Output: example-key
+     * console.log(affiliate.is_default); // Output: true
+     * ```
+     */
+    constructor(record) {
+        this.id = 0;
+        this.name = '';
+        this.key = '';
+        this.domain = '';
+        if (record) {
+            this.id = +(record.id ?? 0);
+            this.name = record.affiliate_name ?? '';
+            this.key = record.affiliate_key ?? '';
+            this.domain = record.affiliate_domain ?? '';
+            if (typeof record.default !== 'undefined') {
+                this.is_default = !!+record.default;
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/affiliates/classes/index.mjs

@@ -0,0 +1,4 @@
+export * from './esolve-affiliate-check-result.model';
+export * from './esolve-affiliate-link-result.model';
+export * from './esolve-affiliate.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nLWVzb2x2ZS1jb25uZWN0L3NyYy9saWIvYWZmaWxpYXRlcy9jbGFzc2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lc29sdmUtYWZmaWxpYXRlLWNoZWNrLXJlc3VsdC5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL2Vzb2x2ZS1hZmZpbGlhdGUtbGluay1yZXN1bHQubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9lc29sdmUtYWZmaWxpYXRlLm1vZGVsJztcbiJdfQ==

package/esm2022/lib/affiliates/index.mjs

@@ -0,0 +1,5 @@
+export * from './classes';
+export * from './interfaces';
+export * from './services';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nLWVzb2x2ZS1jb25uZWN0L3NyYy9saWIvYWZmaWxpYXRlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2xhc3Nlcyc7XG5leHBvcnQgKiBmcm9tICcuL2ludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==

package/esm2022/lib/affiliates/interfaces/esolve-affiliate-check-record.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWFmZmlsaWF0ZS1jaGVjay1yZWNvcmQuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9uZy1lc29sdmUtY29ubmVjdC9zcmMvbGliL2FmZmlsaWF0ZXMvaW50ZXJmYWNlcy9lc29sdmUtYWZmaWxpYXRlLWNoZWNrLXJlY29yZC5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVzb2x2ZUFmZmlsaWF0ZVJlY29yZCB9IGZyb20gJy4vZXNvbHZlLWFmZmlsaWF0ZS1yZWNvcmQuaW50ZXJmYWNlJztcblxuZXhwb3J0IGludGVyZmFjZSBFc29sdmVBZmZpbGlhdGVDaGVja1JlY29yZCB7XG4gICAgYWZmaWxpYXRlOiBFc29sdmVBZmZpbGlhdGVSZWNvcmQ7XG4gICAgY29uZmlybWF0aW9uX3JlcXVpcmVkOiBib29sZWFuO1xuICAgIGxpbmtlZF9hZmZpbGlhdGVzOiBFc29sdmVBZmZpbGlhdGVSZWNvcmRbXTtcbiAgICB0b3RhbF9saW5rZWRfYWZmaWxpYXRlczogbnVtYmVyO1xufVxuIl19

package/esm2022/lib/affiliates/interfaces/esolve-affiliate-link-options.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWFmZmlsaWF0ZS1saW5rLW9wdGlvbnMuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9uZy1lc29sdmUtY29ubmVjdC9zcmMvbGliL2FmZmlsaWF0ZXMvaW50ZXJmYWNlcy9lc29sdmUtYWZmaWxpYXRlLWxpbmstb3B0aW9ucy5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgRXNvbHZlQWZmaWxpYXRlTGlua09wdGlvbnMge1xuICAgIGFmZmlsaWF0ZV9pZD86IG51bWJlcjtcbiAgICBhZmZpbGlhdGVfa2V5Pzogc3RyaW5nO1xufVxuIl19

package/esm2022/lib/affiliates/interfaces/esolve-affiliate-record.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWFmZmlsaWF0ZS1yZWNvcmQuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9uZy1lc29sdmUtY29ubmVjdC9zcmMvbGliL2FmZmlsaWF0ZXMvaW50ZXJmYWNlcy9lc29sdmUtYWZmaWxpYXRlLXJlY29yZC5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgRXNvbHZlQWZmaWxpYXRlUmVjb3JkIHtcbiAgICBpZDogbnVtYmVyO1xuICAgIGFmZmlsaWF0ZV9uYW1lOiBzdHJpbmc7XG4gICAgYWZmaWxpYXRlX2tleTogc3RyaW5nO1xuICAgIGFmZmlsaWF0ZV9kb21haW46IHN0cmluZztcbiAgICBkZWZhdWx0OiBib29sZWFuO1xufVxuIl19

package/esm2022/lib/affiliates/interfaces/esolve-affiliates-options.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWFmZmlsaWF0ZXMtb3B0aW9ucy5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nLWVzb2x2ZS1jb25uZWN0L3NyYy9saWIvYWZmaWxpYXRlcy9pbnRlcmZhY2VzL2Vzb2x2ZS1hZmZpbGlhdGVzLW9wdGlvbnMuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIEVzb2x2ZUFmZmlsaWF0ZXNPcHRpb25zIHtcbiAgICBhZmZpbGlhdGVfaWQ/OiBudW1iZXI7XG4gICAgYWZmaWxpYXRlX2tleT86IHN0cmluZztcbiAgICBwYWdlPzogbnVtYmVyO1xuICAgIHJvd3M/OiBudW1iZXI7XG59XG4iXX0=

package/esm2022/lib/affiliates/interfaces/index.mjs

@@ -0,0 +1,5 @@
+export * from './esolve-affiliate-check-record.interface';
+export * from './esolve-affiliate-link-options.interface';
+export * from './esolve-affiliate-record.interface';
+export * from './esolve-affiliates-options.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nLWVzb2x2ZS1jb25uZWN0L3NyYy9saWIvYWZmaWxpYXRlcy9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkNBQTJDLENBQUM7QUFDMUQsY0FBYywyQ0FBMkMsQ0FBQztBQUMxRCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsdUNBQXVDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Vzb2x2ZS1hZmZpbGlhdGUtY2hlY2stcmVjb3JkLmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2Vzb2x2ZS1hZmZpbGlhdGUtbGluay1vcHRpb25zLmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2Vzb2x2ZS1hZmZpbGlhdGUtcmVjb3JkLmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2Vzb2x2ZS1hZmZpbGlhdGVzLW9wdGlvbnMuaW50ZXJmYWNlJztcbiJdfQ==

package/esm2022/lib/affiliates/services/esolve-affiliate.service.mjs

@@ -0,0 +1,168 @@
+import { inject, Injectable } from '@angular/core';
+import { HttpClient, HttpParams, } from '@angular/common/http';
+import { catchError, map } from 'rxjs';
+import { EsolveConfigService } from '../../core';
+import { EsolveErrorHandlerService, EsolveList, EsolveResponseHandlerService, } from '../../shared';
+import { EsolveAffiliate, EsolveAffiliateCheckResult, EsolveAffiliateLinkResult, } from '../classes';
+import * as i0 from "@angular/core";
+export class EsolveAffiliateService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.config = inject(EsolveConfigService);
+        this.errorHandler = inject(EsolveErrorHandlerService);
+        this.responseHandler = inject(EsolveResponseHandlerService);
+    }
+    /**
+     * Retrieves affiliate records based on the provided options.
+     *
+     * @param options - Optional parameters for filtering and pagination.
+     * @returns - An observable that emits an `EsolveList` containing the retrieved affiliate records and additional data.
+     *
+     * @remarks
+     * If the `options` parameter is provided, it is used to construct an HTTP GET request with query parameters for pagination.
+     * The response is validated and transformed into an `EsolveList` object.
+     * If the response does not contain any records, an error is thrown.
+     * The function utilizes the `HttpClient` to make the HTTP request and applies RxJS operators for handling the response.
+     *
+     * @example
+     * ```typescript
+     * const options: EsolveAffiliatesOptions = {
+     *     page: 1,
+     *     rows: 10,
+     * };
+     *
+     * this.affiliateService.getAffiliates(options).subscribe((affiliates) => {
+     *     console.log(affiliates.items); // Array of EsolveAffiliate objects
+     *     console.log(affiliates.page); // 1
+     *     console.log(affiliates.rows); // 10
+     *     console.log(affiliates.totalRecords); // Total number of affiliate records
+     * });
+     * ```
+     */
+    getAffiliates(options) {
+        let params = new HttpParams();
+        if (options) {
+            if (options.page) {
+                params = params.set('page', options.page);
+            }
+            if (options.rows) {
+                params = params.set('rows', options.rows);
+            }
+        }
+        return this.http
+            .get(`${this.config.api_url}/get-affiliates.php`, {
+            params,
+        })
+            .pipe(map((response) => {
+            if (response.records === undefined ||
+                response.records.length <= 0) {
+                throw response;
+            }
+            const items = this.processAffiliates(response.records);
+            return new EsolveList(items, options?.page, options?.rows, +response.additional_data.total_records);
+        }));
+    }
+    /**
+     * Retrieves affiliate information for user linking based on the provided affiliate key.
+     *
+     * @param affiliate_key - The unique identifier for the affiliate.
+     * @returns - An observable that emits an `EsolveAffiliateCheckResult` object containing the retrieved affiliate check record.
+     *
+     * @remarks
+     * If the `affiliate_key` parameter is an empty string, an error is emitted using the `EsolveErrorHandlerService`.
+     * The function constructs an HTTP GET request with the affiliate key as a query parameter.
+     * The response is validated and transformed into an `EsolveAffiliateCheckResult` object.
+     * If the response does not contain a valid record, an error is thrown.
+     * The function utilizes the `HttpClient` to make the HTTP request and applies RxJS operators for handling the response.
+     *
+     * @example
+     * ```typescript
+     * this.affiliateService.getAffiliateCheck('12345').subscribe((affiliateCheckResult) => {
+     *     console.log(affiliateCheckResult.record); // EsolveAffiliateCheckRecord object
+     * });
+     * ```
+     */
+    getAffiliateCheck(affiliate_key) {
+        if (affiliate_key === '') {
+            return this.errorHandler.emitError('affiliate_key_required', 'Affiliate key is required is required');
+        }
+        const params = new HttpParams({
+            fromObject: { affiliate_key },
+        });
+        return this.http
+            .get(`${this.config.api_url}/get-affiliate-check.php`, {
+            params,
+        })
+            .pipe(map((response) => {
+            let record = response.records;
+            if (Array.isArray(record)) {
+                record = undefined;
+            }
+            if (!record) {
+                throw response;
+            }
+            return new EsolveAffiliateCheckResult(record);
+        }));
+    }
+    /**
+     * Sets the affiliate link using the provided options.
+     *
+     * @param options - The options for setting the affiliate link.
+     * @returns - An observable that emits the result of the affiliate link set operation.
+     *
+     * @remarks
+     * This function constructs a FormData object with the affiliate key from the provided options.
+     * It then sends a POST request to the API endpoint `/set-affiliate-link.php` with the FormData.
+     * The response is validated and transformed into an `EsolveAffiliateLinkResult` object.
+     * If an error occurs during the HTTP request, it is handled and an appropriate error is emitted.
+     */
+    setAffiliateLink(options) {
+        const form_data = new FormData();
+        if (options.affiliate_id !== undefined && options.affiliate_id !== 0) {
+            form_data.append('affiliate_key', options.affiliate_id.toString());
+        }
+        else if (options.affiliate_key !== undefined &&
+            options.affiliate_key !== '') {
+            form_data.append('affiliate_key', options.affiliate_key);
+        }
+        else {
+            return this.errorHandler.emitError('affiliate_key_id_required', 'Affiliate key or id is required is required');
+        }
+        return this.http
+            .post(`${this.config.api_url}/set-affiliate-link.php`, form_data, {
+            responseType: 'json',
+            observe: 'body',
+        })
+            .pipe(map((http_response) => this.responseHandler.validateSingleHttpResponse(http_response, (response) => new EsolveAffiliateLinkResult(response))), catchError((errorRes) => {
+            return this.errorHandler.handleHttpPostError('set-enquiry', errorRes);
+        }));
+    }
+    /**
+     * Processes an array of `EsolveAffiliateRecord` objects and transforms them into an array of `EsolveAffiliate` objects.
+     *
+     * @param records - An array of `EsolveAffiliateRecord` objects to be processed.
+     * @returns - An array of `EsolveAffiliate` objects, where each object is created from a corresponding `EsolveAffiliateRecord` object.
+     *
+     * @remarks
+     * This function iterates over the input array of `EsolveAffiliateRecord` objects and creates a new `EsolveAffiliate` object for each record.
+     * If the input array is empty, an empty array is returned.
+     */
+    processAffiliates(records) {
+        const items = [];
+        if (records.length > 0) {
+            for (const record of records) {
+                items.push(new EsolveAffiliate(record));
+            }
+        }
+        return items;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: EsolveAffiliateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: EsolveAffiliateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: EsolveAffiliateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esolve-affiliate.service.js","sourceRoot":"","sources":["../../../../../../../libs/ng-esolve-connect/src/lib/affiliates/services/esolve-affiliate.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport {\n    HttpClient,\n    HttpErrorResponse,\n    HttpParams,\n} from '@angular/common/http';\n\nimport { catchError, map } from 'rxjs';\n\nimport { EsolveConfigService } from '../../core';\nimport {\n    EsolveErrorHandlerService,\n    EsolveGetResponse,\n    EsolveList,\n    EsolveResponseHandlerService,\n    EsolveSetResponse,\n} from '../../shared';\n\nimport {\n    EsolveAffiliateCheckRecord,\n    EsolveAffiliateLinkOptions,\n    EsolveAffiliateRecord,\n    EsolveAffiliatesOptions,\n} from '../interfaces';\nimport { EsolveAffiliateLinkResponse } from '../types';\nimport {\n    EsolveAffiliate,\n    EsolveAffiliateCheckResult,\n    EsolveAffiliateLinkResult,\n} from '../classes';\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class EsolveAffiliateService {\n    private readonly http = inject(HttpClient);\n    private readonly config = inject(EsolveConfigService);\n    private readonly errorHandler = inject(EsolveErrorHandlerService);\n    private readonly responseHandler = inject(EsolveResponseHandlerService);\n\n    /**\n     * Retrieves affiliate records based on the provided options.\n     *\n     * @param options - Optional parameters for filtering and pagination.\n     * @returns - An observable that emits an `EsolveList` containing the retrieved affiliate records and additional data.\n     *\n     * @remarks\n     * If the `options` parameter is provided, it is used to construct an HTTP GET request with query parameters for pagination.\n     * The response is validated and transformed into an `EsolveList` object.\n     * If the response does not contain any records, an error is thrown.\n     * The function utilizes the `HttpClient` to make the HTTP request and applies RxJS operators for handling the response.\n     *\n     * @example\n     * ```typescript\n     * const options: EsolveAffiliatesOptions = {\n     *     page: 1,\n     *     rows: 10,\n     * };\n     *\n     * this.affiliateService.getAffiliates(options).subscribe((affiliates) => {\n     *     console.log(affiliates.items); // Array of EsolveAffiliate objects\n     *     console.log(affiliates.page); // 1\n     *     console.log(affiliates.rows); // 10\n     *     console.log(affiliates.totalRecords); // Total number of affiliate records\n     * });\n     * ```\n     */\n    public getAffiliates(options?: EsolveAffiliatesOptions) {\n        let params = new HttpParams();\n\n        if (options) {\n            if (options.page) {\n                params = params.set('page', options.page);\n            }\n\n            if (options.rows) {\n                params = params.set('rows', options.rows);\n            }\n        }\n\n        return this.http\n            .get<EsolveGetResponse<EsolveAffiliateRecord[]>>(\n                `${this.config.api_url}/get-affiliates.php`,\n                {\n                    params,\n                },\n            )\n            .pipe(\n                map((response) => {\n                    if (\n                        response.records === undefined ||\n                        response.records.length <= 0\n                    ) {\n                        throw response;\n                    }\n\n                    const items = this.processAffiliates(response.records);\n\n                    return new EsolveList(\n                        items,\n                        options?.page,\n                        options?.rows,\n                        +response.additional_data.total_records,\n                    );\n                }),\n            );\n    }\n\n    /**\n     * Retrieves affiliate information for user linking based on the provided affiliate key.\n     *\n     * @param affiliate_key - The unique identifier for the affiliate.\n     * @returns - An observable that emits an `EsolveAffiliateCheckResult` object containing the retrieved affiliate check record.\n     *\n     * @remarks\n     * If the `affiliate_key` parameter is an empty string, an error is emitted using the `EsolveErrorHandlerService`.\n     * The function constructs an HTTP GET request with the affiliate key as a query parameter.\n     * The response is validated and transformed into an `EsolveAffiliateCheckResult` object.\n     * If the response does not contain a valid record, an error is thrown.\n     * The function utilizes the `HttpClient` to make the HTTP request and applies RxJS operators for handling the response.\n     *\n     * @example\n     * ```typescript\n     * this.affiliateService.getAffiliateCheck('12345').subscribe((affiliateCheckResult) => {\n     *     console.log(affiliateCheckResult.record); // EsolveAffiliateCheckRecord object\n     * });\n     * ```\n     */\n    public getAffiliateCheck(affiliate_key: string) {\n        if (affiliate_key === '') {\n            return this.errorHandler.emitError(\n                'affiliate_key_required',\n                'Affiliate key is required is required',\n            );\n        }\n\n        const params = new HttpParams({\n            fromObject: { affiliate_key },\n        });\n\n        return this.http\n            .get<EsolveGetResponse<EsolveAffiliateCheckRecord>>(\n                `${this.config.api_url}/get-affiliate-check.php`,\n                {\n                    params,\n                },\n            )\n            .pipe(\n                map((response) => {\n                    let record = response.records;\n\n                    if (Array.isArray(record)) {\n                        record = undefined;\n                    }\n\n                    if (!record) {\n                        throw response;\n                    }\n\n                    return new EsolveAffiliateCheckResult(record);\n                }),\n            );\n    }\n\n    /**\n     * Sets the affiliate link using the provided options.\n     *\n     * @param options - The options for setting the affiliate link.\n     * @returns - An observable that emits the result of the affiliate link set operation.\n     *\n     * @remarks\n     * This function constructs a FormData object with the affiliate key from the provided options.\n     * It then sends a POST request to the API endpoint `/set-affiliate-link.php` with the FormData.\n     * The response is validated and transformed into an `EsolveAffiliateLinkResult` object.\n     * If an error occurs during the HTTP request, it is handled and an appropriate error is emitted.\n     */\n    public setAffiliateLink(options: EsolveAffiliateLinkOptions) {\n        const form_data = new FormData();\n\n        if (options.affiliate_id !== undefined && options.affiliate_id !== 0) {\n            form_data.append('affiliate_key', options.affiliate_id.toString());\n        } else if (\n            options.affiliate_key !== undefined &&\n            options.affiliate_key !== ''\n        ) {\n            form_data.append('affiliate_key', options.affiliate_key);\n        } else {\n            return this.errorHandler.emitError(\n                'affiliate_key_id_required',\n                'Affiliate key or id is required is required',\n            );\n        }\n\n        return this.http\n            .post<EsolveSetResponse<EsolveAffiliateLinkResponse>>(\n                `${this.config.api_url}/set-affiliate-link.php`,\n                form_data,\n                {\n                    responseType: 'json',\n                    observe: 'body',\n                },\n            )\n            .pipe(\n                map((http_response) =>\n                    this.responseHandler.validateSingleHttpResponse(\n                        http_response,\n                        (response) => new EsolveAffiliateLinkResult(response),\n                    ),\n                ),\n                catchError((errorRes: HttpErrorResponse | any) => {\n                    return this.errorHandler.handleHttpPostError(\n                        'set-enquiry',\n                        errorRes,\n                    );\n                }),\n            );\n    }\n\n    /**\n     * Processes an array of `EsolveAffiliateRecord` objects and transforms them into an array of `EsolveAffiliate` objects.\n     *\n     * @param records - An array of `EsolveAffiliateRecord` objects to be processed.\n     * @returns - An array of `EsolveAffiliate` objects, where each object is created from a corresponding `EsolveAffiliateRecord` object.\n     *\n     * @remarks\n     * This function iterates over the input array of `EsolveAffiliateRecord` objects and creates a new `EsolveAffiliate` object for each record.\n     * If the input array is empty, an empty array is returned.\n     */\n    private processAffiliates(records: EsolveAffiliateRecord[]) {\n        const items: EsolveAffiliate[] = [];\n\n        if (records.length > 0) {\n            for (const record of records) {\n                items.push(new EsolveAffiliate(record));\n            }\n        }\n\n        return items;\n    }\n}\n"]}

package/esm2022/lib/affiliates/services/index.mjs

@@ -0,0 +1,2 @@
+export * from './esolve-affiliate.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nLWVzb2x2ZS1jb25uZWN0L3NyYy9saWIvYWZmaWxpYXRlcy9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lc29sdmUtYWZmaWxpYXRlLnNlcnZpY2UnO1xuIl19

package/esm2022/lib/affiliates/types/esolve-affiliate-link-response.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWFmZmlsaWF0ZS1saW5rLXJlc3BvbnNlLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nLWVzb2x2ZS1jb25uZWN0L3NyYy9saWIvYWZmaWxpYXRlcy90eXBlcy9lc29sdmUtYWZmaWxpYXRlLWxpbmstcmVzcG9uc2UudHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXNvbHZlUG9zdFJlc3BvbnNlSXRlbSB9IGZyb20gJy4uLy4uL3NoYXJlZCc7XG5cbmV4cG9ydCB0eXBlIEVzb2x2ZUFmZmlsaWF0ZUxpbmtSZXNwb25zZSA9IEVzb2x2ZVBvc3RSZXNwb25zZUl0ZW07XG4iXX0=

package/esm2022/lib/affiliates/types/index.mjs

@@ -0,0 +1,2 @@
+export * from './esolve-affiliate-link-response.type';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nLWVzb2x2ZS1jb25uZWN0L3NyYy9saWIvYWZmaWxpYXRlcy90eXBlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lc29sdmUtYWZmaWxpYXRlLWxpbmstcmVzcG9uc2UudHlwZSc7XG4iXX0=

package/esm2022/lib/captcha/types/esolve-captcha-action.type.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWNhcHRjaGEtYWN0aW9uLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nLWVzb2x2ZS1jb25uZWN0L3NyYy9saWIvY2FwdGNoYS90eXBlcy9lc29sdmUtY2FwdGNoYS1hY3Rpb24udHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgRXNvbHZlQ2FwdGNoYUFjdGlvbiA9ICdvdHAnIHwgJ2ZvcmdvdC1wYXNzd29yZCcgfCAnZW5xdWlyeSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNvbHZlLWNhcHRjaGEtYWN0aW9uLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nLWVzb2x2ZS1jb25uZWN0L3NyYy9saWIvY2FwdGNoYS90eXBlcy9lc29sdmUtY2FwdGNoYS1hY3Rpb24udHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgRXNvbHZlQ2FwdGNoYUFjdGlvbiA9XG4gICAgfCAncmVnaXN0ZXInXG4gICAgfCAnb3RwJ1xuICAgIHwgJ2ZvcmdvdC1wYXNzd29yZCdcbiAgICB8ICdlbnF1aXJ5JztcbiJdfQ==