@experteam-mx/ngx-services 20.0.0-beta.4 → 20.0.1

package/esm2022/lib/apis/api-composition.service.mjs

@@ -0,0 +1,55 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-cookie-service";
+import * as i2 from "@angular/common/http";
+export class ApiCompositionService {
+    environments;
+    cookie;
+    http;
+    constructor(environments, cookie, http) {
+        this.environments = environments;
+        this.cookie = cookie;
+        this.http = http;
+    }
+    /**
+     * Retrieves the API security URL from the environment configuration.
+     *
+     * @return {string} The API security URL.
+     */
+    get url() {
+        return this.environments.apiCompositionUrl ?? '';
+    }
+    /**
+     * Retrieves shipment details based on the provided shipment ID.
+     *
+     * @param {number} id - The unique identifier of the shipment to retrieve.
+     * @return {Observable<ShipmentOut>} An observable that emits the details of the shipment.
+     */
+    getShipment(id) {
+        return this.http.get(`${this.url}/shipments/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the country references data based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters for the API request.
+     * @return {Observable<CompositionCountryReferencesOut>} - An observable emitting the country references.
+     */
+    getCountryReferences(params) {
+        return this.http.get(`${this.url}/country-references`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCompositionService, deps: [{ token: 'env' }, { token: i1.CookieService }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCompositionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCompositionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.CookieService }, { type: i2.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/apis/api-customs.service.mjs

@@ -0,0 +1,157 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiCustomsService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the cash operations API from the environment configurations.
+     *
+     * @return {string} The URL of the cash operations API.
+     */
+    get url() {
+        return this.environments.apiCustomsUrl ?? '';
+    }
+    /**
+     * Fetches the available fields for a given level.
+     *
+     * @return {Observable<FieldsOut>} An Observable that emits the list of fields.
+     * @param params
+     */
+    getFields(params) {
+        return this.http.get(`${this.url}/fields`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves override configurations for a given level.
+     *
+     * @return {Observable<OverridesOut>} An Observable that emits the overrides configuration.
+     * @param params
+     */
+    getOverrides(params) {
+        return this.http.get(`${this.url}/overrides`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the catalogs used in customs operations.
+     *
+     * @return {Observable<CatalogsOut>} An Observable that emits the catalogs.
+     */
+    getCatalogs(params) {
+        return this.http.get(`${this.url}/catalogs`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the list of rules based on the provided query parameters.
+     *
+     * @param {QueryParams} params - Query parameters to filter the rules.
+     * @return {Observable<RulesOut>} An Observable that emits the list of rules.
+     */
+    getRules(params) {
+        return this.http.get(`${this.url}/rules`, { params }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the details of a specific rule by its ID.
+     *
+     * @param {number} id - The ID of the rule.
+     * @return {Observable<RuleOut>} An Observable that emits the rule details.
+     */
+    getRule(id) {
+        return this.http.get(`${this.url}/rules/${id}`).pipe(map(({ data }) => data));
+    }
+    /**
+     * Creates a new criteria.
+     *
+     * @param {CriteriaIn} body - The criteria payload to create.
+     * @return {Observable<CriteriaOut>} An Observable that emits the created criteria.
+     */
+    postCriteria(body) {
+        return this.http.post(`${this.url}/criteria`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Creates a new rule.
+     *
+     * @param {RuleIn} body - The rule payload to create.
+     * @return {Observable<RuleOut>} An Observable that emits the created rule.
+     */
+    postRules(body) {
+        return this.http.post(`${this.url}/rules`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves rules that match the given criteria.
+     *
+     * @param {RuleCriteriaIn} params - Criteria used to search for matching rules.
+     * @return {Observable<RulesByCriteriaOut>} An Observable that emits the list of matching rules.
+     */
+    postRulesByCriteria(params) {
+        return this.http.post(`${this.url}/rules/by-criteria`, params).pipe(map(({ data }) => data));
+    }
+    /**
+     * Enables a specific rule by its ID.
+     *
+     * @param {number} id - The ID of the rule to enable.
+     * @return {Observable<{}>} An Observable that emits an empty array on success.
+     */
+    putRuleActivate(id) {
+        return this.http.put(`${this.url}/rules/${id}/activate`, null).pipe(map(({ data }) => data));
+    }
+    /**
+     * Disables (deletes) a specific rule by its ID.
+     *
+     * @param {number} id - The ID of the rule to disable.
+     * @return {Observable<[]>} An Observable that emits an empty array on success.
+     */
+    deleteRule(id) {
+        return this.http.delete(`${this.url}/rules/${id}`).pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing criteria by its ID.
+     *
+     * @param {number} id - The ID of the criteria.
+     * @param {CriteriaIn} body - The updated criteria payload.
+     * @return {Observable<CriteriaOut>} An Observable that emits the updated criteria.
+     */
+    putCriteria(id, body) {
+        return this.http.put(`${this.url}/criteria/${id}`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing rule by its ID.
+     *
+     * @param {number} id - The ID of the rule.
+     * @param {RulesIn} body - The updated rule payload.
+     * @return {Observable<RuleOut>} An Observable that emits the updated rule.
+     */
+    putRule(id, body) {
+        return this.http.put(`${this.url}/rules/${id}`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the list of country groups used in customs operations.
+     *
+     * @return {Observable<CountryGroupsOut>} An Observable that emits the list of country groups.
+     */
+    getCountryGroups(params) {
+        return this.http.get(`${this.url}/country-groups`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCustomsService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCustomsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCustomsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-customs.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-customs.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { HttpClient } from '@angular/common/http'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport { map, Observable } from 'rxjs'\r\nimport {\r\n  CatalogsOut, CountryGroupsOut,\r\n  CriteriaIn,\r\n  CriteriaOut,\r\n  FieldsOut,\r\n  OverridesOut, RuleCriteriaIn, RuleIn,\r\n  RuleOut, RulesByCriteriaOut, RulesIn,\r\n  RulesOut\r\n} from './models/api-customs.types'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiCustomsService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the URL for the cash operations API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the cash operations API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiCustomsUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Fetches the available fields for a given level.\r\n   *\r\n   * @return {Observable<FieldsOut>} An Observable that emits the list of fields.\r\n   * @param params\r\n   */\r\n  getFields (params: QueryParams): Observable<FieldsOut> {\r\n    return this.http.get<ApiSuccess<FieldsOut>>(\r\n      `${this.url}/fields`, {\r\n        params\r\n      }\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Retrieves override configurations for a given level.\r\n   *\r\n   * @return {Observable<OverridesOut>} An Observable that emits the overrides configuration.\r\n   * @param params\r\n   */\r\n  getOverrides (params: QueryParams): Observable<OverridesOut> {\r\n    return this.http.get<ApiSuccess<OverridesOut>>(\r\n      `${this.url}/overrides`, {\r\n        params\r\n      }\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Fetches the catalogs used in customs operations.\r\n   *\r\n   * @return {Observable<CatalogsOut>} An Observable that emits the catalogs.\r\n   */\r\n  getCatalogs (params: QueryParams): Observable<CatalogsOut> {\r\n    return this.http.get<ApiSuccess<CatalogsOut>>(\r\n      `${this.url}/catalogs`, {\r\n        params\r\n      }\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of rules based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter the rules.\r\n   * @return {Observable<RulesOut>} An Observable that emits the list of rules.\r\n   */\r\n  getRules (params: QueryParams): Observable<RulesOut> {\r\n    return this.http.get<ApiSuccess<RulesOut>>(\r\n      `${this.url}/rules`,\r\n      { params }\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Retrieves the details of a specific rule by its ID.\r\n   *\r\n   * @param {number} id - The ID of the rule.\r\n   * @return {Observable<RuleOut>} An Observable that emits the rule details.\r\n   */\r\n  getRule (id: number): Observable<RuleOut> {\r\n    return this.http.get<ApiSuccess<RuleOut>>(\r\n      `${this.url}/rules/${id}`\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Creates a new criteria.\r\n   *\r\n   * @param {CriteriaIn} body - The criteria payload to create.\r\n   * @return {Observable<CriteriaOut>} An Observable that emits the created criteria.\r\n   */\r\n  postCriteria (body: CriteriaIn): Observable<CriteriaOut> {\r\n    return this.http.post<ApiSuccess<CriteriaOut>>(`${this.url}/criteria`,\r\n      body\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Creates a new rule.\r\n   *\r\n   * @param {RuleIn} body - The rule payload to create.\r\n   * @return {Observable<RuleOut>} An Observable that emits the created rule.\r\n   */\r\n  postRules (body: RuleIn): Observable<RuleOut> {\r\n    return this.http.post<ApiSuccess<RuleOut>>(`${this.url}/rules`,\r\n      body\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Retrieves rules that match the given criteria.\r\n   *\r\n   * @param {RuleCriteriaIn} params - Criteria used to search for matching rules.\r\n   * @return {Observable<RulesByCriteriaOut>} An Observable that emits the list of matching rules.\r\n   */\r\n  postRulesByCriteria (params: RuleCriteriaIn): Observable<RulesByCriteriaOut> {\r\n    return this.http.post<ApiSuccess<RulesByCriteriaOut>>(\r\n      `${this.url}/rules/by-criteria`,\r\n      params\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Enables a specific rule by its ID.\r\n   *\r\n   * @param {number} id - The ID of the rule to enable.\r\n   * @return {Observable<{}>} An Observable that emits an empty array on success.\r\n   */\r\n  putRuleActivate (id:number): Observable<{}> {\r\n    return this.http.put<ApiSuccess<{}>>(\r\n      `${this.url}/rules/${id}/activate`, null\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Disables (deletes) a specific rule by its ID.\r\n   *\r\n   * @param {number} id - The ID of the rule to disable.\r\n   * @return {Observable<[]>} An Observable that emits an empty array on success.\r\n   */\r\n  deleteRule (id:number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(\r\n      `${this.url}/rules/${id}`\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Updates an existing criteria by its ID.\r\n   *\r\n   * @param {number} id - The ID of the criteria.\r\n   * @param {CriteriaIn} body - The updated criteria payload.\r\n   * @return {Observable<CriteriaOut>} An Observable that emits the updated criteria.\r\n   */\r\n  putCriteria (id:number, body: CriteriaIn): Observable<CriteriaOut> {\r\n    return this.http.put<ApiSuccess<CriteriaOut>>(\r\n      `${this.url}/criteria/${id}`,\r\n      body\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Updates an existing rule by its ID.\r\n   *\r\n   * @param {number} id - The ID of the rule.\r\n   * @param {RulesIn} body - The updated rule payload.\r\n   * @return {Observable<RuleOut>} An Observable that emits the updated rule.\r\n   */\r\n  putRule (id:number, body: RulesIn): Observable<RuleOut> {\r\n    return this.http.put<ApiSuccess<RuleOut>>(\r\n      `${this.url}/rules/${id}`,\r\n      body\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of country groups used in customs operations.\r\n   *\r\n   * @return {Observable<CountryGroupsOut>} An Observable that emits the list of country groups.\r\n   */\r\n  getCountryGroups (params: QueryParams): Observable<CountryGroupsOut> {\r\n    return this.http.get<ApiSuccess<CountryGroupsOut>>(\r\n      `${this.url}/country-groups`,\r\n      {\r\n        params\r\n      }\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n}\r\n"]}

package/esm2022/lib/apis/api-discounts.service.mjs

@@ -0,0 +1,243 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiDiscountsService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Gets the API endpoint URL for discounts from the environments configuration.
+     *
+     * @return {string} The URL for the discounts API. Returns an empty string if not defined.
+     */
+    get url() {
+        return this.environments.apiDiscountsUrl ?? '';
+    }
+    /**
+     * Fetches available discounts based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter and retrieve discounts.
+     * @return {Observable<DiscountsOut>} An Observable that emits the retrieved discounts data.
+     */
+    getDiscounts(params) {
+        return this.http.get(`${this.url}/discounts`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a request to create or update discounts on the server.
+     *
+     * @param {DiscountIn} body - The discount information to be submitted.
+     * @return {Observable<DiscountOut>} An Observable emitting the server's response containing the created or updated discount details.
+     */
+    postDiscounts(body) {
+        return this.http.post(`${this.url}/discounts`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates the discount information for a specific item.
+     *
+     * @param {number} id - The unique identifier of the item whose discount is to be updated.
+     * @param {DiscountIn} body - The payload containing the updated discount details.
+     * @return {Observable<DiscountOut>} An observable emitting the updated discount details.
+     */
+    putDiscounts(id, body) {
+        return this.http.put(`${this.url}/discounts/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the top customers based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter and sort the top customers.
+     * @return {Observable<TopCustomersOut>} An observable emitting the list of top customers.
+     */
+    getTopCustomers(params) {
+        return this.http.get(`${this.url}/top-customers`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to load the top customer data in the system, using the provided input.
+     * Transforms the API response to extract the data field containing the discount information.
+     *
+     * @param {OperationsLoadTopCustomerV2In} body - The input payload containing the company country ID and the file.
+     * @param {number} body.company_country_id - The ID of the company's country.
+     * @param {File} body.file - The file containing data to be processed.
+     * @return {Observable<DiscountOut>} An observable containing the discount output information.
+     */
+    postOperationsLoadTopCustomerV2(body) {
+        const formData = new FormData();
+        formData.append('company_country_id', String(body.company_country_id));
+        formData.append('file', body.file);
+        return this.http.post(`${this.url}/operations/load-top-customer/V2`, formData)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the loyalty periods based on the provided query parameters.
+     *
+     * @param {QueryParams} params - An object containing query parameters to filter the periods.
+     * @return {Observable<LoyaltyPeriodsOut>} An observable that emits the fetched loyalty periods.
+     */
+    getLoyaltyPeriods(params) {
+        return this.http.get(`${this.url}/loyalty-periods`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the loyalty period details for the given ID.
+     *
+     * @param {number} id - The unique identifier of the loyalty period to retrieve.
+     * @return {Observable<LoyaltyPeriodOut>} An observable emitting the loyalty period details.
+     */
+    getLoyaltyPeriod(id) {
+        return this.http.get(`${this.url}/loyalty-periods/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a PUT request to update the loyalty period with the provided data.
+     *
+     * @param {LoyaltyPeriodIn} body - The data for the loyalty period to be updated.
+     * @return {Observable<LoyaltyPeriodOut>} An observable that emits the updated loyalty period data.
+     */
+    postLoyaltyPeriod(body) {
+        return this.http.put(`${this.url}/loyalty-periods`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates the loyalty period for a specified ID with the provided data.
+     *
+     * @param {number} id - The unique identifier of the loyalty period to update.
+     * @param {LoyaltyPeriodIn} body - An object containing the updated details of the loyalty period.
+     * @return {Observable<LoyaltyPeriodOut>} An observable that emits the updated loyalty period details.
+     */
+    putLoyaltyPeriod(id, body) {
+        return this.http.put(`${this.url}/loyalty-periods/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the loyalty rules based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter the loyalty rules.
+     * @return {Observable<LoyaltyRulesOut>} An observable containing the loyalty rules output.
+     */
+    getLoyaltyRules(params) {
+        return this.http.get(`${this.url}/loyalty-rules`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a specific loyalty rule based on the provided ID.
+     *
+     * @param {number} id - The unique identifier of the loyalty rule to retrieve.
+     * @return {Observable<LoyaltyRuleOut>} An observable that emits the details of the specified loyalty rule.
+     */
+    getLoyaltyRule(id) {
+        return this.http.get(`${this.url}/loyalty-rules/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a request to add or update a loyalty rule.
+     *
+     * @param {LoyaltyRuleIn} body - The loyalty rule data to be sent to the server.
+     * @return {Observable<LoyaltyRuleOut>} An observable that emits the updated loyalty rule details.
+     */
+    postLoyaltyRule(body) {
+        return this.http.put(`${this.url}/loyalty-rules`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing loyalty rule with the provided data.
+     *
+     * @param {number} id - The unique identifier of the loyalty rule to update.
+     * @param {LoyaltyRuleIn} body - The data to update the loyalty rule with.
+     * @return {Observable<LoyaltyRuleOut>} An observable that emits the updated loyalty rule.
+     */
+    putLoyaltyRule(id, body) {
+        return this.http.put(`${this.url}/loyalty-rules/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches customer restrictions based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter customer restrictions.
+     * @return {Observable<CustomerRestrictionsOut>} An observable that emits the customer restrictions data.
+     */
+    getCustomerRestrictions(params) {
+        return this.http.get(`${this.url}/customer-restrictions`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves customer restriction details for a given customer ID.
+     *
+     * @param {number} id - The unique identifier of the customer.
+     * @return {Observable<CustomerRestrictionOut>} An observable containing the customer restriction details.
+     */
+    getCustomerRestriction(id) {
+        return this.http.get(`${this.url}/customer-restrictions/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a request to apply a restriction to a customer.
+     *
+     * @param {CustomerRestrictionIn} body - The restriction details to be applied to the customer.
+     * @return {Observable<CustomerRestrictionOut>} An observable containing the response with the applied customer restriction.
+     */
+    postCustomerRestriction(body) {
+        return this.http.put(`${this.url}/customer-restrictions`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates customer restrictions using the provided ID and data.
+     *
+     * @param {number} id - The unique identifier of the customer restriction to be updated.
+     * @param {LoyaltyRuleIn} body - The data object containing the customer restriction details to be updated.
+     * @return {Observable<CustomerRestrictionOut>} An observable emitting the updated customer restriction details.
+     */
+    putCustomerRestriction(id, body) {
+        return this.http.put(`${this.url}/customer-restrictions/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Deletes a customer restriction by its ID.
+     *
+     * @param {number} id - The unique identifier of the customer restriction to delete.
+     * @return {Observable<{}>} An Observable that emits the result of the deletion operation.
+     */
+    deleteCustomerRestriction(id) {
+        return this.http.delete(`${this.url}/customer-restrictions/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a request to apply a restriction to a customer (Version 2).
+     *
+     * @param {CustomerRestrictionInV2} body - The restriction details to be applied to the customer.
+     * @return {Observable<CustomerRestrictionOut>} An observable containing the response with the applied customer restriction.
+     */
+    postCustomerRestrictionV2(body) {
+        return this.http.post(`${this.url}/customer-restrictions/V2`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates customer restrictions using the provided ID and data (Version 2).
+     *
+     * @param {number} id - The unique identifier of the customer restriction to be updated.
+     * @param {CustomerRestrictionInV2} body - The data object containing the customer restriction details to be updated.
+     * @return {Observable<CustomerRestrictionOut>} An observable emitting the updated customer restriction details.
+     */
+    putCustomerRestrictionV2(id, body) {
+        return this.http.put(`${this.url}/customer-restrictions/V2/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiDiscountsService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiDiscountsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiDiscountsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-discounts.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-discounts.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http'\r\nimport { Inject, Injectable } from '@angular/core'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { map, Observable } from 'rxjs'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport {\r\n  CustomerRestrictionIn,\r\n  CustomerRestrictionInV2,\r\n  CustomerRestrictionOut,\r\n  CustomerRestrictionsOut,\r\n  DiscountIn,\r\n  DiscountOut,\r\n  DiscountsOut,\r\n  LoyaltyPeriodIn,\r\n  LoyaltyPeriodOut,\r\n  LoyaltyPeriodsOut,\r\n  LoyaltyRuleIn,\r\n  LoyaltyRuleOut,\r\n  LoyaltyRulesOut,\r\n  OperationsLoadTopCustomerV2In,\r\n  TopCustomersOut\r\n} from './models/api-discounts.types'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiDiscountsService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient\r\n  ) { }\r\n\r\n  /**\r\n   * Gets the API endpoint URL for discounts from the environments configuration.\r\n   *\r\n   * @return {string} The URL for the discounts API. Returns an empty string if not defined.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiDiscountsUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Fetches available discounts based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter and retrieve discounts.\r\n   * @return {Observable<DiscountsOut>} An Observable that emits the retrieved discounts data.\r\n   */\r\n  getDiscounts (params: QueryParams): Observable<DiscountsOut> {\r\n    return this.http.get<ApiSuccess<DiscountsOut>>(`${this.url}/discounts`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a request to create or update discounts on the server.\r\n   *\r\n   * @param {DiscountIn} body - The discount information to be submitted.\r\n   * @return {Observable<DiscountOut>} An Observable emitting the server's response containing the created or updated discount details.\r\n   */\r\n  postDiscounts (body: DiscountIn): Observable<DiscountOut> {\r\n    return this.http.post<ApiSuccess<DiscountOut>>(`${this.url}/discounts`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the discount information for a specific item.\r\n   *\r\n   * @param {number} id - The unique identifier of the item whose discount is to be updated.\r\n   * @param {DiscountIn} body - The payload containing the updated discount details.\r\n   * @return {Observable<DiscountOut>} An observable emitting the updated discount details.\r\n   */\r\n  putDiscounts (id: number, body: DiscountIn): Observable<DiscountOut> {\r\n    return this.http.put<ApiSuccess<DiscountOut>>(`${this.url}/discounts/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the top customers based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter and sort the top customers.\r\n   * @return {Observable<TopCustomersOut>} An observable emitting the list of top customers.\r\n   */\r\n  getTopCustomers (params: QueryParams): Observable<TopCustomersOut> {\r\n    return this.http.get<ApiSuccess<TopCustomersOut>>(`${this.url}/top-customers`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to load the top customer data in the system, using the provided input.\r\n   * Transforms the API response to extract the data field containing the discount information.\r\n   *\r\n   * @param {OperationsLoadTopCustomerV2In} body - The input payload containing the company country ID and the file.\r\n   * @param {number} body.company_country_id - The ID of the company's country.\r\n   * @param {File} body.file - The file containing data to be processed.\r\n   * @return {Observable<DiscountOut>} An observable containing the discount output information.\r\n   */\r\n  postOperationsLoadTopCustomerV2 (body: OperationsLoadTopCustomerV2In): Observable<{}> {\r\n    const formData = new FormData()\r\n    formData.append('company_country_id', String(body.company_country_id))\r\n    formData.append('file', body.file)\r\n\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operations/load-top-customer/V2`, formData)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the loyalty periods based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - An object containing query parameters to filter the periods.\r\n   * @return {Observable<LoyaltyPeriodsOut>} An observable that emits the fetched loyalty periods.\r\n   */\r\n  getLoyaltyPeriods (params: QueryParams): Observable<LoyaltyPeriodsOut> {\r\n    return this.http.get<ApiSuccess<LoyaltyPeriodsOut>>(`${this.url}/loyalty-periods`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the loyalty period details for the given ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the loyalty period to retrieve.\r\n   * @return {Observable<LoyaltyPeriodOut>} An observable emitting the loyalty period details.\r\n   */\r\n  getLoyaltyPeriod (id: number): Observable<LoyaltyPeriodOut> {\r\n    return this.http.get<ApiSuccess<LoyaltyPeriodOut>>(`${this.url}/loyalty-periods/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a PUT request to update the loyalty period with the provided data.\r\n   *\r\n   * @param {LoyaltyPeriodIn} body - The data for the loyalty period to be updated.\r\n   * @return {Observable<LoyaltyPeriodOut>} An observable that emits the updated loyalty period data.\r\n   */\r\n  postLoyaltyPeriod (body: LoyaltyPeriodIn): Observable<LoyaltyPeriodOut> {\r\n    return this.http.put<ApiSuccess<LoyaltyPeriodOut>>(`${this.url}/loyalty-periods`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the loyalty period for a specified ID with the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the loyalty period to update.\r\n   * @param {LoyaltyPeriodIn} body - An object containing the updated details of the loyalty period.\r\n   * @return {Observable<LoyaltyPeriodOut>} An observable that emits the updated loyalty period details.\r\n   */\r\n  putLoyaltyPeriod (id: number, body: LoyaltyPeriodIn): Observable<LoyaltyPeriodOut> {\r\n    return this.http.put<ApiSuccess<LoyaltyPeriodOut>>(`${this.url}/loyalty-periods/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the loyalty rules based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the loyalty rules.\r\n   * @return {Observable<LoyaltyRulesOut>} An observable containing the loyalty rules output.\r\n   */\r\n  getLoyaltyRules (params: QueryParams): Observable<LoyaltyRulesOut> {\r\n    return this.http.get<ApiSuccess<LoyaltyRulesOut>>(`${this.url}/loyalty-rules`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a specific loyalty rule based on the provided ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the loyalty rule to retrieve.\r\n   * @return {Observable<LoyaltyRuleOut>} An observable that emits the details of the specified loyalty rule.\r\n   */\r\n  getLoyaltyRule (id: number): Observable<LoyaltyRuleOut> {\r\n    return this.http.get<ApiSuccess<LoyaltyRuleOut>>(`${this.url}/loyalty-rules/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a request to add or update a loyalty rule.\r\n   *\r\n   * @param {LoyaltyRuleIn} body - The loyalty rule data to be sent to the server.\r\n   * @return {Observable<LoyaltyRuleOut>} An observable that emits the updated loyalty rule details.\r\n   */\r\n  postLoyaltyRule (body: LoyaltyRuleIn): Observable<LoyaltyRuleOut> {\r\n    return this.http.put<ApiSuccess<LoyaltyRuleOut>>(`${this.url}/loyalty-rules`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing loyalty rule with the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the loyalty rule to update.\r\n   * @param {LoyaltyRuleIn} body - The data to update the loyalty rule with.\r\n   * @return {Observable<LoyaltyRuleOut>} An observable that emits the updated loyalty rule.\r\n   */\r\n  putLoyaltyRule (id: number, body: LoyaltyRuleIn): Observable<LoyaltyRuleOut> {\r\n    return this.http.put<ApiSuccess<LoyaltyRuleOut>>(`${this.url}/loyalty-rules/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches customer restrictions based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter customer restrictions.\r\n   * @return {Observable<CustomerRestrictionsOut>} An observable that emits the customer restrictions data.\r\n   */\r\n  getCustomerRestrictions (params: QueryParams): Observable<CustomerRestrictionsOut> {\r\n    return this.http.get<ApiSuccess<CustomerRestrictionsOut>>(`${this.url}/customer-restrictions`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves customer restriction details for a given customer ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the customer.\r\n   * @return {Observable<CustomerRestrictionOut>} An observable containing the customer restriction details.\r\n   */\r\n  getCustomerRestriction (id: number): Observable<CustomerRestrictionOut> {\r\n    return this.http.get<ApiSuccess<CustomerRestrictionOut>>(`${this.url}/customer-restrictions/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a request to apply a restriction to a customer.\r\n   *\r\n   * @param {CustomerRestrictionIn} body - The restriction details to be applied to the customer.\r\n   * @return {Observable<CustomerRestrictionOut>} An observable containing the response with the applied customer restriction.\r\n   */\r\n  postCustomerRestriction (body: CustomerRestrictionIn): Observable<CustomerRestrictionOut> {\r\n    return this.http.put<ApiSuccess<CustomerRestrictionOut>>(`${this.url}/customer-restrictions`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates customer restrictions using the provided ID and data.\r\n   *\r\n   * @param {number} id - The unique identifier of the customer restriction to be updated.\r\n   * @param {LoyaltyRuleIn} body - The data object containing the customer restriction details to be updated.\r\n   * @return {Observable<CustomerRestrictionOut>} An observable emitting the updated customer restriction details.\r\n   */\r\n  putCustomerRestriction (id: number, body: CustomerRestrictionIn): Observable<CustomerRestrictionOut> {\r\n    return this.http.put<ApiSuccess<CustomerRestrictionOut>>(`${this.url}/customer-restrictions/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes a customer restriction by its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the customer restriction to delete.\r\n   * @return {Observable<{}>} An Observable that emits the result of the deletion operation.\r\n   */\r\n  deleteCustomerRestriction (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/customer-restrictions/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a request to apply a restriction to a customer (Version 2).\r\n   *\r\n   * @param {CustomerRestrictionInV2} body - The restriction details to be applied to the customer.\r\n   * @return {Observable<CustomerRestrictionOut>} An observable containing the response with the applied customer restriction.\r\n   */\r\n  postCustomerRestrictionV2 (body: CustomerRestrictionInV2): Observable<CustomerRestrictionOut> {\r\n    return this.http.post<ApiSuccess<CustomerRestrictionOut>>(`${this.url}/customer-restrictions/V2`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates customer restrictions using the provided ID and data (Version 2).\r\n   *\r\n   * @param {number} id - The unique identifier of the customer restriction to be updated.\r\n   * @param {CustomerRestrictionInV2} body - The data object containing the customer restriction details to be updated.\r\n   * @return {Observable<CustomerRestrictionOut>} An observable emitting the updated customer restriction details.\r\n   */\r\n  putCustomerRestrictionV2 (id: number, body: CustomerRestrictionInV2): Observable<CustomerRestrictionOut> {\r\n    return this.http.put<ApiSuccess<CustomerRestrictionOut>>(`${this.url}/customer-restrictions/V2/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

package/esm2022/lib/apis/api-e-tools-auto-billing.service.mjs

@@ -0,0 +1,75 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiEToolsAutoBillingService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the shipments API from the environment configurations.
+     *
+     * @return {string} The URL of the shipments API.
+     */
+    get url() {
+        return this.environments.apiEToolsAutoBilling ?? '';
+    }
+    /**
+     * Updates external shipment address details for the given address ID.
+     *
+     * @param {Object} params - The parameters for the API request.
+     * @param {string} params.id - The unique identifier of the address to update.
+     * @param {Object} params.body - The payload containing updated address details.
+     * @return {Observable<ExternalShipmentAddressesOut>} An observable containing the updated external shipment address information.
+     */
+    patchExternalShipmentAddresses({ id, ...body }) {
+        return this.http.patch(`${this.url}/external-shipment-addresses/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the external shipment file by its identifier.
+     *
+     * @param {number} fileId - The unique identifier of the external shipment file to be retrieved.
+     * @return {Observable<ExternalShipmentFileOut>} An observable containing the external shipment file data.
+     */
+    getExternalShipmentFile(fileId) {
+        return this.http.get(`${this.url}/external-shipment-files/${fileId}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the history entries for a specific external shipment.
+     *
+     * @param {number} id - The ID of the external shipment to retrieve history for.
+     * @return {Observable<ExternalShipmentHistoriesOut>} An observable containing the external shipment history entries.
+     */
+    getExternalShipmentHistories(id) {
+        return this.http.get(`${this.url}/external-shipments/${id}/external-shipment-histories`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the list of external shipment statuses
+     *
+     * @param {QueryParams} params - The query parameters used to fetch the external shipment statuses.
+     * @return {Observable<ExternalShipmentStatusOut>} An observable that emits the external shipment statuses data.
+     */
+    getExternalShipmentStatuses(params) {
+        return this.http.get(`${this.url}/external-shipment-statuses`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiEToolsAutoBillingService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiEToolsAutoBillingService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiEToolsAutoBillingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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