@experteam-mx/ngx-services 18.7.10 → 18.7.12

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

@@ -10,9 +10,9 @@ export class ApiDiscountsService {
         this.http = http;
     }
     /**
-     * Retrieves the URL for the shipments API from the environment configurations.
+     * Gets the API endpoint URL for discounts from the environments configuration.
      *
-     * @return {string} The URL of the shipments API.
+     * @return {string} The URL for the discounts API. Returns an empty string if not defined.
      */
     get url() {
         return this.environments.apiDiscounts ?? '';
@@ -219,4 +219,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     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  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   * Retrieves the URL for the shipments API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the shipments API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiDiscounts ?? ''\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"]}
+//# 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  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.apiDiscounts ?? ''\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"]}

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

@@ -0,0 +1,104 @@
+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 ApiNotificationsService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the notifications API from the environment settings.
+     * If the URL is not defined, an empty string is returned.
+     *
+     * @return {string} The API Notifications URL or an empty string if not defined.
+     */
+    get url() {
+        return this.environments.apiNotificationsUrl ?? '';
+    }
+    /**
+     * Retrieves notifications based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter and retrieve notifications.
+     * @return {Observable<NotificationsOut>} An observable that emits the fetched notifications.
+     */
+    getNotifications(params) {
+        return this.http.get(`${this.url}/notifications`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a notification request to the server using the provided body.
+     *
+     * @param {NotificationIn} body - The notification data to be sent in the request body.
+     * @return {Observable<NotificationOut>} An observable emitting the response containing the notification output data.
+     */
+    postNotification(body) {
+        return this.http.post(`${this.url}/notifications`, { body })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a PUT request to update a notification with the provided ID and body.
+     *
+     * @param {number} id - The unique identifier of the notification to be updated.
+     * @param {NotificationIn} body - The data to update the notification with.
+     * @return {Observable<NotificationOut>} An observable containing the updated notification data.
+     */
+    putNotification(id, body) {
+        return this.http.put(`${this.url}/notifications/${id}`, { body })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Deletes a notification by its unique identifier.
+     *
+     * @param {number} id - The unique identifier of the notification to delete.
+     * @return {Observable<{}>} An observable that emits the response after deleting the notification.
+     */
+    deleteNotification(id) {
+        return this.http.delete(`${this.url}/notifications/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Marks the notification as finished for the specified notification ID.
+     *
+     * @param {number} id - The unique identifier of the notification to be marked as finished.
+     * @return {Observable<NotificationOut>} An Observable emitting the updated notification object.
+     */
+    putNotificationFinish(id) {
+        return this.http.put(`${this.url}/notifications/finish/${id}`, {})
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create or update notification configurations.
+     *
+     * @param {NotificationConfigurationIn} body - The notification configuration payload to be sent in the request.
+     * @return {Observable<NotificationConfigurationOut>} An observable emitting the response containing the created or updated notification configuration.
+     */
+    postNotificationConfigurations(body) {
+        return this.http.post(`${this.url}/notification-configurations`, { body })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the notification types based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters for fetching the notification types.
+     * @return {Observable<NotificationsTypeOut>} An observable that emits the fetched notification types.
+     */
+    getNotificationsType(params) {
+        return this.http.get(`${this.url}/notifications-type`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiNotificationsService, 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: ApiNotificationsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiNotificationsService, 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-notifications.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-notifications.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 { ApiSuccess, QueryParams } from './models/api.models'\r\nimport {\r\n  NotificationConfigurationIn,\r\n  NotificationConfigurationOut,\r\n  NotificationIn,\r\n  NotificationOut,\r\n  NotificationsOut,\r\n  NotificationsTypeOut\r\n} from './models/api-notifications.types'\r\nimport { map, Observable } from 'rxjs'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiNotificationsService {\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 notifications API from the environment settings.\r\n   * If the URL is not defined, an empty string is returned.\r\n   *\r\n   * @return {string} The API Notifications URL or an empty string if not defined.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiNotificationsUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Retrieves notifications based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter and retrieve notifications.\r\n   * @return {Observable<NotificationsOut>} An observable that emits the fetched notifications.\r\n   */\r\n  getNotifications (params: QueryParams): Observable<NotificationsOut> {\r\n    return this.http.get<ApiSuccess<NotificationsOut>>(`${this.url}/notifications`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a notification request to the server using the provided body.\r\n   *\r\n   * @param {NotificationIn} body - The notification data to be sent in the request body.\r\n   * @return {Observable<NotificationOut>} An observable emitting the response containing the notification output data.\r\n   */\r\n  postNotification (body: NotificationIn): Observable<NotificationOut> {\r\n    return this.http.post<ApiSuccess<NotificationOut>>(`${this.url}/notifications`, { body })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a PUT request to update a notification with the provided ID and body.\r\n   *\r\n   * @param {number} id - The unique identifier of the notification to be updated.\r\n   * @param {NotificationIn} body - The data to update the notification with.\r\n   * @return {Observable<NotificationOut>} An observable containing the updated notification data.\r\n   */\r\n  putNotification (id: number, body: NotificationIn): Observable<NotificationOut> {\r\n    return this.http.put<ApiSuccess<NotificationOut>>(`${this.url}/notifications/${id}`, { body })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes a notification by its unique identifier.\r\n   *\r\n   * @param {number} id - The unique identifier of the notification to delete.\r\n   * @return {Observable<{}>} An observable that emits the response after deleting the notification.\r\n   */\r\n  deleteNotification (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/notifications/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Marks the notification as finished for the specified notification ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the notification to be marked as finished.\r\n   * @return {Observable<NotificationOut>} An Observable emitting the updated notification object.\r\n   */\r\n  putNotificationFinish (id: number): Observable<NotificationOut> {\r\n    return this.http.put<ApiSuccess<NotificationOut>>(`${this.url}/notifications/finish/${id}`, {})\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update notification configurations.\r\n   *\r\n   * @param {NotificationConfigurationIn} body - The notification configuration payload to be sent in the request.\r\n   * @return {Observable<NotificationConfigurationOut>} An observable emitting the response containing the created or updated notification configuration.\r\n   */\r\n  postNotificationConfigurations (body: NotificationConfigurationIn): Observable<NotificationConfigurationOut> {\r\n    return this.http.post<ApiSuccess<NotificationConfigurationOut>>(`${this.url}/notification-configurations`, { body })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the notification types based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for fetching the notification types.\r\n   * @return {Observable<NotificationsTypeOut>} An observable that emits the fetched notification types.\r\n   */\r\n  getNotificationsType (params: QueryParams): Observable<NotificationsTypeOut> {\r\n    return this.http.get<ApiSuccess<NotificationsTypeOut>>(`${this.url}/notifications-type`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,93 @@
+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 ApiServicesService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the services API from the environment settings.
+     * If the URL is not defined, an empty string is returned.
+     *
+     * @return {string} The API Services URL or an empty string if not defined.
+     */
+    get url() {
+        return this.environments.apiServicesUrl ?? '';
+    }
+    /**
+     * Retrieves service areas based on the provided query parameters.
+     *
+     * @param {ServiceAreaIn} body - The query parameters used to filter and retrieve service areas.
+     * @return {Observable<NotificationsOut>} An observable that emits the fetched service areas.
+     */
+    postServiceAreas(body) {
+        return this.http.post(`${this.url}/service-areas`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Validate facility values based on the provided parameter.
+     *
+     * @param {ValidateFacilityIn} body - The facility data to be sent in the request body
+     * @return {Observable<ValidateFacilityOut>} An observable emitting the response containing the facility validated output data.
+     */
+    postValidateFacility(body) {
+        return this.http.post(`${this.url}/facilities`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Create an email resource.
+     *
+     * @param {EmailErrorIn} body - The email data to be sent in the request body
+     * @return {Observable<{}>} An observable emitting the response data.
+     */
+    postEmailError(body) {
+        return this.http.post(`${this.url}/emails/error`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a promotion request to the server using the provided body.
+     *
+     * @param {PromotionIn} body - The promotion data to be sent in the request body.
+     * @return {Observable<PromotionOut>} An observable emitting the response containing the promotion output data.
+     */
+    postPromotion(body) {
+        return this.http.post(`${this.url}/promotions`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Validate NIP account value based on the provided parameter.
+     *
+     * @param {ValidateNIPIn} body - The NIP account data to be sent in the request body
+     * @return {Observable<ValidateNIPOut>} An observable emitting the response containing the NIP account validated data.
+     */
+    postValidateNIP(body) {
+        return this.http.post(`${this.url}/accounts/nip`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Validate BR Identification value based on the provided parameter.
+     *
+     * @param {ValidateIdentificationBRIn} body - The BR Identification data to be sent in the request body
+     * @return {Observable<ValidateIdentificationBROut>} An observable emitting the response containing the BR Identification validated data.
+     */
+    postValidateIdentificationBR(body) {
+        return this.http.post(`${this.url}/identifications/br-validation`, body)
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiServicesService, 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: ApiServicesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiServicesService, 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-services.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-services.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAIlD,OAAO,EAAE,GAAG,EAAc,MAAM,MAAM,CAAA;;;AAkBtC,MAAM,OAAO,kBAAkB;IAEJ;IACf;IAFV,YACyB,YAAyB,EACxC,IAAgB;QADD,iBAAY,GAAZ,YAAY,CAAa;QACxC,SAAI,GAAJ,IAAI,CAAY;IACvB,CAAC;IAEJ;;;;;OAKG;IACH,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,IAAI,EAAE,CAAA;IAC/C,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAE,IAAmB;QACnC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA8B,GAAG,IAAI,CAAC,GAAG,gBAAgB,EAAE,IAAI,CAAC;aAClF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,oBAAoB,CAAE,IAAwB;QAC5C,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAkC,GAAG,IAAI,CAAC,GAAG,aAAa,EAAE,IAAI,CAAC;aACnF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAE,IAAkB;QAChC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAiB,GAAG,IAAI,CAAC,GAAG,eAAe,EAAE,IAAI,CAAC;aACpE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,aAAa,CAAE,IAAiB;QAC9B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA2B,GAAG,IAAI,CAAC,GAAG,aAAa,EAAE,IAAI,CAAC;aAC5E,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,eAAe,CAAE,IAAmB;QAClC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA6B,GAAG,IAAI,CAAC,GAAG,eAAe,EAAE,IAAI,CAAC;aAChF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,4BAA4B,CAAE,IAAgC;QAC5D,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA0C,GAAG,IAAI,CAAC,GAAG,gCAAgC,EAAE,IAAI,CAAC;aAC9G,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;wGAhFU,kBAAkB,kBAEnB,KAAK;4GAFJ,kBAAkB,cAHjB,MAAM;;4FAGP,kBAAkB;kBAJ9B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAII,MAAM;2BAAC,KAAK","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { HttpClient } from '@angular/common/http'\r\nimport { ApiSuccess } from './models/api.models'\r\nimport { map, Observable } from 'rxjs'\r\nimport {\r\n  ValidateFacilityIn,\r\n  ValidateFacilityOut,\r\n  ServiceAreasOut,\r\n  EmailErrorIn,\r\n  PromotionIn,\r\n  PromotionOut,\r\n  ValidateNIPOut,\r\n  ValidateNIPIn,\r\n  ValidateIdentificationBROut,\r\n  ValidateIdentificationBRIn, ServiceAreaIn\r\n} from './models/api-services.types'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\n\r\nexport class ApiServicesService {\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 services API from the environment settings.\r\n   * If the URL is not defined, an empty string is returned.\r\n   *\r\n   * @return {string} The API Services URL or an empty string if not defined.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiServicesUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Retrieves service areas based on the provided query parameters.\r\n   *\r\n   * @param {ServiceAreaIn} body - The query parameters used to filter and retrieve service areas.\r\n   * @return {Observable<NotificationsOut>} An observable that emits the fetched service areas.\r\n   */\r\n  postServiceAreas (body: ServiceAreaIn): Observable<ServiceAreasOut> {\r\n    return this.http.post<ApiSuccess<ServiceAreasOut>>(`${this.url}/service-areas`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Validate facility values based on the provided parameter.\r\n   *\r\n   * @param {ValidateFacilityIn} body - The facility data to be sent in the request body\r\n   * @return {Observable<ValidateFacilityOut>} An observable emitting the response containing the facility validated output data.\r\n   */\r\n  postValidateFacility (body: ValidateFacilityIn): Observable<ValidateFacilityOut> {\r\n    return this.http.post<ApiSuccess<ValidateFacilityOut>>(`${this.url}/facilities`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create an email resource.\r\n   *\r\n   * @param {EmailErrorIn} body - The email data to be sent in the request body\r\n   * @return {Observable<{}>} An observable emitting the response data.\r\n   */\r\n  postEmailError (body: EmailErrorIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/emails/error`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a promotion request to the server using the provided body.\r\n   *\r\n   * @param {PromotionIn} body - The promotion data to be sent in the request body.\r\n   * @return {Observable<PromotionOut>} An observable emitting the response containing the promotion output data.\r\n   */\r\n  postPromotion (body: PromotionIn): Observable<PromotionOut> {\r\n    return this.http.post<ApiSuccess<PromotionOut>>(`${this.url}/promotions`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Validate NIP account value based on the provided parameter.\r\n   *\r\n   * @param {ValidateNIPIn} body - The NIP account data to be sent in the request body\r\n   * @return {Observable<ValidateNIPOut>} An observable emitting the response containing the NIP account validated data.\r\n   */\r\n  postValidateNIP (body: ValidateNIPIn): Observable<ValidateNIPOut> {\r\n    return this.http.post<ApiSuccess<ValidateNIPOut>>(`${this.url}/accounts/nip`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Validate BR Identification value based on the provided parameter.\r\n   *\r\n   * @param {ValidateIdentificationBRIn} body - The BR Identification data to be sent in the request body\r\n   * @return {Observable<ValidateIdentificationBROut>} An observable emitting the response containing the BR Identification validated data.\r\n   */\r\n  postValidateIdentificationBR (body: ValidateIdentificationBRIn): Observable<ValidateIdentificationBROut> {\r\n    return this.http.post<ApiSuccess<ValidateIdentificationBROut>>(`${this.url}/identifications/br-validation`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,83 @@
+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 ApiSuppliesService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the API supplies endpoint.
+     *
+     * @return {string} The API supplies URL or an empty string if not defined.
+     */
+    get url() {
+        return this.environments.apiSuppliesUrl ?? '';
+    }
+    /**
+     * Fetches a list of supplies based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter the supplies.
+     * @return {Observable<SuppliesOut>} An observable containing the list of supplies.
+     */
+    getSupplies(params) {
+        return this.http.get(`${this.url}/supplies`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the supply details for a given supply ID.
+     *
+     * @param {number} id - The unique identifier of the supply to retrieve.
+     * @return {Observable<SupplyOut>} An observable containing the supply details.
+     */
+    getSupply(id) {
+        return this.http.get(`${this.url}/supplies/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a supply object to the server and returns the created or updated supply information.
+     *
+     * @param {SupplyIn} body - The supply information to be sent to the server.
+     * @return {Observable<SupplyOut>} An observable containing the response with the supply data.
+     */
+    postSupply(body) {
+        return this.http.post(`${this.url}/supplies`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing supply with the provided data.
+     *
+     * @param {number} id - The unique identifier of the supply to update.
+     * @param {SupplyIn} body - The data to update the supply with.
+     * @return {Observable<SupplyOut>} An observable containing the updated supply information.
+     */
+    putSupply(id, body) {
+        return this.http.put(`${this.url}/supplies/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the supply types based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter the supply types.
+     * @return {Observable<SupplyTypesOut>} An Observable that emits the supply types data.
+     */
+    getSupplyTypes(params) {
+        return this.http.get(`${this.url}/supply-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiSuppliesService, 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: ApiSuppliesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiSuppliesService, 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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

package/esm2022/lib/apis/models/api-companies.interfaces.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-companies.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { ActiveLessLaravelModel, LaravelModel } from './api.models'\r\nimport { BoardingProcessStatus, Country, Currency, IdentificationType, Product, State } from './api-catalog.interfaces'\r\n\r\nexport interface Account extends LaravelModel {\r\n  number: string\r\n  description: string | null\r\n  account_type_id: number\r\n  account_type: AccountType\r\n  country_id: number\r\n  domestic_approved: boolean\r\n  is_default: boolean\r\n}\r\n\r\nexport interface AccountCategory extends LaravelModel {\r\n  name: string\r\n}\r\n\r\nexport interface AccountType extends LaravelModel {\r\n  name: string\r\n  account_category_id: number\r\n  account_category?: AccountCategory\r\n}\r\n\r\nexport interface Company extends LaravelModel {\r\n  id: number\r\n  created_at: string\r\n  updated_at: string\r\n  name: string\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone: string\r\n  state: string\r\n  city: string\r\n  county_name: string\r\n  zip_code: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  is_active: boolean\r\n}\r\n\r\nexport interface CompanyCountry extends LaravelModel {\r\n  company_id: number\r\n  country_id: number\r\n  headquarters_city_code: string\r\n  lp_code: string\r\n  company: Company\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone_code: string\r\n  contact_phone_number: string\r\n  state: string\r\n  city: string\r\n  zip_code: string\r\n  county_name: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n}\r\n\r\nexport interface CompanyCountryTax extends LaravelModel {\r\n  code: string\r\n  name: string\r\n  percentage: number\r\n  company_country_id: number\r\n  shipment_scopes: number[]\r\n  base_percentage: number\r\n  tax_type: string\r\n}\r\n\r\nexport interface CountryCurrencyRate extends CountryReferenceCurrency {\r\n  rate: string\r\n}\r\n\r\nexport interface CountryReference extends LaravelModel {\r\n  language_id: number\r\n  decimal_point: number\r\n  decimal_separator: string\r\n  thousands_separator: string\r\n  use_billing: boolean\r\n  use_payments: boolean\r\n  restricted_import_countries: number[]\r\n  currency_id: number\r\n  max_quantity_document_piece: number\r\n  max_quantity_package_piece: number\r\n  weight_restriction_piece: number\r\n  restriction_shipment: number\r\n  restriction_dimension: number\r\n  max_declared_value: number\r\n  territories: number[]\r\n  some_openings: boolean\r\n  locale: string\r\n  country_id: number\r\n  label_printer_name: string\r\n  receipt_printer_name: string\r\n  others_printer_name: string\r\n  country: Country\r\n}\r\n\r\nexport interface CountryReferenceCurrency extends LaravelModel {\r\n  country_id: number\r\n  currency_id: number\r\n  is_local: boolean\r\n  can_transact: boolean\r\n  code: string\r\n  name: string\r\n  is_default: boolean\r\n  is_declared_insured: boolean\r\n  currency: Currency\r\n}\r\n\r\nexport interface CountryReferenceExtraCharge extends LaravelModel {\r\n  country_id: number\r\n  extra_charge_id: number\r\n  local_availability: boolean\r\n  mandatory: boolean\r\n  selected: boolean\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  value_local: number\r\n  value_usd: number\r\n}\r\n\r\nexport interface ExtraChargeEntity extends LaravelModel {\r\n  code: string\r\n  name: string\r\n}\r\n\r\nexport interface Employee extends LaravelModel {\r\n  name: string\r\n  last_name: string\r\n  number: string\r\n  email: string\r\n  username: string\r\n  company_id: number\r\n  country_id: number\r\n  external: boolean\r\n  phone_code: string\r\n  phone_number: string\r\n  locations: Location[]\r\n  company: Company\r\n}\r\n\r\nexport interface Exchange extends LaravelModel {\r\n  company_country_currency_id: number\r\n  valid_since: string\r\n  valid_until: string | null\r\n  value: string\r\n  type: string\r\n}\r\n\r\nexport interface CountryExchange extends Exchange {\r\n  currency: Currency\r\n  country_reference_currency: CountryReferenceCurrency\r\n}\r\n\r\nexport interface Installation extends LaravelModel {\r\n  system_id: number\r\n  mac_address: string\r\n  ip_address: string\r\n  location_id: number\r\n  number: number\r\n  system: System\r\n}\r\n\r\nexport interface Location extends LaravelModel {\r\n  accounts: Account[]\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  billing_code: string | null\r\n  city_name: string\r\n  commission_account: string | null\r\n  company_country: CompanyCountry\r\n  company_country_id: number\r\n  contact_name: string | null\r\n  country_region: null\r\n  country_region_id: number | null\r\n  country_zone: null\r\n  country_zone_id: number | null\r\n  county_name: string\r\n  default_account_id: number | null\r\n  email: string | null\r\n  etools_auto_billing_enabled: boolean\r\n  extra_fields: { [key: string]: string | number | boolean | null }\r\n  facility_code: string\r\n  facility_id: number\r\n  gmt_offset: string\r\n  google_maps_id: string\r\n  iata_code: string\r\n  is_occurs: boolean\r\n  location_code: string | null\r\n  locker_enabled: boolean\r\n  management_area: null\r\n  management_area_id: number | null\r\n  name: string\r\n  phone_code: string\r\n  phone_number: string\r\n  queue_manager_enabled: boolean\r\n  route_number: string\r\n  service_area_code: string\r\n  service_point_id: string\r\n  state: State\r\n  state_code: string | null\r\n  state_id: number\r\n  state_name: string\r\n  supervisor: Employee\r\n  type: string\r\n  zip_code: string\r\n}\r\n\r\nexport interface LocationEmployee extends LaravelModel {\r\n  location_id: number\r\n  employee_id: number\r\n  is_active: boolean\r\n  is_supervisor: boolean\r\n  employee: Employee\r\n  location: Location\r\n}\r\n\r\nexport interface Parameter extends LaravelModel {\r\n  name: string\r\n  type: string\r\n  regex: string\r\n  description: string\r\n  value: string | number | boolean | null | { [key: string]: (string | number | boolean | null)[] }\r\n  parameter_type_id: number\r\n}\r\n\r\nexport interface ParameterConfig {\r\n  id: number\r\n  level: number\r\n  model_type: string | null\r\n  model_id: number | null\r\n  parameter_id: number\r\n  name: string\r\n  value: string | number | boolean | null | { [key: string]: (string | number | boolean | null)[] }\r\n  parameter: Parameter\r\n}\r\n\r\nexport interface SupplyEntity extends LaravelModel {\r\n  name: string\r\n  description: string\r\n  country_id: number\r\n  enabled_for_dropoff: boolean\r\n  supply_type: SupplyType\r\n  supply_packing: SupplyPacking\r\n}\r\n\r\nexport interface SupplyPacking extends LaravelModel {\r\n  value: number\r\n  weight: number\r\n  height: number\r\n  depth: number\r\n  width: number\r\n  emobile_code: string | null\r\n}\r\n\r\nexport interface SupplyType extends LaravelModel {\r\n  name: string\r\n}\r\n\r\nexport interface WorkflowConfig {\r\n  id: number\r\n  system_id: number\r\n  level: string\r\n  model_type: string\r\n  model_id: number\r\n  name: string\r\n  page_id: number\r\n  page_name: string\r\n  enabled: boolean\r\n}\r\n\r\nexport interface EmployeeCustomerDhl extends LaravelModel {\r\n  identification_type_id: number\r\n  identification_type_value: string\r\n  name: string\r\n  last_name: string\r\n  address: string\r\n  phone_code: string\r\n  phone_number: string\r\n  email: string\r\n  country_id: number\r\n  employee_id: number | null\r\n  identification_type: IdentificationType\r\n}\r\n\r\nexport interface BoardingProcess {\r\n  id: number\r\n  boarding_process_type_id: number\r\n  status_id: number\r\n  is_finished: boolean\r\n  start_date_time: string\r\n  end_date_time: string\r\n  created_at: string\r\n  updated_at: string\r\n  status: BoardingProcessStatus\r\n  boarding_process_histories: BoardingProcessHistory[]\r\n}\r\n\r\nexport interface BoardingProcessHistory {\r\n  id: number\r\n  boarding_process_id: number\r\n  status_id: number\r\n  messages: string[]\r\n  created_at: string\r\n  updated_at: string\r\n}\r\n\r\nexport interface System extends LaravelModel {\r\n  name: string\r\n  type: string\r\n  configuration: { [key: string]: string }\r\n  can_workflow_config: boolean\r\n}\r\n\r\nexport interface CountryReferenceProduct extends LaravelModel {\r\n  country_id: number\r\n  product_id: number\r\n  local_name: string\r\n  min_weight: number\r\n  max_weight: number\r\n  insurance: number\r\n  business_letter: boolean\r\n  packaging: boolean\r\n  anti_drug_letter: boolean\r\n  max_declared_value: number\r\n  shipment_groups: number[]\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  is_prepaid_dropoff: boolean\r\n  product: Product\r\n}\r\n\r\nexport interface ProductEntity extends LaravelModel {\r\n  global_code: string\r\n  local_code: string\r\n  global_name: string\r\n  local_name: string\r\n}\r\n\r\nexport interface TDXAccountSetting extends LaravelModel {\r\n  location_id: number;\r\n  account_id: number;\r\n  product_id: number;\r\n  product_global_code_name: string;\r\n  product_local_code_name: string;\r\n  account: AccountToTDX\r\n}\r\n\r\nexport interface AccountToTDX extends ActiveLessLaravelModel {\r\n  number: string;\r\n  description: string | null;\r\n  account_type_id: number;\r\n  country_id: number;\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-companies.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { ActiveLessLaravelModel, LaravelModel } from './api.models'\r\nimport { BoardingProcessStatus, Country, Currency, IdentificationType, Product, State } from './api-catalog.interfaces'\r\n\r\nexport interface Account extends LaravelModel {\r\n  number: string\r\n  description: string | null\r\n  account_type_id: number\r\n  account_type: AccountType\r\n  country_id: number\r\n  domestic_approved: boolean\r\n  is_default: boolean\r\n}\r\n\r\nexport interface AccountCategory extends LaravelModel {\r\n  name: string\r\n}\r\n\r\nexport interface AccountType extends LaravelModel {\r\n  name: string\r\n  account_category_id: number\r\n  account_category?: AccountCategory\r\n}\r\n\r\nexport interface Company extends LaravelModel {\r\n  id: number\r\n  created_at: string\r\n  updated_at: string\r\n  name: string\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone: string\r\n  state: string\r\n  city: string\r\n  county_name: string\r\n  zip_code: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  is_active: boolean\r\n}\r\n\r\nexport interface CompanyCountry extends LaravelModel {\r\n  company_id: number\r\n  country_id: number\r\n  headquarters_city_code: string\r\n  lp_code: string\r\n  company: Company\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone_code: string\r\n  contact_phone_number: string\r\n  state: string\r\n  city: string\r\n  zip_code: string\r\n  county_name: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n}\r\n\r\nexport interface CompanyCountryTax extends LaravelModel {\r\n  code: string\r\n  name: string\r\n  percentage: number\r\n  company_country_id: number\r\n  shipment_scopes: number[]\r\n  base_percentage: number\r\n  tax_type: string\r\n}\r\n\r\nexport interface CountryCurrencyRate extends CountryReferenceCurrency {\r\n  rate: string\r\n}\r\n\r\nexport interface CountryReference extends LaravelModel {\r\n  language_id: number\r\n  decimal_point: number\r\n  decimal_separator: string\r\n  thousands_separator: string\r\n  use_billing: boolean\r\n  use_payments: boolean\r\n  restricted_import_countries: number[]\r\n  currency_id: number\r\n  max_quantity_document_piece: number\r\n  max_quantity_package_piece: number\r\n  weight_restriction_piece: number\r\n  restriction_shipment: number\r\n  restriction_dimension: number\r\n  max_declared_value: number\r\n  territories: number[]\r\n  some_openings: boolean\r\n  locale: string\r\n  country_id: number\r\n  label_printer_name: string\r\n  receipt_printer_name: string\r\n  others_printer_name: string\r\n  country: Country\r\n}\r\n\r\nexport interface CountryReferenceCurrency extends LaravelModel {\r\n  country_id: number\r\n  currency_id: number\r\n  is_local: boolean\r\n  can_transact: boolean\r\n  code: string\r\n  name: string\r\n  is_default: boolean\r\n  is_declared_insured: boolean\r\n  currency: Currency\r\n}\r\n\r\nexport interface CountryReferenceExtraCharge extends LaravelModel {\r\n  country_id: number\r\n  extra_charge_id: number\r\n  local_availability: boolean\r\n  mandatory: boolean\r\n  selected: boolean\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  value_local: number\r\n  value_usd: number\r\n}\r\n\r\nexport interface ExtraChargeEntity extends LaravelModel {\r\n  code: string\r\n  name: string\r\n}\r\n\r\nexport interface Employee extends LaravelModel {\r\n  name: string\r\n  last_name: string\r\n  number: string\r\n  email: string\r\n  username: string\r\n  company_id: number\r\n  country_id: number\r\n  external: boolean\r\n  phone_code: string\r\n  phone_number: string\r\n  locations: Location[]\r\n  company: Company\r\n}\r\n\r\nexport interface Exchange extends LaravelModel {\r\n  company_country_currency_id: number\r\n  valid_since: string\r\n  valid_until: string | null\r\n  value: string\r\n  type: string\r\n}\r\n\r\nexport interface CountryExchange extends Exchange {\r\n  currency: Currency\r\n  country_reference_currency: CountryReferenceCurrency\r\n}\r\n\r\nexport interface Installation extends LaravelModel {\r\n  system_id: number\r\n  mac_address: string\r\n  ip_address: string\r\n  location_id: number\r\n  number: number\r\n  system: System\r\n}\r\n\r\nexport interface Location extends LaravelModel {\r\n  accounts: Account[]\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  billing_code: string | null\r\n  city_name: string\r\n  commission_account: string | null\r\n  company_country: CompanyCountry\r\n  company_country_id: number\r\n  contact_name: string | null\r\n  country_region: null\r\n  country_region_id: number | null\r\n  country_zone: null\r\n  country_zone_id: number | null\r\n  county_name: string\r\n  default_account_id: number | null\r\n  email: string | null\r\n  etools_auto_billing_enabled: boolean\r\n  extra_fields: { [key: string]: string | number | boolean | null }\r\n  facility_code: string\r\n  facility_id: number\r\n  gmt_offset: string\r\n  google_maps_id: string\r\n  iata_code: string\r\n  is_occurs: boolean\r\n  location_code: string | null\r\n  locker_enabled: boolean\r\n  management_area: null\r\n  management_area_id: number | null\r\n  name: string\r\n  phone_code: string\r\n  phone_number: string\r\n  queue_manager_enabled: boolean\r\n  route_number: string\r\n  service_area_code: string\r\n  service_point_id: string\r\n  state: State\r\n  state_code: string | null\r\n  state_id: number\r\n  state_name: string\r\n  supervisor: Employee\r\n  type: string\r\n  zip_code: string\r\n}\r\n\r\nexport interface LocationEmployee extends LaravelModel {\r\n  location_id: number\r\n  employee_id: number\r\n  is_active: boolean\r\n  is_supervisor: boolean\r\n  employee: Employee\r\n  location: Location\r\n}\r\n\r\nexport interface Parameter extends LaravelModel {\r\n  name: string\r\n  type: string\r\n  regex: string\r\n  description: string\r\n  value: string | number | boolean | null | { [key: string]: (string | number | boolean | null)[] }\r\n  parameter_type_id: number\r\n}\r\n\r\nexport interface ParameterConfig {\r\n  id: number\r\n  level: number\r\n  model_type: string | null\r\n  model_id: number | null\r\n  parameter_id: number\r\n  name: string\r\n  value: string | number | boolean | null | { [key: string]: (string | number | boolean | null)[] }\r\n  parameter: Parameter\r\n}\r\n\r\nexport interface WorkflowConfig {\r\n  id: number\r\n  system_id: number\r\n  level: string\r\n  model_type: string\r\n  model_id: number\r\n  name: string\r\n  page_id: number\r\n  page_name: string\r\n  enabled: boolean\r\n}\r\n\r\nexport interface EmployeeCustomerDhl extends LaravelModel {\r\n  identification_type_id: number\r\n  identification_type_value: string\r\n  name: string\r\n  last_name: string\r\n  address: string\r\n  phone_code: string\r\n  phone_number: string\r\n  email: string\r\n  country_id: number\r\n  employee_id: number | null\r\n  identification_type: IdentificationType\r\n}\r\n\r\nexport interface BoardingProcess {\r\n  id: number\r\n  boarding_process_type_id: number\r\n  status_id: number\r\n  is_finished: boolean\r\n  start_date_time: string\r\n  end_date_time: string\r\n  created_at: string\r\n  updated_at: string\r\n  status: BoardingProcessStatus\r\n  boarding_process_histories: BoardingProcessHistory[]\r\n}\r\n\r\nexport interface BoardingProcessHistory {\r\n  id: number\r\n  boarding_process_id: number\r\n  status_id: number\r\n  messages: string[]\r\n  created_at: string\r\n  updated_at: string\r\n}\r\n\r\nexport interface System extends LaravelModel {\r\n  name: string\r\n  type: string\r\n  configuration: { [key: string]: string }\r\n  can_workflow_config: boolean\r\n}\r\n\r\nexport interface CountryReferenceProduct extends LaravelModel {\r\n  country_id: number\r\n  product_id: number\r\n  local_name: string\r\n  min_weight: number\r\n  max_weight: number\r\n  insurance: number\r\n  business_letter: boolean\r\n  packaging: boolean\r\n  anti_drug_letter: boolean\r\n  max_declared_value: number\r\n  shipment_groups: number[]\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  is_prepaid_dropoff: boolean\r\n  product: Product\r\n}\r\n\r\nexport interface ProductEntity extends LaravelModel {\r\n  global_code: string\r\n  local_code: string\r\n  global_name: string\r\n  local_name: string\r\n}\r\n\r\nexport interface TDXAccountSetting extends LaravelModel {\r\n  location_id: number;\r\n  account_id: number;\r\n  product_id: number;\r\n  product_global_code_name: string;\r\n  product_local_code_name: string;\r\n  account: AccountToTDX\r\n}\r\n\r\nexport interface AccountToTDX extends ActiveLessLaravelModel {\r\n  number: string;\r\n  description: string | null;\r\n  account_type_id: number;\r\n  country_id: number;\r\n}\r\n"]}

package/esm2022/lib/apis/models/api-companies.types.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.types.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-companies.types.ts"],"names":[],"mappings":"","sourcesContent":["import {\r\n  Account,\r\n  AccountCategory,\r\n  AccountType,\r\n  BoardingProcess,\r\n  Company,\r\n  CompanyCountry,\r\n  CompanyCountryTax,\r\n  CountryExchange,\r\n  CountryReference,\r\n  CountryReferenceCurrency,\r\n  CountryReferenceExtraCharge,\r\n  CountryReferenceProduct,\r\n  Employee,\r\n  EmployeeCustomerDhl,\r\n  ExtraChargeEntity,\r\n  Installation,\r\n  Location,\r\n  LocationEmployee,\r\n  Parameter,\r\n  ParameterConfig,\r\n  ProductEntity,\r\n  SupplyEntity,\r\n  System, TDXAccountSetting,\r\n  WorkflowConfig\r\n} from './api-companies.interfaces'\r\n\r\nexport type LocationEmployeesOut = {\r\n  location_employees: LocationEmployee[]\r\n  total: number\r\n}\r\n\r\nexport type LocationEmployeeBatchIn = {\r\n  store_update: {\r\n    location_id: number\r\n    employee_id: number\r\n    is_active: boolean\r\n  }[];\r\n}\r\n\r\nexport type LocationEmployeeOut = {\r\n  location_employee: LocationEmployee\r\n}\r\n\r\nexport type InstallationsOut = {\r\n  installations: Installation[]\r\n  total: number\r\n}\r\n\r\nexport type InstallationIn = {\r\n  system_id: number\r\n  mac_address: string\r\n  ip_address: string\r\n  location_id: number\r\n  number: number\r\n}\r\n\r\nexport type InstallationOut = {\r\n  installation: Installation\r\n}\r\n\r\nexport type LocationsOut = {\r\n  locations: Location[]\r\n  total: number\r\n}\r\n\r\nexport type LocationIn = {\r\n  name: string\r\n  contact_name: string\r\n  email: string\r\n  facility_code: string\r\n  location_code: string\r\n  state_name: string\r\n  state_id: number\r\n  state_code: string\r\n  city_name: string\r\n  zip_code: string\r\n  county_name: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  service_area_code: string\r\n  iata_code: string\r\n  phone_number: string\r\n  phone_code: string\r\n  is_active: boolean\r\n  gmt_offset: string\r\n  company_country_id: number\r\n  country_zone_id: number\r\n  country_region_id: number\r\n  management_area_id: number\r\n  route_number: string\r\n  locker_enabled: boolean\r\n  queue_manager_enabled: boolean\r\n  commission_account: string\r\n  type: string\r\n  facility_id: number\r\n  service_point_id: number\r\n  default_account_id: number\r\n}\r\nexport type LocationOut = {\r\n  location: Location\r\n}\r\n\r\nexport type SupplyEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  check_all?: boolean\r\n  supply_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type SupplyEntitiesOut = {\r\n  supply_entities: SupplyEntity[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeesOut = {\r\n  employees: Employee[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeeIn = {\r\n  auth_type: string\r\n  company_id: number\r\n  country_id: number\r\n  email: string\r\n  last_name: string\r\n  name: string\r\n  username: string\r\n  number: string\r\n  external: boolean\r\n  phone_code: string\r\n  phone_number: string\r\n  is_active: boolean\r\n  password: string\r\n  roles: string[]\r\n}\r\nexport type EmployeeOut = {\r\n  employee: Employee\r\n}\r\n\r\nexport type CompanyCountriesOut = {\r\n  company_countries: CompanyCountry[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyCountryIn = {\r\n  company_id: number\r\n  country_id: number\r\n  is_active: boolean\r\n  headquarters_city_code: string | null\r\n  lp_code: string | null\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone_code: string\r\n  contact_phone_number: string\r\n  state: string | null\r\n  city: string | null\r\n  zip_code: string | null\r\n  county_name: string | null\r\n  address1: string\r\n  address2: string | null\r\n  address3: string | null\r\n}\r\nexport type CompanyCountryOut = {\r\n  company_country: CompanyCountry\r\n}\r\n\r\nexport type CountryReferenceCurrencyIn = {\r\n  is_local: boolean\r\n  can_transact: boolean\r\n  code: string\r\n  name: string\r\n  is_default: boolean\r\n  is_declared_insured: boolean\r\n  is_active: boolean\r\n}\r\nexport type CountryReferenceCurrencyOut = {\r\n  country_reference_currency: CountryReferenceCurrency\r\n}\r\n\r\nexport type CountryReferenceCurrenciesOut = {\r\n  country_reference_currencies: CountryReferenceCurrency[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyCountryTaxesOut = {\r\n  company_country_taxes: CompanyCountryTax[]\r\n  total: number\r\n}\r\n\r\nexport type ExchangeIn = {\r\n  country_reference_currency_id: number\r\n  valid_since: string\r\n  valid_until?: string\r\n  value: string\r\n  type: string\r\n  is_active: boolean\r\n}\r\n\r\nexport type ExchangesOut = {\r\n  exchanges: CountryExchange[]\r\n  total: number\r\n}\r\n\r\nexport type ExchangeOut = {\r\n  exchange: CountryExchange\r\n}\r\n\r\nexport type AccountsOut = {\r\n  accounts: Account[]\r\n  total: number\r\n}\r\n\r\nexport type AccountIn = {\r\n  number: string\r\n  description: string\r\n  account_type_id: number\r\n  country_id: number\r\n}\r\nexport type AccountOut = {\r\n  account: Account\r\n}\r\n\r\nexport type AccountEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  account_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type AccountEntitiesOut = {\r\n  account_entities: Account[]\r\n  total: number\r\n}\r\n\r\nexport type AccountCategoriesOut = {\r\n  account_categories: AccountCategory[]\r\n  total: number\r\n}\r\n\r\nexport type AccountTypeIn = {\r\n  name: string\r\n  account_category_id: number\r\n}\r\nexport type AccountTypeOut = {\r\n  account_type: AccountType\r\n}\r\n\r\nexport type AccountTypesOut = {\r\n  account_types: AccountType[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersOut = {\r\n  parameters: Parameter[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersValuesIn = {\r\n  paramNames: string[]\r\n}\r\nexport type ParametersValuesOut = {\r\n  parameters: Parameter[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersByLevelIn = {\r\n  name: string\r\n  model_type: string\r\n  model_id: number\r\n}[]\r\n\r\nexport type ParameterValueIn = {\r\n  paramName: string\r\n}\r\nexport type ParameterValueOut = {\r\n  value: string | boolean | number | { [key: string]: (string | boolean | number)[] }\r\n}\r\n\r\nexport type CountryReferencesOut = {\r\n  country_references: CountryReference[]\r\n}\r\n\r\nexport type CountryReferenceIn = {\r\n  decimal_point: number\r\n  decimal_separator: string\r\n  thousands_separator: string\r\n  use_billing: boolean\r\n  use_payments: boolean\r\n  currency_id: number\r\n  is_active: boolean\r\n  locale: string\r\n  language_id: number\r\n  restricted_import_countries: number[]\r\n  max_quantity_document_piece: number\r\n  max_quantity_package_piece: number\r\n  weight_restriction_piece: number\r\n  restriction_shipment: number\r\n  restriction_dimension: number\r\n  max_declared_value: number\r\n  territories: number[]\r\n  some_openings: boolean\r\n}\r\nexport type CountryReferenceOut = {\r\n  country_reference: CountryReference\r\n}\r\n\r\nexport type CountryReferenceExtraChargeIn = {\r\n  local_availability: boolean\r\n  mandatory: boolean\r\n  selected: boolean\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  value_local: number\r\n  value_usd: number\r\n  country_id: number\r\n  extra_charge_id: number\r\n}\r\n\r\nexport type CountryReferenceExtraChargeOut = {\r\n  country_reference_extra_charge: CountryReferenceExtraCharge\r\n}\r\n\r\nexport type WorkflowsOut = {\r\n  workflow: {\r\n    page: string\r\n    enabled: boolean\r\n  }[]\r\n  system_configuration: object\r\n}\r\n\r\nexport type EmployeesCustomersOut = {\r\n  employee_customers: EmployeeCustomerDhl[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeeCustomersOut = {\r\n  employee_customer: EmployeeCustomerDhl\r\n}\r\n\r\nexport type EmployeeCustomersIn = {\r\n  identification_type_id: number\r\n  identification_type_value: string\r\n  name: string\r\n  last_name: string\r\n  address: string\r\n  phone_code: string\r\n  phone_number: string\r\n  email: string\r\n  country_id: number\r\n  employee_id: number | null\r\n  is_active: boolean\r\n}\r\n\r\nexport type BoardingProcessIn = {\r\n  boarding_process: BoardingProcess;\r\n}\r\n\r\nexport type BoardingProcessIdIn = {\r\n  boarding_process_id: number\r\n  message: string\r\n}\r\n\r\nexport type SystemsOut = {\r\n  systems: System[]\r\n  total: number\r\n}\r\n\r\nexport type SystemIn = {\r\n  name: string\r\n  type: string\r\n  can_workflow_config?: boolean\r\n  configuration: { [key: string]: string }\r\n}\r\nexport type SystemOut = {\r\n  system: System\r\n}\r\n\r\nexport type SystemEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  system_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\nexport type SystemEntitiesOut = {\r\n  system_entities: System[]\r\n  total: number\r\n}\r\n\r\nexport type WorkflowConfigsBatchIn = {\r\n  store: {\r\n    system_id: number\r\n    model_type: string\r\n    model_id: number\r\n    page_id: number\r\n    enabled: boolean\r\n  }[]\r\n  update: {\r\n    system_id: number\r\n    model_type: string\r\n    model_id: number\r\n    page_id: number\r\n    enabled: boolean\r\n  }[]\r\n}\r\n\r\nexport type WorkflowConfigsOut = {\r\n  workflow_configs: WorkflowConfig[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyIn = {\r\n  name: string\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone_code: string\r\n  contact_phone_number: string\r\n  state: string | null\r\n  city: string | null\r\n  county_name: string | null\r\n  zip_code: string | null\r\n  address1: string\r\n  address2: string | null\r\n  address3: string | null\r\n  is_active: boolean\r\n}\r\nexport type CompanyOut = {\r\n  company: Company\r\n}\r\n\r\nexport type ProductEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  product_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type ProductEntitiesOut = {\r\n  product_entities: ProductEntity[]\r\n  total: number\r\n}\r\n\r\nexport type CountryReferenceProductsOut = {\r\n  country_reference_products: CountryReferenceProduct[]\r\n  total: number\r\n}\r\n\r\nexport type CountryReferenceProductIn = {\r\n  anti_drug_letter: boolean\r\n  business_letter: boolean\r\n  country_id: number\r\n  max_declared_value: number\r\n  max_weight: number\r\n  min_weight: number\r\n  packaging: boolean\r\n  product_id: number\r\n  shipment_content_types: number[]\r\n  shipment_groups: number[]\r\n  shipment_scopes: number[]\r\n  local_name: string\r\n  insurance: number\r\n}\r\nexport type CountryReferenceProductOut = {\r\n  country_reference_product: CountryReferenceProduct\r\n}\r\n\r\nexport type ExtraChargeEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  extracharge_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\nexport type ExtraChargeEntitiesOut = {\r\n  extracharge_entities: ExtraChargeEntity[]\r\n  total: number\r\n}\r\n\r\nexport type ParameterConfigsOut = {\r\n  parameter_configs: ParameterConfig[]\r\n  total: number\r\n}\r\n\r\nexport type ParameterConfigIn = {\r\n  level: string\r\n  parameter_id: number\r\n  model_type: string\r\n  model_id: number\r\n  name: string\r\n  value: string\r\n}\r\nexport type ParameterConfigOut = {\r\n  parameter_config: ParameterConfig\r\n  total: number\r\n}\r\n\r\nexport type TDXAccountsSettingsOut = {\r\n  tdx_account_settings: TDXAccountSetting[]\r\n  total: number\r\n}\r\n\r\nexport type TDXAccountSettingsOut = {\r\n  tdx_account_settings: TDXAccountSetting\r\n}\r\n\r\nexport type TDXAccountSettingsIn = {\r\n  id?: number\r\n  location_id: number\r\n  account_id: number\r\n  product_id: number\r\n  is_active: boolean\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.types.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-companies.types.ts"],"names":[],"mappings":"","sourcesContent":["import {\r\n  Account,\r\n  AccountCategory,\r\n  AccountType,\r\n  BoardingProcess,\r\n  Company,\r\n  CompanyCountry,\r\n  CompanyCountryTax,\r\n  CountryExchange,\r\n  CountryReference,\r\n  CountryReferenceCurrency,\r\n  CountryReferenceExtraCharge,\r\n  CountryReferenceProduct,\r\n  Employee,\r\n  EmployeeCustomerDhl,\r\n  ExtraChargeEntity,\r\n  Installation,\r\n  Location,\r\n  LocationEmployee,\r\n  Parameter,\r\n  ParameterConfig,\r\n  ProductEntity,\r\n  System,\r\n  TDXAccountSetting,\r\n  WorkflowConfig\r\n} from './api-companies.interfaces'\r\nimport { Supply } from './api-supplies.interfaces'\r\n\r\nexport type LocationEmployeesOut = {\r\n  location_employees: LocationEmployee[]\r\n  total: number\r\n}\r\n\r\nexport type LocationEmployeeBatchIn = {\r\n  store_update: {\r\n    location_id: number\r\n    employee_id: number\r\n    is_active: boolean\r\n  }[];\r\n}\r\n\r\nexport type LocationEmployeeOut = {\r\n  location_employee: LocationEmployee\r\n}\r\n\r\nexport type InstallationsOut = {\r\n  installations: Installation[]\r\n  total: number\r\n}\r\n\r\nexport type InstallationIn = {\r\n  system_id: number\r\n  mac_address: string\r\n  ip_address: string\r\n  location_id: number\r\n  number: number\r\n}\r\n\r\nexport type InstallationOut = {\r\n  installation: Installation\r\n}\r\n\r\nexport type LocationsOut = {\r\n  locations: Location[]\r\n  total: number\r\n}\r\n\r\nexport type LocationIn = {\r\n  name: string\r\n  contact_name: string\r\n  email: string\r\n  facility_code: string\r\n  location_code: string\r\n  state_name: string\r\n  state_id: number\r\n  state_code: string\r\n  city_name: string\r\n  zip_code: string\r\n  county_name: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  service_area_code: string\r\n  iata_code: string\r\n  phone_number: string\r\n  phone_code: string\r\n  is_active: boolean\r\n  gmt_offset: string\r\n  company_country_id: number\r\n  country_zone_id: number\r\n  country_region_id: number\r\n  management_area_id: number\r\n  route_number: string\r\n  locker_enabled: boolean\r\n  queue_manager_enabled: boolean\r\n  commission_account: string\r\n  type: string\r\n  facility_id: number\r\n  service_point_id: number\r\n  default_account_id: number\r\n}\r\nexport type LocationOut = {\r\n  location: Location\r\n}\r\n\r\nexport type SupplyEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  check_all?: boolean\r\n  supply_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type SupplyEntitiesOut = {\r\n  supply_entities: Supply[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeesOut = {\r\n  employees: Employee[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeeIn = {\r\n  auth_type: string\r\n  company_id: number\r\n  country_id: number\r\n  email: string\r\n  last_name: string\r\n  name: string\r\n  username: string\r\n  number: string\r\n  external: boolean\r\n  phone_code: string\r\n  phone_number: string\r\n  is_active: boolean\r\n  password: string\r\n  roles: string[]\r\n}\r\nexport type EmployeeOut = {\r\n  employee: Employee\r\n}\r\n\r\nexport type CompanyCountriesOut = {\r\n  company_countries: CompanyCountry[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyCountryIn = {\r\n  company_id: number\r\n  country_id: number\r\n  is_active: boolean\r\n  headquarters_city_code: string | null\r\n  lp_code: string | null\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone_code: string\r\n  contact_phone_number: string\r\n  state: string | null\r\n  city: string | null\r\n  zip_code: string | null\r\n  county_name: string | null\r\n  address1: string\r\n  address2: string | null\r\n  address3: string | null\r\n}\r\nexport type CompanyCountryOut = {\r\n  company_country: CompanyCountry\r\n}\r\n\r\nexport type CountryReferenceCurrencyIn = {\r\n  is_local: boolean\r\n  can_transact: boolean\r\n  code: string\r\n  name: string\r\n  is_default: boolean\r\n  is_declared_insured: boolean\r\n  is_active: boolean\r\n}\r\nexport type CountryReferenceCurrencyOut = {\r\n  country_reference_currency: CountryReferenceCurrency\r\n}\r\n\r\nexport type CountryReferenceCurrenciesOut = {\r\n  country_reference_currencies: CountryReferenceCurrency[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyCountryTaxesOut = {\r\n  company_country_taxes: CompanyCountryTax[]\r\n  total: number\r\n}\r\n\r\nexport type ExchangeIn = {\r\n  country_reference_currency_id: number\r\n  valid_since: string\r\n  valid_until?: string\r\n  value: string\r\n  type: string\r\n  is_active: boolean\r\n}\r\n\r\nexport type ExchangesOut = {\r\n  exchanges: CountryExchange[]\r\n  total: number\r\n}\r\n\r\nexport type ExchangeOut = {\r\n  exchange: CountryExchange\r\n}\r\n\r\nexport type AccountsOut = {\r\n  accounts: Account[]\r\n  total: number\r\n}\r\n\r\nexport type AccountIn = {\r\n  number: string\r\n  description: string\r\n  account_type_id: number\r\n  country_id: number\r\n}\r\nexport type AccountOut = {\r\n  account: Account\r\n}\r\n\r\nexport type AccountEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  account_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type AccountEntitiesOut = {\r\n  account_entities: Account[]\r\n  total: number\r\n}\r\n\r\nexport type AccountCategoriesOut = {\r\n  account_categories: AccountCategory[]\r\n  total: number\r\n}\r\n\r\nexport type AccountTypeIn = {\r\n  name: string\r\n  account_category_id: number\r\n}\r\nexport type AccountTypeOut = {\r\n  account_type: AccountType\r\n}\r\n\r\nexport type AccountTypesOut = {\r\n  account_types: AccountType[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersOut = {\r\n  parameters: Parameter[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersValuesIn = {\r\n  paramNames: string[]\r\n}\r\nexport type ParametersValuesOut = {\r\n  parameters: Parameter[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersByLevelIn = {\r\n  name: string\r\n  model_type: string\r\n  model_id: number\r\n}[]\r\n\r\nexport type ParameterValueIn = {\r\n  paramName: string\r\n}\r\nexport type ParameterValueOut = {\r\n  value: string | boolean | number | { [key: string]: (string | boolean | number)[] }\r\n}\r\n\r\nexport type CountryReferencesOut = {\r\n  country_references: CountryReference[]\r\n}\r\n\r\nexport type CountryReferenceIn = {\r\n  decimal_point: number\r\n  decimal_separator: string\r\n  thousands_separator: string\r\n  use_billing: boolean\r\n  use_payments: boolean\r\n  currency_id: number\r\n  is_active: boolean\r\n  locale: string\r\n  language_id: number\r\n  restricted_import_countries: number[]\r\n  max_quantity_document_piece: number\r\n  max_quantity_package_piece: number\r\n  weight_restriction_piece: number\r\n  restriction_shipment: number\r\n  restriction_dimension: number\r\n  max_declared_value: number\r\n  territories: number[]\r\n  some_openings: boolean\r\n}\r\nexport type CountryReferenceOut = {\r\n  country_reference: CountryReference\r\n}\r\n\r\nexport type CountryReferenceExtraChargeIn = {\r\n  local_availability: boolean\r\n  mandatory: boolean\r\n  selected: boolean\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  value_local: number\r\n  value_usd: number\r\n  country_id: number\r\n  extra_charge_id: number\r\n}\r\n\r\nexport type CountryReferenceExtraChargeOut = {\r\n  country_reference_extra_charge: CountryReferenceExtraCharge\r\n}\r\n\r\nexport type WorkflowsOut = {\r\n  workflow: {\r\n    page: string\r\n    enabled: boolean\r\n  }[]\r\n  system_configuration: object\r\n}\r\n\r\nexport type EmployeesCustomersOut = {\r\n  employee_customers: EmployeeCustomerDhl[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeeCustomersOut = {\r\n  employee_customer: EmployeeCustomerDhl\r\n}\r\n\r\nexport type EmployeeCustomersIn = {\r\n  identification_type_id: number\r\n  identification_type_value: string\r\n  name: string\r\n  last_name: string\r\n  address: string\r\n  phone_code: string\r\n  phone_number: string\r\n  email: string\r\n  country_id: number\r\n  employee_id: number | null\r\n  is_active: boolean\r\n}\r\n\r\nexport type BoardingProcessIn = {\r\n  boarding_process: BoardingProcess;\r\n}\r\n\r\nexport type BoardingProcessIdIn = {\r\n  boarding_process_id: number\r\n  message: string\r\n}\r\n\r\nexport type SystemsOut = {\r\n  systems: System[]\r\n  total: number\r\n}\r\n\r\nexport type SystemIn = {\r\n  name: string\r\n  type: string\r\n  can_workflow_config?: boolean\r\n  configuration: { [key: string]: string }\r\n}\r\nexport type SystemOut = {\r\n  system: System\r\n}\r\n\r\nexport type SystemEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  system_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\nexport type SystemEntitiesOut = {\r\n  system_entities: System[]\r\n  total: number\r\n}\r\n\r\nexport type WorkflowConfigsBatchIn = {\r\n  store: {\r\n    system_id: number\r\n    model_type: string\r\n    model_id: number\r\n    page_id: number\r\n    enabled: boolean\r\n  }[]\r\n  update: {\r\n    system_id: number\r\n    model_type: string\r\n    model_id: number\r\n    page_id: number\r\n    enabled: boolean\r\n  }[]\r\n}\r\n\r\nexport type WorkflowConfigsOut = {\r\n  workflow_configs: WorkflowConfig[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyIn = {\r\n  name: string\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone_code: string\r\n  contact_phone_number: string\r\n  state: string | null\r\n  city: string | null\r\n  county_name: string | null\r\n  zip_code: string | null\r\n  address1: string\r\n  address2: string | null\r\n  address3: string | null\r\n  is_active: boolean\r\n}\r\nexport type CompanyOut = {\r\n  company: Company\r\n}\r\n\r\nexport type ProductEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  product_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type ProductEntitiesOut = {\r\n  product_entities: ProductEntity[]\r\n  total: number\r\n}\r\n\r\nexport type CountryReferenceProductsOut = {\r\n  country_reference_products: CountryReferenceProduct[]\r\n  total: number\r\n}\r\n\r\nexport type CountryReferenceProductIn = {\r\n  anti_drug_letter: boolean\r\n  business_letter: boolean\r\n  country_id: number\r\n  max_declared_value: number\r\n  max_weight: number\r\n  min_weight: number\r\n  packaging: boolean\r\n  product_id: number\r\n  shipment_content_types: number[]\r\n  shipment_groups: number[]\r\n  shipment_scopes: number[]\r\n  local_name: string\r\n  insurance: number\r\n}\r\nexport type CountryReferenceProductOut = {\r\n  country_reference_product: CountryReferenceProduct\r\n}\r\n\r\nexport type ExtraChargeEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  extracharge_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\nexport type ExtraChargeEntitiesOut = {\r\n  extracharge_entities: ExtraChargeEntity[]\r\n  total: number\r\n}\r\n\r\nexport type ParameterConfigsOut = {\r\n  parameter_configs: ParameterConfig[]\r\n  total: number\r\n}\r\n\r\nexport type ParameterConfigIn = {\r\n  level: string\r\n  parameter_id: number\r\n  model_type: string\r\n  model_id: number\r\n  name: string\r\n  value: string\r\n}\r\nexport type ParameterConfigOut = {\r\n  parameter_config: ParameterConfig\r\n  total: number\r\n}\r\n\r\nexport type TDXAccountsSettingsOut = {\r\n  tdx_account_settings: TDXAccountSetting[]\r\n  total: number\r\n}\r\n\r\nexport type TDXAccountSettingsOut = {\r\n  tdx_account_settings: TDXAccountSetting\r\n}\r\n\r\nexport type TDXAccountSettingsIn = {\r\n  id?: number\r\n  location_id: number\r\n  account_id: number\r\n  product_id: number\r\n  is_active: boolean\r\n}\r\n"]}