import * as i0 from '@angular/core';
import { InjectionToken, ModuleWithProviders, EnvironmentProviders } from '@angular/core';
import { Observable } from 'rxjs';
import { HttpResponse, HttpRequest, HttpHandlerFn, HttpEvent, HttpParams, HttpHeaders } from '@angular/common/http';
import { Channel } from 'pusher-js';

/**
 * Represents the configuration settings for the application's environment.
 * This type includes various API endpoint URLs, authentication details, caching options, and other relevant settings.
 *
 * Properties:
 * - apiCompaniesUrl: The URL for the companies API endpoint.
 * - apiEventsUrl: The URL for the events API endpoint.
 * - apiInvoicesUrl: The URL for the invoices API endpoint.
 * - apiReportsUrl: The URL for the reports API endpoint.
 * - apiSecurityUrl: The URL for the security-related API endpoint.
 * - apiShipmentUrl: The URL for the shipment API endpoint.
 * - authCookie: The name of the authentication cookie used for user sessions.
 * - cacheTtl: Optional. Specifies the time-to-live (TTL) for cached items.
 * - printUrl: Optional. The URL used for generating or downloading printable documents.
 * - secretKey: A secret key used for authentication or other secure operations.
 */
type Environment = {
    apiBillingDO?: string;
    apiBillingGT?: string;
    apiBillingMX?: string;
    apiBillingPA?: string;
    apiBillingSV?: string;
    apiCashOperationsUrl?: string;
    apiCatalogsUrl?: string;
    apiCompaniesUrl?: string;
    apiCompositionUrl?: string;
    apiCustomsUrl?: string;
    apiDiscountsUrl?: string;
    apiEToolsAutoBilling?: string;
    apiEventsUrl?: string;
    apiExternalOperationsKey?: string;
    apiExternalOperationsUrl?: string;
    apiInventoriesUrl?: string;
    apiInvoicesUrl?: string;
    apiNotificationsUrl?: string;
    apiOpenItemsUrl?: string;
    apiQuotesUrl?: string;
    apiReportsUrl?: string;
    apiSecurityUrl?: string;
    apiServicesUrl?: string;
    apiShipmentUrl?: string;
    apiSuppliesUrl?: string;
    apiSurveysUrl?: string;
    authCookie?: string;
    cacheTtl?: number;
    printUrl?: string;
    secretKey?: string;
    sockets?: {
        app_key: string;
        debug?: boolean;
        port: number;
        url: string;
    };
};
/**
 * Injection token used to inject environment configurations.
 *
 * `ENVIRONMENT_TOKEN` is a dependency injection token that allows
 * for the provision and retrieval of environment-specific configurations
 * within the application. This token is typically associated with an
 * `Environment` type that defines the structure of the configuration.
 */
declare const ENVIRONMENT_TOKEN: InjectionToken<Environment>;

declare class NgxServicesModule {
    /**
     * Returns a module with providers for the NgxServicesModule.
     *
     * @param {Environment} environment - The environment configuration object.
     *
     * @return {ModuleWithProviders<NgxServicesModule>} The module with providers for the NgxServicesModule.
     *
    * @deprecated Use `provideNgxServices(environment)` in `ApplicationConfig.providers`
    * for standalone applications. This API will be removed in `20.2.0`.
     */
    static forRoot(environment: Environment): ModuleWithProviders<NgxServicesModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxServicesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxServicesModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgxServicesModule>;
}

/**
 * Provides ngx-services dependencies for standalone Angular applications.
 *
 * Register this provider in `ApplicationConfig.providers` so all services in
 * this library can resolve the environment-based configuration.
 */
declare function provideNgxServices(environment: Environment): EnvironmentProviders;

interface ApiResponse {
    status: 'success' | 'fail' | 'error';
}
interface ApiSuccess<T> extends ApiResponse {
    status: 'success';
    data: T;
}
interface ApiModel {
    id: number;
}
interface LaravelModel extends ApiModel {
    is_active: boolean;
    created_at: string;
    updated_at: string;
}
interface ActiveLessLaravelModel extends ApiModel {
    created_at: string;
    updated_at: string;
}
interface SymfonyModel extends ApiModel {
    isActive: boolean;
    createdAt: string;
    updatedAt: string;
}
interface ActiveLessSymfonyModel extends ApiModel {
    createdAt: string;
    updatedAt: string;
}
type QueryParams = {
    [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
};
interface Translations {
    [key: string]: TranslateLang;
}
interface TranslateLang {
    [langCode: string]: string;
}

interface IncomeType extends LaravelModel {
    code: string;
    name: string;
    billing_code: string;
}

type IncomeTypesOut = {
    income_types: IncomeType[];
    total: number;
};

declare class ApiBillingDOService {
    private environments;
    private http;
    /**
     * Gets the base URL for Billing DO API endpoints.
     *
     * @returns {string} Billing DO API base URL, or an empty string when it is not configured.
     */
    get url(): string;
    /**
     * Retrieves the list of income types from Billing DO.
     *
     * @returns {Observable<IncomeTypesOut>} Observable that emits the income types payload.
     */
    getIncomeTypes(): Observable<IncomeTypesOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiBillingDOService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiBillingDOService>;
}

interface BillingPaCustomer {
    document_id: number;
    name: string;
    number: string;
    type_ruc: number;
    type_ruc_code: string;
    verification_code: string;
    type_rec: string;
    identification_type_id: number;
}
interface District extends LaravelModel {
    code: string;
    name: string;
    province_id: number;
}
interface Parish extends LaravelModel {
    code: string;
    name: string;
    district_id: number;
    province_id: number;
}
interface Province extends LaravelModel {
    code: string;
    name: string;
}

type DistrictsOut = {
    total: number;
    districts: District[];
};
type BillingPaCustomerOut = {
    customer: BillingPaCustomer;
};
type ParishesOut = {
    total: number;
    parishes: Parish[];
};
type ProvincesOut = {
    total: number;
    provinces: Province[];
};

interface ApiBillingConfigurable {
    getConfigs(): Observable<BillingConfigsOut>;
    getConfig(id: number): Observable<BillingConfigOut>;
    postConfigs(body: BillingConfigIn): Observable<BillingConfigOut>;
    getDistricts?(params: QueryParams): Observable<DistrictsOut>;
    getParishes?(params: QueryParams): Observable<ParishesOut>;
    getProvinces?(params: QueryParams): Observable<ProvincesOut>;
}
type BillingConfig = {
    label: string;
    field: string;
    is_required: boolean;
    type?: string;
};
type BillingConfigsOut = {
    configurations: BillingConfig[];
    total: number;
};
type BillingConfigIn = {
    [key: string]: string | number;
};
type BillingConfigOut = {
    [key: string]: [key: string | number][];
};

declare class ApiBillingGtService implements ApiBillingConfigurable {
    private environments;
    private http;
    /**
     * Gets the base URL for Billing GT API endpoints.
     *
     * @returns {string} Billing GT API base URL, or an empty string when it is not configured.
     */
    get url(): string;
    /**
     * Retrieves the list of billing configurations by location.
     *
     * @returns {Observable<BillingConfigsOut>} Observable that emits the billing configurations payload.
     */
    getConfigs(): Observable<BillingConfigsOut>;
    /**
     * Retrieves billing configuration details for a location.
     *
     * @param {number} id - Location identifier to fetch.
     * @returns {Observable<BillingConfigOut>} Observable that emits the location billing configuration payload.
     */
    getConfig(id: number): Observable<BillingConfigOut>;
    /**
     * Creates a billing configuration for a location.
     *
     * @param {BillingConfigIn} body - Billing configuration payload for the location.
     * @returns {Observable<BillingConfigOut>} Observable that emits the created billing configuration payload.
     */
    postConfigs(body: BillingConfigIn): Observable<BillingConfigOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiBillingGtService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiBillingGtService>;
}

interface CFDI extends LaravelModel {
    code: string;
    description: string;
    fiscal_regimen_receptor: string;
    moral_person: string;
    physical_person: string;
}
interface FiscalRegimen extends LaravelModel {
    code: string;
    description: string;
    moral_person: string;
    physical_person: string;
}
interface PostalCodeBillings extends LaravelModel {
    city: string;
    municipality: string;
    state: string;
    suburb: string;
    postal_code_number: string;
}

type FiscalRegimensAcceptedOut = {
    total: number;
    cfdi_use: CFDI[];
};
type FiscalRegimensOut = {
    total: number;
    fiscal_regimen: FiscalRegimen[];
};
type PostalCodesOut = {
    postal_code: PostalCodeBillings[];
    total: number;
};

declare class ApiBillingMxService {
    private environments;
    private http;
    /**
     * Gets the base URL for Billing MX API endpoints.
     *
     * @returns {string} Billing MX API base URL, or an empty string when it is not configured.
     */
    get url(): string;
    /**
     * Retrieves the list of fiscal regimens from Billing MX.
     *
     * @returns {Observable<FiscalRegimensOut>} Observable that emits the fiscal regimens payload.
     */
    getFiscalRegimens(): Observable<FiscalRegimensOut>;
    /**
     * Retrieves the CFDI uses accepted for a fiscal regimen.
     *
     * @param {number} fiscalRegimen Fiscal regimen identifier used to filter accepted CFDI uses.
     * @returns {Observable<FiscalRegimensAcceptedOut>} Observable that emits the accepted CFDI uses payload.
     */
    getFiscalRegimensAccepted(fiscalRegimen: number): Observable<FiscalRegimensAcceptedOut>;
    /**
     * Retrieves postal code information from Billing MX.
     *
     * @param {QueryParams} params Query parameters used by the postal codes endpoint.
     * @returns {Observable<PostalCodesOut>} Observable that emits the postal code data payload.
     */
    getPostalCodes(params: QueryParams): Observable<PostalCodesOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiBillingMxService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiBillingMxService>;
}

declare class ApiBillingPaService implements ApiBillingConfigurable {
    private environments;
    private http;
    /**
     * Gets the base URL for Billing PA API endpoints.
     *
     * @returns {string} Billing PA API base URL, or an empty string when it is not configured.
     */
    get url(): string;
    /**
     * Retrieves the list of districts.
     *
     * @param {QueryParams} params Query parameters used by the districts endpoint.
     * @returns {Observable<DistrictsOut>} Observable that emits the districts payload.
     */
    getDistricts(params: QueryParams): Observable<DistrictsOut>;
    /**
      * Retrieves the list of parishes.
     *
      * @param {QueryParams} params Query parameters used by the parishes endpoint.
      * @returns {Observable<ParishesOut>} Observable that emits the parishes payload.
     */
    getParishes(params: QueryParams): Observable<ParishesOut>;
    /**
      * Retrieves the list of provinces.
     *
      * @param {QueryParams} params Query parameters used by the provinces endpoint.
      * @returns {Observable<ProvincesOut>} Observable that emits the provinces payload.
     */
    getProvinces(params: QueryParams): Observable<ProvincesOut>;
    /**
      * Validates a customer using Billing PA.
     *
      * @param {QueryParams} params Query parameters used by the customer validation endpoint.
      * @returns {Observable<BillingPaCustomerOut>} Observable that emits customer validation data.
     */
    getValidateCustomer(params: QueryParams): Observable<BillingPaCustomerOut>;
    /**
      * Retrieves billing configurations by location.
     *
      * @returns {Observable<BillingConfigsOut>} Observable that emits billing configuration items.
     */
    getConfigs(): Observable<BillingConfigsOut>;
    /**
      * Retrieves the billing configuration for a location.
     *
      * @param {number} id Location identifier.
      * @returns {Observable<BillingConfigOut>} Observable that emits the location billing configuration payload.
     */
    getConfig(id: number): Observable<BillingConfigOut>;
    /**
      * Creates a billing configuration for a location.
     *
      * @param {BillingConfigIn} body Billing configuration payload for the new location.
      * @returns {Observable<BillingConfigOut>} Observable that emits the created billing configuration payload.
     */
    postConfigs(body: BillingConfigIn): Observable<BillingConfigOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiBillingPaService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiBillingPaService>;
}

interface PersonType extends LaravelModel {
    code: string;
    name: string;
}
interface EconomicActivity extends LaravelModel {
    code: string;
    name: string;
}
interface EstablishmentType extends LaravelModel {
    code: string;
    name: string;
}
interface Department extends LaravelModel {
    code: string;
    name: string;
}
interface Municipality extends LaravelModel {
    code: string;
    name: string;
    department_code: string;
}

type EconomicActivitiesOut = {
    economic_activities: EconomicActivity[];
    total: number;
};
type PersonTypesOut = {
    person_types: PersonType[];
    total: number;
};
type EstablishmentTypesOut = {
    establishment_types: EstablishmentType[];
    total: number;
};
type DepartmentsOut = {
    departments: Department[];
    total: number;
};
type MunicipalitiesOut = {
    municipalities: Municipality[];
    total: number;
};

declare class ApiBillingSvService {
    private environments;
    private http;
    /**
     * Retrieves the URL for the billing API.
     * If the URL is not defined in the environments configuration, returns an empty string.
     *
    * @returns {string} The billing API URL or an empty string if not set.
     */
    get url(): string;
    /**
     * Fetches the list of economic activities based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter the economic activities.
    * @returns {Observable<EconomicActivitiesOut>} An observable that emits the list of economic activities.
     */
    getEconomicActivities(params: QueryParams): Observable<EconomicActivitiesOut>;
    /**
     * Retrieves the list of person types based on given query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter the person types.
    * @returns {Observable<PersonTypesOut>} An observable that emits a list of person types.
     */
    getPersonTypes(params: QueryParams): Observable<PersonTypesOut>;
    /**
     * Fetches the list of establishment types.
     *
     * @param {QueryParams} params The query parameters to be sent with the HTTP request.
    * @returns {Observable<EstablishmentTypesOut>} An observable that emits the establishment types data.
     */
    getEstablishmentTypes(params: QueryParams): Observable<EstablishmentTypesOut>;
    /**
     * Fetches the list of departments based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter or modify the departments fetch request.
    * @returns {Observable<DepartmentsOut>} An observable emitting the list of departments.
     */
    getDepartments(params: QueryParams): Observable<DepartmentsOut>;
    /**
     * Retrieves a list of municipalities based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter the municipalities.
    * @returns {Observable<MunicipalitiesOut>} An observable that emits the retrieved municipalities data.
     */
    getMunicipalities(params: QueryParams): Observable<MunicipalitiesOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiBillingSvService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiBillingSvService>;
}

interface InstallationCountryReferenceCurrency extends ActiveLessSymfonyModel {
    installationId?: number;
    countryReferenceCurrencyId: number;
    minCashValue?: number;
    maxCashValue?: number;
}
interface CashValueSummary {
    countryReferenceCurrencyId: number;
    currencyCode: string;
    balanceInitial: number;
    transfers: number;
    payments: number;
    totalBalance: number;
    minCashValue: number;
    maxAmount: number;
}
interface OpeningTransference extends ActiveLessSymfonyModel {
    openingId: number;
    openingReferenceId: number;
    transferenceTypeId: number;
    userId: number;
    amount: number;
    countryReferenceCurrencyId: number;
    transferenceCode: string;
    receiptNumber: string;
    userName: string | null;
    userUsername: string | null;
    currencyCode: string | null;
    maxCashExceeded: boolean;
    transferenceType: TransferenceType;
}
interface ReceiptFile {
    format: string;
    base64: string;
}
interface TransferenceType extends SymfonyModel {
    code: string;
    name: string;
}

type InstallationCountryReferenceCurrenciesOut = {
    total: number;
    installationCountryReferenceCurrencies: InstallationCountryReferenceCurrency[];
};
type InstallationCountryReferenceCurrencyIn = {
    installationId?: number;
    countryReferenceCurrencyId: number;
    minCashValue?: number;
    maxCashValue?: number;
};
type InstallationCountryReferenceCurrencyOut = {
    installationCountryReferenceCurrencies: InstallationCountryReferenceCurrency;
};
type CashValueSummaryOut = {
    total: number;
    cashValueSummary: CashValueSummary[];
};
type OpeningTransferenceIn = {
    openingId: number;
    amount: number;
    countryReferenceCurrencyId: number;
    transferenceTypeCode: string;
};
type OpeningTransferenceOut = {
    openingTransference: OpeningTransference;
};
type ReceiptFileOut = {
    receipt: ReceiptFile;
};
type DepositSlipOut = {
    depositSlip: {
        format: string;
        base64: string;
    };
};

declare class ApiCashOperationsService {
    private environments;
    private http;
    /**
     * Retrieves the URL for the cash operations API from the environment configurations.
     *
    * @returns {string} The URL of the cash operations API.
     */
    get url(): string;
    /**
     * Creates a new installation country reference currency.
     *
     * @param {InstallationCountryReferenceCurrencyIn} body - The data for the new reference currency.
     * @returns {Observable<InstallationCountryReferenceCurrencyOut>} The created reference currency.
     */
    postInstallationCountryReferenceCurrency(body: InstallationCountryReferenceCurrencyIn): Observable<InstallationCountryReferenceCurrencyOut>;
    /**
     * Updates an existing installation country reference currency.
     *
     * @param {number} id - The ID of the reference currency to update.
     * @param {InstallationCountryReferenceCurrencyIn} body - The updated data for the reference currency.
     * @returns {Observable<InstallationCountryReferenceCurrencyOut>} The updated reference currency.
     */
    putInstallationCountryReferenceCurrency(id: number, body: InstallationCountryReferenceCurrencyIn): Observable<InstallationCountryReferenceCurrencyOut>;
    /**
     * Retrieves a list of installation country reference currencies based on query parameters.
     *
     * @param {QueryParams} params - Query parameters for filtering the currencies.
     * @returns {Observable<InstallationCountryReferenceCurrenciesOut>} The list of reference currencies.
     */
    getInstallationCompanyCountryCurrencies(params: QueryParams): Observable<InstallationCountryReferenceCurrenciesOut>;
    /**
     * Retrieves the cash value summary for a specific opening ID.
     *
     * @param {number} id - The ID of the opening for which to retrieve the cash value summary.
     * @returns {Observable<CashValueSummaryOut>} An observable that emits the cash value summary data.
     */
    getOpeningCashValueSummary(id: number): Observable<CashValueSummaryOut>;
    /**
     * Creates a new opening transference record.
     *
     * @param {OpeningTransferenceIn} body - The data to create the new opening transference.
     * @returns {Observable<OpeningTransferenceOut>} An observable that emits the newly created opening transference.
     */
    postOpeningTransferences(body: OpeningTransferenceIn): Observable<OpeningTransferenceOut>;
    /**
     * Retrieves the receipt file associated with the given opening transference ID.
     *
     * @param {number} id - The ID of the opening transference whose receipt is to be retrieved.
     * @returns {Observable<ReceiptFileOut>} An observable that emits the receipt file data.
     */
    getOpeningTransferenceReceipt(id: number): Observable<ReceiptFileOut>;
    /**
     * Retrieves a deposit slip by its ID.
     * @param id - The unique identifier of the deposit slip to retrieve
     * @returns An Observable that emits the deposit slip data
     */
    getDepositSlip(id: number): Observable<DepositSlipOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiCashOperationsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiCashOperationsService>;
}

declare enum ViewSectionOption {
    SHIPMENT = "shipment",
    PICKUP = "pickup",
    EMPLOYEE_DHL = "employeeDhl",
    BILLING = "billing",
    CUSTOMER_RESTRICTION = "customerRestriction"
}

interface Country extends SymfonyModel {
    name: string;
    code: string;
    codeAndName: string;
    isoCode: string;
    codePhone: string;
    locale: string;
    locationType: LocationType;
    unit: Unit;
    timezone: string;
    hasImportService: boolean;
    phoneDigits: number;
    locationTypeFields: LocationTypeFields;
    postalCodeSuffixRegex: string;
    decimalPoint: number;
    max_quantity_document_piece: number;
    max_quantity_package_piece: number;
    weight_restriction_piece: number;
    restriction_shipment: number;
    restriction_dimension: number;
    max_declared_value: number;
    decimal_separator: string;
    thousands_separator: string;
    label_printer_name: string;
    receipt_printer_name: string;
    others_printer_name: string;
    territories: number[];
    use_billing?: boolean;
    translations: Translations;
}
interface LocationType extends SymfonyModel {
    code: string;
    name: string;
    priority: number;
}
interface LocationTypeFields {
    city: City;
    postalCode: PostalCode;
    suburb: Suburb;
}
interface City {
    enabled: boolean;
    required: boolean;
}
interface PostalCode {
    enabled: boolean;
    required: boolean;
}
interface Suburb {
    enabled: boolean;
    required: boolean;
}
interface Language extends SymfonyModel {
    code: string;
    name: string;
}
interface State extends SymfonyModel {
    country: Country;
    code: string;
    name: string;
}
interface IdentificationType extends SymfonyModel {
    code: string;
    countryId: number;
    identificationType: number | null;
    name: string;
    viewSection?: Record<ViewSectionOption, boolean>;
    regex: string[] | null;
    isExternalValidation: boolean;
}
interface OperationType extends SymfonyModel {
    code: string;
    name: string;
    translations?: Translations;
}
interface BoardingProcessStatus {
    id: number;
    code: string;
    createdAt: string;
    updatedAt: string;
}
interface ExtraCharge extends SymfonyModel {
    code: string;
    name: string;
    isDiscount: boolean;
    aggregated: boolean;
}
interface Region extends SymfonyModel {
    code: string;
    name: string;
    country: Country;
}
interface Zone extends SymfonyModel {
    code: string;
    name: string;
    country: Country;
}
interface ManagementArea extends SymfonyModel {
    name: string;
    country: Country;
}
interface CancellationReason extends SymfonyModel {
    code: string;
    name: string;
    eventReasonCode: string;
    countryId: number;
}
interface Currency extends SymfonyModel {
    code: string;
    name: string;
    symbol: string;
}
interface Currency extends SymfonyModel {
    code: string;
    name: string;
    symbol: string;
}
interface Unit extends SymfonyModel {
    name: string;
    weight: string;
    dimension: string;
}
interface Unit extends SymfonyModel {
    name: string;
    weight: string;
    dimension: string;
}
interface ShipmentScope extends SymfonyModel {
    code: string;
    name: string;
}
interface ShipmentContentType extends SymfonyModel {
    code: string;
    name: string;
}
interface GenericFolio extends SymfonyModel {
    countryId: number;
    code: string;
    customer: string;
    accountNumber: string;
    content: string;
    packaging: true;
    destinationFullName: string;
    destinationAddressLine1: string;
    destinationAddressLine2: string;
    destinationAddressLine3: string;
    destinationCountryId: number;
    destinationCountryCode: string;
    destinationPostalCode: string;
    destinationCityName: string;
    destinationCountyName: string;
    destinationStateCode: string;
    destinationPhoneCode: string;
    destinationPhoneNumber: string;
    destinationEmail: string;
    countryReferenceProductIds: number[];
    productLocalCodes: string;
}
interface Product extends SymfonyModel {
    globalCode: number;
    localCode: string;
    globalName: string;
    localName: string;
    isDocument: string;
    restrictedAccounts: {
        id: string;
        number: string;
        isActive: boolean;
    }[];
    discounts: [];
}
interface ShipmentIncomeType extends SymfonyModel {
    countryId: number;
    code: string;
    name: string;
}
interface UniqueFolio extends SymfonyModel {
    code: number;
    customer: string;
    content: string;
    kad: string | null;
    executive: string;
}
interface ShipmentGroup extends SymfonyModel {
    code: string;
    name: string;
}
interface ShipmentStatus extends SymfonyModel {
    code: string;
    description: string;
}
interface Question extends SymfonyModel {
    description: string;
    type: string;
    questionOrder: number;
    countryId: number;
    isRequiredValue: boolean;
}
interface Holiday extends SymfonyModel {
    date: string;
    description: string;
    country: Country;
}
interface BusinessPartyTraderType extends SymfonyModel {
    code: string;
    name: string;
    description: string | null;
    category: string | null;
    esbCode: string;
}
interface PackageLocation extends SymfonyModel {
    name: string;
}

type OperationTypesOut = {
    total: number;
    operationTypes: OperationType[];
};
interface IdentificationTypesOut {
    total: number;
    identificationTypes: IdentificationType[];
}
type IdentificationTypeOut = {
    IdentificationType: IdentificationType;
};
type IdentificationTypeIn = {
    code: string;
    countryId: number;
    identificationType?: number | null;
    name: string;
    viewSection: Record<ViewSectionOption, boolean>;
    regex: string[] | null;
    isExternalValidation?: boolean;
    isActive: boolean;
};
type ExtraChargesOut = {
    total: number;
    extracharges: ExtraCharge[];
};
type CountriesOut = {
    total: number;
    countries: Country[];
};
type CountryIn = {
    code: string;
    name: string;
    locationTypeId: number;
    unitId: number;
    timezone: string;
    hasImportService: boolean;
    isActive: boolean;
    isoCode: string;
    codePhone: string;
    phoneDigits: number;
};
type CountryOut = {
    country: Country;
};
type RegionsOut = {
    total: number;
    regions: Region[];
};
type ZonesOut = {
    total: number;
    zones: Zone[];
};
type ManagementAreasOut = {
    total: number;
    managementAreas: ManagementArea[];
};
type CancellationReasonsOut = {
    total: number;
    cancellationReasons: CancellationReason[];
};
type CancellationReasonIn = {
    code: string;
    name: string;
    eventReasonCode: string | null;
    isActive: boolean;
    countryId: number;
};
type CancellationReasonOut = {
    cancellationReason: CancellationReason;
};
type CurrenciesOut = {
    total: number;
    currencies: Currency[];
};
type CurrencyOut = {
    currency: Currency;
};
type LanguagesOut = {
    total: number;
    languages: Language[];
};
type UnitsOut = {
    total: number;
    units: Unit[];
};
type ShipmentScopesOut = {
    total: number;
    shipmentScopes: ShipmentScope[];
};
type ShipmentContentTypesOut = {
    total: number;
    shipmentContentTypes: ShipmentContentType[];
};
type ExtraChargeIn = {
    code: string;
    name: string;
    isDiscount: boolean;
    aggregated: boolean;
};
type ExtraChargeOut = {
    extraCharge: ExtraCharge;
};
type GenericFoliosOut = {
    total: number;
    genericFolios: GenericFolio[];
};
type GenericFolioIn = {
    accountNumber: string;
    code: string;
    content: string;
    countryReferenceProductIds: number[];
    customer: string;
    destinationAddressLine1: string;
    destinationAddressLine2: string;
    destinationAddressLine3: string;
    destinationCityName?: string;
    destinationCountryId: number;
    destinationCountyName?: string;
    destinationEmail: string;
    destinationFullName: string;
    destinationPhoneCode: string;
    destinationPhoneNumber: string;
    destinationPostalCode?: string;
    destinationStateCode?: string;
    isActive: boolean;
    packaging: boolean;
    countryId: number;
};
type GenericFolioOut = {
    genericFolio: GenericFolio;
};
type ProductIn = {
    globalCode: number;
    localCode: string;
    globalName: string;
    localName: string;
    isDocument: boolean;
};
type ProductOut = {
    product: Product;
};
type ShipmentIncomeTypesOut = {
    total: number;
    shipmentIncomeTypes: ShipmentIncomeType[];
};
type ShipmentIncomeTypeIn = {
    countryId: number;
    code: string;
    name: string;
    isActive: boolean;
};
type ShipmentIncomeTypeOut = {
    shipmentIncomeType: ShipmentIncomeType;
};
type UniqueFolioIn = {
    code: number;
    customer: string;
    content: string;
    kad: string | null;
    executive: string;
    isActive: boolean;
};
type UniqueFolioOut = {
    uniqueFolio: UniqueFolio;
};
type UniqueFoliosOut = {
    total: number;
    uniqueFolios: UniqueFolio[];
};
type ShipmentGroupsOut = {
    shipmentGroups: ShipmentGroup[];
    total: number;
};
type ShipmentStatusesOut = {
    shipmentStatuses: ShipmentStatus[];
    total: number;
};
type QuestionsOut = {
    questions: Question[];
    total: number;
};
type QuestionOut = {
    question: Question;
};
type QuestionIn = {
    description: string;
    type: 'marketing';
    questionOrder: number;
    isActive: boolean;
    countryId: number;
    isRequiredValue: boolean;
};
type HolidaysOut = {
    holidays: Holiday[];
    total: number;
};
type HolidayOut = {
    holiday: Holiday;
};
type HolidayIn = {
    date: string;
    description: string;
    countryId: number;
    isActive: boolean;
};
type IdentificationTypeNumberValidationIn = {
    identificationTypeId: number;
    identificationNumber: string;
    section: string;
};
type IdentificationTypeNumberValidationOut = {};
type BusinessPartyTraderTypesOut = {
    total: number;
    businessPartyTraderTypes: BusinessPartyTraderType[];
};
type PackageLocationsData = {
    total: number;
    packageLocations: PackageLocation[];
};

declare class ApiCatalogsService {
    private environments;
    private http;
    /**
     * Retrieves the URL for the reports API from the environment configurations.
     *
     * @return {string} The URL of the reports API.
     */
    get url(): string;
    /**
     * Retrieves the list of collection payments
     *
     * @param {QueryParams} params - The query parameters used to fetch the operation types.
     * @return {Observable<OperationTypesOut[]>} An observable that emits an array of operation type.
     */
    getOperationTypes(params: QueryParams): Observable<OperationTypesOut>;
    /**
     * Retrieves the list of identificatios types
     *
     * @param {QueryParams} params - The query parameters used to fetch the identification types.
     * @return {Observable<IdentificationTypesOut[]>} An observable that emits an array of identification type.
     */
    getIdentificationTypes(params: QueryParams): Observable<IdentificationTypesOut>;
    /**
     * Retrieve a single identification type by its id.
     *
     * Sends an HTTP GET request to the indentification type endpoint and returns an Observable that emits
     * the IdentificationTypeOut payload extracted from the API success envelope.
     *
     * @param id - The numeric identifier of the identification type to fetch.
     * @returns An Observable that emits the requested IdentificationTypeOut. The Observable will error
     *          if the HTTP request fails (for example network issues or non-2xx responses).
     */
    getIdentificationType(id: number): Observable<IdentificationTypeOut>;
    /**
     * Sends a POST request to create a new identification type and returns the created resource.
     *
     * The request payload is sent as an object with a `body` property containing the provided
     * IdentificationTypeIn value (i.e. { body: IdentificationTypeIn }). On success the HTTP response is expected
     * to follow the ApiSuccess<T> shape; the operator maps that response to the inner `data`
     * object and emits it as a IdentificationTypeOut.
     *
     * @param body - The identification type payload to create (IdentificationTypeIn).
     * @returns Observable<IdentificationTypeOut> that emits the created identification type on success.
     */
    postIdentificationType(body: IdentificationTypeIn): Observable<IdentificationTypeOut>;
    /**
     * Update a identification type by its ID.
     *
     * Sends an HTTP PUT to `${this.url}/identification-types/${id}` with the provided payload.
     * The request body is sent as an object with a `body` property containing the
     * `IdentificationTypeIn` data. The server response is expected to be an `ApiSuccess<IdentificationTypeOut>`
     * and this method returns an Observable that emits the unwrapped `IdentificationTypeOut`.
     *
     * @param id - The identifier of the identification type to update.
     * @param body - The update payload for the identification type.
     * @returns An Observable that emits the updated `IdentificationTypeOut` on success.
     */
    putIdentificationType(id: number, body: IdentificationTypeIn): Observable<IdentificationTypeOut>;
    /**
     * Delete a identification type by its ID.
     *
     * Sends an HTTP DELETE request to the backend endpoint `/identification-types/{id}` and
     * returns an Observable that emits the API response's `data` payload (typically an empty object).
     *
     * The implementation maps an ApiSuccess wrapper to its `data` property before emitting.
     *
     * @param id - The numeric identifier of the identification type to delete.
     * @returns An Observable that emits the deleted resource payload ({} expected) on success.
     *          The Observable will emit an error if the HTTP request fails.
     */
    deleteIdentificationType(id: number): Observable<{}>;
    /**
     * Sends a POST request to validate identification type number.
     *
     * The request payload is sent as an object with a `body` property containing the provided
     * IdentificationTypeNumberValidationIn value (i.e. { body: IdentificationTypeNumberValidationIn }). On success the HTTP response is expected
     * to follow the ApiSuccess<T> shape; the operator maps that response to the inner `data`
     * object and emits it as a IdentificationTypeNumberValidationOut.
     *
     * @param body - The identification type number validation payload to validate (IdentificationTypeNumberValidationIn).
     * @returns Observable<IdentificationTypeNumberValidationOut> that emits the validate status.
     */
    postIdentificationTypeNumberValidation(body: IdentificationTypeNumberValidationIn): Observable<IdentificationTypeNumberValidationOut>;
    /**
     * Fetches the extra charges based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the results.
     * @return {Observable<ExtraChargesOut>} An observable emitting the extra charges data.
     */
    getExtraCharges(params: QueryParams): Observable<ExtraChargesOut>;
    /**
     * Submits an extra charge request to the server and returns the created extra charge details.
     *
     * @param {ExtraChargeIn} body - The data for the extra charge to be created.
     * @return {Observable<ExtraChargeOut>} An observable that emits the details of the created extra charge.
     */
    postExtraCharge(body: ExtraChargeIn): Observable<ExtraChargeOut>;
    /**
     * Updates an extra charge entity with new data and returns the updated entity.
     *
     * @param {number} id - The unique identifier of the extra charge to update.
     * @param {ExtraChargeIn} body - The new data for the extra charge.
     * @return {Observable<ExtraChargeOut>} An observable emitting the updated extra charge entity.
     */
    putExtraCharge(id: number, body: ExtraChargeIn): Observable<ExtraChargeOut>;
    /**
     * Fetches a list of countries from the API.
     *
     * @param {QueryParams} params - The query parameters to be passed to the API request.
     * @return {Observable<CountriesOut>} An observable containing the list of countries.
     */
    getCountries(params: QueryParams): Observable<CountriesOut>;
    /**
     * Retrieves the details of a country based on its ID.
     *
     * @param {number} id - The identifier of the country to fetch.
     * @return {Observable<CountryOut>} An observable that emits the country data.
     */
    getCountry(id: number): Observable<CountryOut>;
    /**
     * Updates the details of a specific country by its ID.
     *
     * @param {number} id - The unique identifier of the country to be updated.
     * @param {CountryIn} body - The data to update the country with.
     * @return {Observable<CountryOut>} An observable that emits the updated country data.
     */
    putCountry(id: number, body: CountryIn): Observable<CountryOut>;
    /**
     * Fetches a list of regions based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter the regions.
     * @return {Observable<RegionsOut>} An observable that emits the list of regions.
     */
    getRegions(params: QueryParams): Observable<RegionsOut>;
    /**
     * Fetches the zones data based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter the zones data.
     * @return {Observable<ZonesOut>} An observable that emits the fetched zones data.
     */
    getZones(params: QueryParams): Observable<ZonesOut>;
    /**
     * Fetches the management areas based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the management areas.
     * @return {Observable<ManagementAreasOut>} An observable that emits the management areas data.
     */
    getManagementAreas(params: QueryParams): Observable<ManagementAreasOut>;
    /**
     * Retrieves cancellation reasons from the server based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the cancellation reasons.
     * @return {Observable<CancellationReasonsOut>} An observable containing the retrieved cancellation reasons.
     */
    getCancellationReasons(params: QueryParams): Observable<CancellationReasonsOut>;
    /**
     * Sends a cancellation reason to the server.
     *
     * @param {CancellationReasonIn} body - The cancellation reason object to be sent.
     * @return {Observable<CancellationReasonOut>} An observable containing the server's response with the processed cancellation reason.
     */
    postCancellationReason(body: CancellationReasonIn): Observable<CancellationReasonOut>;
    /**
     * Updates the cancellation reason for the specified ID with the provided data.
     *
     * @param {number} id - The unique identifier of the cancellation reason to update.
     * @param {CancellationReasonIn} body - The details of the cancellation reason to be updated.
     * @return {Observable<CancellationReasonOut>} An observable containing the updated cancellation reason.
     */
    putCancellationReason(id: number, body: CancellationReasonIn): Observable<CancellationReasonOut>;
    /**
     * Retrieves a list of currencies based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to customize the currency retrieval request.
     * @return {Observable<CurrenciesOut>} An observable that emits the retrieved currencies data.
     */
    getCurrencies(params: QueryParams): Observable<CurrenciesOut>;
    /**
     * Retrieves currency information by ID.
     * @param id - The unique identifier of the currency to retrieve.
     * @returns An Observable that emits the currency data.
     */
    getCurrency(id: number): Observable<CurrencyOut>;
    /**
     * Fetches the list of available languages based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to pass with the HTTP request.
     * @return {Observable<LanguagesOut>} An observable that emits the available languages.
     */
    getLanguages(params: QueryParams): Observable<LanguagesOut>;
    /**
     * Fetches the available units from the API based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the units being fetched.
     * @return {Observable<UnitsOut>} An observable that emits the retrieved units data.
     */
    getUnits(params: QueryParams): Observable<UnitsOut>;
    /**
     * Retrieves the shipment scopes based on the provided query parameters.
     *
     * @param {QueryParams} params The query parameters to filter or modify the request for shipment scopes.
     * @return {Observable<ShipmentScopesOut>} An observable that emits the shipment scopes data.
     */
    getShipmentScopes(params: QueryParams): Observable<ShipmentScopesOut>;
    /**
     * Fetches the available shipment content types based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the shipment content types.
     * @return {Observable<ShipmentContentTypesOut>} An observable that emits the shipment content types data.
     */
    getShipmentContentTypes(params: QueryParams): Observable<ShipmentContentTypesOut>;
    /**
     * Fetches a list of generic folios based on the given query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter the generic folios.
     * @return {Observable<GenericFoliosOut>} An observable containing the fetched generic folios.
     */
    getGenericFolios(params: QueryParams): Observable<GenericFoliosOut>;
    /**
     * Sends a POST request to create or update a generic folio.
     *
     * @param {GenericFolioIn} body - The payload containing the details of the generic folio to be created or updated.
     * @return {Observable<GenericFolioOut>} An observable containing the response data of the created or updated generic folio.
     */
    postGenericFolio(body: GenericFolioIn): Observable<GenericFolioOut>;
    /**
     * Updates a generic folio with the specified ID using the provided data.
     *
     * @param {number} id - The unique identifier of the generic folio to update.
     * @param {GenericFolioIn} body - The data to update the generic folio with.
     * @return {Observable<GenericFolioOut>} An observable containing the updated generic folio.
     */
    putGenericFolio(id: number, body: GenericFolioIn): Observable<GenericFolioOut>;
    /**
     * Sends a PUT request to update a Generic Folio resource with the specified ID and body data, and returns the updated resource.
     *
     * @param {number} id - The unique identifier of the Generic Folio to be updated.
     * @param {Partial<GenericFolioIn>} body - The partial data representing the changes to be applied to the Generic Folio.
     * @return {Observable<GenericFolioOut>} An observable containing the updated Generic Folio resource.
     */
    pathGenericFolio(id: number, body: Partial<GenericFolioIn>): Observable<GenericFolioOut>;
    /**
     * Sends a POST request to create a new product.
     *
     * @param {ProductIn} body - The product data to be sent in the request body.
     * @return {Observable<ProductOut>} An observable emitting the created product data.
     */
    postProduct(body: ProductIn): Observable<ProductOut>;
    /**
     * Updates an existing product with the given ID using the provided data.
     *
     * @param {number} id - The unique identifier of the product to update.
     * @param {ProductIn} body - The product data to update.
     * @return {Observable<ProductOut>} An observable containing the updated product data.
     */
    putProduct(id: number, body: ProductIn): Observable<ProductOut>;
    /**
     * Retrieves a list of shipment income types based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the shipment income types.
     * @return {Observable<ShipmentIncomeTypesOut>} An observable containing the shipment income types data.
     */
    getShipmentIncomeTypes(params: QueryParams): Observable<ShipmentIncomeTypesOut>;
    /**
     * Sends a POST request to create a new shipment income type.
     *
     * @param {ShipmentIncomeTypeIn} body The payload containing the details of the shipment income type to be created.
     * @return {Observable<ShipmentIncomeTypeOut>} An observable that emits the created shipment income type data.
     */
    postShipmentIncomeType(body: ShipmentIncomeTypeIn): Observable<ShipmentIncomeTypeOut>;
    /**
     * Updates the shipment income type with the specified ID.
     *
     * @param {number} id - The identifier of the shipment income type to update.
     * @param {ShipmentIncomeTypeIn} body - The data to update the shipment income type with.
     * @return {Observable<ShipmentIncomeTypeOut>} An observable emitting the updated shipment income type.
     */
    putShipmentIncomeType(id: number, body: ShipmentIncomeTypeIn): Observable<ShipmentIncomeTypeOut>;
    /**
     * Retrieves a list of unique folios based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter and fetch unique folios.
     * @return {Observable<UniqueFoliosOut>} An observable that emits the unique folios data.
     */
    getUniqueFolios(params: QueryParams): Observable<UniqueFoliosOut>;
    /**
     * Sends a POST request to create a unique folio.
     *
     * @param {UniqueFolioIn} body - The data object containing details for the unique folio to be created.
     * @return {Observable<UniqueFolioOut>} An observable that emits the created unique folio details.
     */
    postUniqueFolio(body: UniqueFolioIn): Observable<UniqueFolioOut>;
    /**
     * Updates a unique folio with the given data using the provided ID.
     *
     * @param {number} id - The ID of the unique folio to be updated.
     * @param {UniqueFolioIn} body - The payload containing the details of the unique folio to update.
     * @return {Observable<UniqueFolioOut>} An observable that emits the updated unique folio.
     */
    putUniqueFolio(id: number, body: UniqueFolioIn): Observable<UniqueFolioOut>;
    /**
     * Updates a unique folio by its identifier with the provided data.
     *
     * @param {number} id - The identifier of the unique folio to update.
     * @param {Partial<UniqueFolioIn>} body - The partial data of the unique folio to update.
     * @return {Observable<UniqueFolioOut>} An observable emitting the updated unique folio data.
     */
    pathUniqueFolio(id: number, body: Partial<UniqueFolioIn>): Observable<UniqueFolioOut>;
    /**
     * Retrieves shipment groups based on the provided query parameters.
     *
     * @param params - The query parameters to filter the shipment groups.
     * @returns An Observable that emits the shipment groups data.
     */
    getShipmentGroups(params: QueryParams): Observable<ShipmentGroupsOut>;
    /**
     * Retrieves the shipment statuses from the API.
     *
     * @param params - The query parameters to filter or modify the request.
     * @returns An Observable that emits the shipment statuses output.
     */
    getShipmentStatuses(params: QueryParams): Observable<ShipmentStatusesOut>;
    /**
     * Fetches questions from the catalogs API.
     *
     * Sends an HTTP GET request to `${this.url}/questions` using the supplied query parameters
     * and returns the unwrapped payload (`data`) from the API response.
     *
     * @param params - Query parameters to include in the request (e.g. paging, filters, sorting).
     * @returns An Observable that emits the QuestionsOut payload (the `data` field from ApiSuccess<QuestionsOut>).
     */
    getQuestions(params: QueryParams): Observable<QuestionsOut>;
    /**
     * Retrieve a single question by its id.
     *
     * Sends an HTTP GET request to the questions endpoint and returns an Observable that emits
     * the QuestionOut payload extracted from the API success envelope.
     *
     * @param id - The numeric identifier of the question to fetch.
     * @returns An Observable that emits the requested QuestionOut. The Observable will error
     *          if the HTTP request fails (for example network issues or non-2xx responses).
     */
    getQuestion(id: number): Observable<QuestionOut>;
    /**
     * Sends a POST request to create a new question and returns the created resource.
     *
     * The request payload is sent as an object with a `body` property containing the provided
     * QuestionIn value (i.e. { body: QuestionIn }). On success the HTTP response is expected
     * to follow the ApiSuccess<T> shape; the operator maps that response to the inner `data`
     * object and emits it as a QuestionOut.
     *
     * @param body - The question payload to create (QuestionIn).
     * @returns Observable<QuestionOut> that emits the created question on success.
     */
    postQuestion(body: QuestionIn): Observable<QuestionOut>;
    /**
     * Update a question by its ID.
     *
     * Sends an HTTP PUT to `${this.url}/questions/${id}` with the provided payload.
     * The request body is sent as an object with a `body` property containing the
     * `QuestionIn` data. The server response is expected to be an `ApiSuccess<QuestionOut>`
     * and this method returns an Observable that emits the unwrapped `QuestionOut`.
     *
     * @param id - The identifier of the question to update.
     * @param body - The update payload for the question.
     * @returns An Observable that emits the updated `QuestionOut` on success.
     */
    putQuestion(id: number, body: QuestionIn): Observable<QuestionOut>;
    /**
     * Deletes a question by its ID.
     *
     * Sends an HTTP DELETE request to the backend endpoint `/questions/{id}` and
     * returns an Observable that emits the API response's `data` payload (typically an empty object).
     *
     * The implementation maps an ApiSuccess wrapper to its `data` property before emitting.
     *
     * @param id - The numeric identifier of the question to delete.
     * @returns An Observable that emits the deleted resource payload ({} expected) on success.
     *          The Observable will emit an error if the HTTP request fails.
     */
    deleteQuestion(id: number): Observable<{}>;
    /**
     * Fetches holidays from the catalogs API.
     *
     * Sends an HTTP GET request to `${this.url}/holidays` using the supplied query parameters
     * and returns the unwrapped payload (`data`) from the API response.
     *
     * @param params - Query parameters to include in the request (e.g. paging, filters, sorting).
     * @returns An Observable that emits the HolidaysOut payload (the `data` field from ApiSuccess<HolidaysOut>).
     */
    getHolidays(params: QueryParams): Observable<HolidaysOut>;
    /**
     * Retrieve a single holiday by its id.
     *
     * Sends an HTTP GET request to the holidays endpoint and returns an Observable that emits
     * the HolidayOut payload extracted from the API success envelope.
     *
     * @param id - The numeric identifier of the holiday to fetch.
     * @returns An Observable that emits the requested HolidayOut. The Observable will error
     *          if the HTTP request fails (for example network issues or non-2xx responses).
     */
    getHoliday(id: number): Observable<HolidayOut>;
    /**
     * Sends a POST request to create a new holiday and returns the created resource.
     *
     * The request payload is sent as an object with a `body` property containing the provided
     * HolidayIn value (i.e. { body: HolidayIn }). On success the HTTP response is expected
     * to follow the ApiSuccess<T> shape; the operator maps that response to the inner `data`
     * object and emits it as a HolidayOut.
     *
     * @param body - The holiday payload to create (HolidayIn).
     * @returns Observable<HolidayOut> that emits the created holiday on success.
     */
    postHoliday(body: HolidayIn): Observable<HolidayOut>;
    /**
     * Update a holiday by its ID.
     *
     * Sends an HTTP PUT to `${this.url}/holidays/${id}` with the provided payload.
     * The request body is sent as an object with a `body` property containing the
     * `HolidayIn` data. The server response is expected to be an `ApiSuccess<HolidayOut>`
     * and this method returns an Observable that emits the unwrapped `HolidayOut`.
     *
     * @param id - The identifier of the holiday to update.
     * @param body - The update payload for the holiday.
     * @returns An Observable that emits the updated `HolidayOut` on success.
     */
    putHoliday(id: number, body: HolidayIn): Observable<HolidayOut>;
    /**
     * Deletes a question by its ID.
     *
     * Sends an HTTP DELETE request to the backend endpoint `/questions/{id}` and
     * returns an Observable that emits the API response's `data` payload (typically an empty object).
     *
     * The implementation maps an ApiSuccess wrapper to its `data` property before emitting.
     *
     * @param id - The numeric identifier of the question to delete.
     * @returns An Observable that emits the deleted resource payload ({} expected) on success.
     *          The Observable will emit an error if the HTTP request fails.
     */
    deleteHoliday(id: number): Observable<{}>;
    /**
     * Retrieves a list of business party trader types
     * @param {QueryParams} params - Query parameters for filtering and pagination (optional)
     * @returns {Observable<BusinessPartyTraderTypesOut>} Observable containing the list of trader types
     */
    getBusinessPartyTraderTypes(params: QueryParams): Observable<BusinessPartyTraderTypesOut>;
    /**
     * Retrieves package locations based on the provided query parameters.
     * @param params - Query parameters to filter or configure the package locations request
     * @returns An Observable that emits the package locations data
     */
    getPackageLocations(params: QueryParams): Observable<PackageLocationsData>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiCatalogsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiCatalogsService>;
}

type AuthLoginIn = {
    username: string;
    password: string;
    role?: number;
    system_name?: string;
};
type AuthLoginOut = {
    access_token: string;
    token_type: string;
    expires_in: number;
};
type AuthUserLoginIn = {
    username: string;
};
type SessionIn = {
    modelType: string;
    modelId: number;
    token?: string;
};
type SessionOut = {
    session: Session;
};
type PutUsersIn = {
    user: User;
};
type PutUsersOut = {
    user: User;
};
type GetUserOut = {
    user: User;
};
type GetUsersOut = {
    users: User[];
    total: number;
};
type AuthMeOut = {
    user: UserMe;
};
type ChangeLanguageIn = {
    languageId: number;
};
type RolesOut = {
    roles: Role[];
    total: number;
};
type Pivot = {
    role_id: number;
    permission_id: number;
} | {
    module_id: string;
    permission_id: string;
};
type RoleOut = {
    role: Role;
};
type RoleIn = {
    name: string;
    role_type_id: number;
    company_country_id: number;
    regional_country_id?: number[] | null;
    is_active: boolean;
    permissions?: string[];
};
type RoleTypesOut = {
    role_types: RoleType[];
    total: number;
};
type ModulesOut = {
    modules: Module[];
    total: number;
};

interface Session extends LaravelModel {
    model_type: string;
    model_id: number;
    status: string;
    last_activity: string;
    user_agent: string;
    gmt_offset: string;
    opening_id: number;
    user_id: number;
    installation_id: number;
    locale: string | null;
    decimal_point: number;
    country_id: number;
    company_id: number;
    company_country_id: number;
    location_id: number;
    country_reference_currency_id: number;
    location_employee_id: number;
}
interface Role extends LaravelModel {
    name: string;
    guard_name: string;
    company_country_id: number;
    role_type_id: number;
    regional_country_id: number | null;
    role_type: RoleType;
    permissions?: Permission[];
}
interface RoleType extends LaravelModel {
    name: string;
    level: number;
}
interface Permission extends LaravelModel {
    name: string;
    guard_name: string;
    description: string;
    is_default: boolean;
    pivot: Pivot;
}
interface User extends LaravelModel {
    name: string;
    username: string;
    model_type: string;
    model_id: number;
    auth_type: string;
    language_id: number;
    email: string;
    roles: Role[];
}
interface UserMe extends Omit<User, 'roles'> {
    permissions: string[];
    session: Session | null;
    role: Role;
}
interface Module extends LaravelModel {
    name: string;
    code: string;
    module_type_id: number;
    module_type: ModuleType;
    permissions: Permission[];
}
interface ModuleType extends LaravelModel {
    name: string;
    description: string;
}

interface Account extends LaravelModel {
    number: string;
    description: string | null;
    account_type_id: number;
    account_type: AccountType;
    country_id: number;
    domestic_approved: boolean;
}
interface AccountCategory extends LaravelModel {
    name: string;
}
interface AccountType extends LaravelModel {
    name: string;
    account_category_id: number;
    account_category?: AccountCategory;
}
interface Company extends LaravelModel {
    id: number;
    created_at: string;
    updated_at: string;
    name: string;
    contact_name: string;
    contact_email: string;
    contact_phone: string;
    state: string;
    city: string;
    county_name: string;
    zip_code: string;
    address1: string;
    address2: string;
    address3: string;
    is_active: boolean;
}
interface CompanyCountry extends LaravelModel {
    company_id: number;
    country_id: number;
    headquarters_city_code: string;
    lp_code: string;
    company: Company;
    contact_name: string;
    contact_email: string;
    contact_phone_code: string;
    contact_phone_number: string;
    state: string;
    city: string;
    zip_code: string;
    county_name: string;
    address1: string;
    address2: string;
    address3: string;
}
interface CompanyCountryTax extends LaravelModel {
    code: string;
    name: string;
    percentage: number;
    company_country_id: number;
    shipment_scopes: number[];
    base_percentage: number;
    tax_type: string;
}
interface CountryCurrencyRate extends CountryReferenceCurrency {
    rate: string;
}
interface CountryReference extends LaravelModel {
    language_id: number;
    decimal_point: number;
    decimal_separator: string;
    thousands_separator: string;
    use_billing: boolean;
    use_payments: boolean;
    restricted_import_countries: number[];
    currency_id: number;
    max_quantity_document_piece: number;
    max_quantity_package_piece: number;
    weight_restriction_piece: number;
    restriction_shipment: number;
    restriction_dimension: number;
    max_declared_value: number;
    territories: number[];
    some_openings: boolean;
    locale: string;
    country_id: number;
    label_printer_name: string;
    receipt_printer_name: string;
    others_printer_name: string;
    country: Country;
    sanctioned_countries: number[] | null;
}
interface CountryReferenceCurrency extends LaravelModel {
    country_id: number;
    currency_id: number;
    is_local: boolean;
    can_transact: boolean;
    code: string;
    name: string;
    is_default: boolean;
    is_declared_insured: boolean;
    currency: Currency;
}
interface CountryReferenceExtraCharge extends LaravelModel {
    country_id: number;
    extra_charge_id: number;
    local_availability: boolean;
    mandatory: boolean;
    selected: boolean;
    shipment_scopes: number[];
    shipment_content_types: number[];
    value_local: number;
    value_usd: number;
}
interface ExtraChargeEntity extends LaravelModel {
    code: string;
    name: string;
}
interface Employee extends LaravelModel {
    auth_type: string;
    company_id: number;
    company: Company;
    country_id: number;
    email: string;
    external: boolean;
    last_name: string;
    locations: Location[];
    name: string;
    number: string;
    phone_code: string;
    phone_number: string;
    roles: Role[];
    username: string;
}
interface Exchange extends LaravelModel {
    company_country_currency_id: number;
    valid_since: string;
    valid_until: string | null;
    value: string;
    type: string;
}
interface CountryExchange extends Exchange {
    currency: Currency;
    country_reference_currency: CountryReferenceCurrency;
}
interface Installation extends LaravelModel {
    system_id: number;
    mac_address: string;
    ip_address: string;
    location_id: number;
    number: number;
    system: System;
    customer_screen: boolean;
    epod_capture: boolean;
    cx_survey: boolean;
    customer_flow: boolean;
    promotional_content: boolean;
}
interface Location extends LaravelModel {
    accounts: Account[];
    address1: string;
    address2: string;
    address3: string;
    billing_code: string | null;
    city_name: string;
    commission_account: string | null;
    company_country: CompanyCountry;
    company_country_id: number;
    contact_name: string | null;
    country_region: null;
    country_region_id: number | null;
    country_zone: null;
    country_zone_id: number | null;
    county_name: string;
    default_account_id: number | null;
    email: string | null;
    etools_auto_billing_enabled: boolean;
    extra_fields: {
        [key: string]: string | number | boolean | null;
    };
    facility_code: string;
    facility_id: number;
    gmt_offset: string;
    google_maps_id: string;
    iata_code: string;
    is_occurs: boolean;
    location_code: string | null;
    locker_enabled: boolean;
    management_area: null;
    management_area_id: number | null;
    name: string;
    phone_code: string;
    phone_number: string;
    queue_manager_enabled: boolean;
    route_number: string;
    service_area_code: string;
    service_point_id: string;
    state: State;
    state_code: string | null;
    state_id: number;
    state_name: string;
    supervisor: Employee;
    type: string;
    zip_code: string;
}
interface LocationEmployee extends LaravelModel {
    location_id: number;
    employee_id: number;
    is_active: boolean;
    is_supervisor: boolean;
    employee: Employee;
    location: Location;
}
interface Parameter extends LaravelModel {
    name: string;
    type: string;
    regex: string;
    description: string;
    value: string | number | boolean | null | {
        [key: string]: (string | number | boolean | null)[];
    };
    parameter_type_id: number;
}
interface ParameterConfig {
    id: number;
    level: number;
    model_type: string | null;
    model_id: number | null;
    parameter_id: number;
    name: string;
    value: string | number | boolean | null | {
        [key: string]: (string | number | boolean | null)[];
    };
    parameter: Parameter;
}
interface WorkflowConfig {
    id: number;
    system_id: number;
    level: string;
    model_type: string;
    model_id: number;
    name: string;
    page_id: number;
    page_name: string;
    enabled: boolean;
}
interface EmployeeCustomerDhl extends LaravelModel {
    identification_type_id: number;
    identification_type_value: string;
    name: string;
    last_name: string;
    address: string;
    phone_code: string;
    phone_number: string;
    phone_full?: {
        code: string;
        number: string;
        country_code: string;
    };
    email: string;
    country_id: number;
    employee_id: number | null;
    identification_type: IdentificationType;
}
interface BoardingProcess {
    id: number;
    boarding_process_type_id: number;
    status_id: number;
    is_finished: boolean;
    start_date_time: string;
    end_date_time: string;
    created_at: string;
    updated_at: string;
    status: BoardingProcessStatus;
    boarding_process_histories: BoardingProcessHistory[];
}
interface BoardingProcessHistory {
    id: number;
    boarding_process_id: number;
    status_id: number;
    messages: string[];
    created_at: string;
    updated_at: string;
}
interface System extends LaravelModel {
    name: string;
    type: string;
    configuration: {
        [key: string]: string;
    };
    can_workflow_config: boolean;
}
interface CountryReferenceProduct extends LaravelModel {
    country_id: number;
    product_id: number;
    local_name: string;
    min_weight: number;
    max_weight: number;
    insurance: number;
    business_letter: boolean;
    packaging: boolean;
    anti_drug_letter: boolean;
    max_declared_value: number;
    shipment_groups: number[];
    shipment_scopes: number[];
    shipment_content_types: number[];
    is_prepaid_dropoff: boolean;
    product: Product;
}
interface ProductEntity extends LaravelModel {
    global_code: string;
    local_code: string;
    global_name: string;
    local_name: string;
}
interface TDXAccountSetting extends LaravelModel {
    location_id: number;
    account_id: number;
    product_id: number;
    product_global_code_name: string;
    product_local_code_name: string;
    account: AccountToTDX;
}
interface AccountToTDX extends ActiveLessLaravelModel {
    number: string;
    description: string | null;
    account_type_id: number;
    country_id: number;
}
interface SupplyEntity extends LaravelModel {
    name: string;
    description: null | string;
    country_id: number;
    enabled_for_dropoff: boolean;
    supply_type: SupplyEntityType;
    supply_packing: SupplyEntityPacking;
}
interface SupplyEntityType extends LaravelModel {
    name: string;
}
interface SupplyEntityPacking {
    value: number;
    weight: number;
    height: number;
    depth: number;
    width: number;
    emobile_code: null | string;
    created_at: string;
    updated_at: string;
}
interface AccountLocationId {
    location_id: number;
}
interface AccountCompanyCountry {
    company_country_id: number;
    locations: AccountLocationId[];
}
interface AccountCompanyCountryLocation extends ApiModel {
    company_country_id: number;
    account_id: number;
    account_company_country_locations: AccountLocation[];
}
interface AccountLocation extends ApiModel, AccountLocationId {
}
interface AccountWithDefault extends Account {
    is_default: boolean;
}
interface AccountWithLocations extends Account {
    account_company_countries: AccountCompanyCountryLocation[];
    country: CountryAccount;
}
interface PostalCodeFormat extends SymfonyModel {
    format: string;
    significantChars: number;
    regex: string;
}
interface CountryAccount {
    id: number;
    code: string;
    name: string;
    timezone: string;
    hasImportService: boolean;
    isActive: boolean;
    isoCode: string;
    codePhone: string;
    phoneDigits: string | null;
    createdAt: string;
    updatedAt: string;
    locationType: LocationType;
    unit: Unit;
    locationTypeFields: LocationTypeFields;
    postalCodeFormats: PostalCodeFormat[];
    translations: Translations;
}

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

declare class ApiCompaniesService {
    private environments;
    private http;
    /**
     * Retrieves the URL for the companies API from the environment configurations.
     *
     * @return {string} The URL of the companies API.
     */
    get url(): string;
    /**
     * Fetches the installations based on the provided query parameters.
     *
     * @param {QueryParams} params - The parameters used to filter the installations query.
     * @return {Observable<InstallationsOut>} An observable that emits the installation's data.
     */
    getInstallations(params: QueryParams): Observable<InstallationsOut>;
    /**
     * Retrieves the installation details based on the given installation ID.
     *
     * @param {number} id - The unique identifier of the installation to retrieve.
     * @returns {Observable<InstallationOut>} An observable of the installation details.
     */
    getInstallation(id: number): Observable<InstallationOut>;
    /**
     * Sends a post-installation request to the server and retrieves the installation details.
     *
     * @param {InstallationIn} body - The installation details to be sent in the request body.
     * @return {Observable<InstallationOut>} An observable that emits the response containing installation output details.
     */
    postInstallation(body: InstallationIn): Observable<InstallationOut>;
    /**
     * Updates an existing installation record by its ID.
     *
     * @param id The unique identifier of the installation to update.
     * @param body The data payload containing the updated installation information.
     * @return An observable that emits the updated installation data upon a successful update.
     */
    putInstallation(id: number, body: InstallationIn): Observable<InstallationOut>;
    /**
     * Deletes an installation by its unique identifier.
     *
     * @param {number} id - The unique identifier of the installation to be deleted.
     * @return {Observable<{}>} An observable that emits the response after the installation is deleted.
     */
    deleteInstallation(id: number): Observable<{}>;
    /**
     * Retrieves a list of locations based on the provided query parameters.
     *
     * @param {QueryParams} params - The parameters to use for querying locations.
     * @return {Observable<LocationsOut>} An observable that emits the location's data.
     */
    getLocations(params: QueryParams): Observable<LocationsOut>;
    /**
     * Fetches the location details for a given location ID.
     *
     * @param {number} id - The unique identifier of the location.
     * @return {Observable<LocationOut>} An Observable containing the location details.
     */
    getLocation(id: number): Observable<LocationOut>;
    /**
     * Sends a location object to the server and returns the created location data.
     *
     * @param {LocationIn} body - The location input object to be sent in the request body.
     * @return {Observable<LocationOut>} An observable emitting the created location output object.
     */
    postLocation(body: LocationIn): Observable<LocationOut>;
    /**
     * Updates the location information for the specified ID.
     *
     * @param {number} id - The unique identifier of the location to be updated.
     * @param {LocationIn} body - The updated location data to be sent in the request body.
     * @return {Observable<LocationOut>} An observable containing the updated location information.
     */
    putLocation(id: number, body: LocationIn): Observable<LocationOut>;
    /**
     * Deletes a location by its unique identifier.
     *
     * @param {number} id - The unique identifier of the location to be deleted.
     * @return {Observable<{}>} An observable that emits an empty object upon successful deletion.
     */
    deleteLocation(id: number): Observable<{}>;
    /**
     * Retrieves a list of active supply entities.
     *
     * @param {QueryParams} params - The query parameters to filter supply entities.
     * @return {Observable<SupplyEntitiesOut>} Observable emitting supply entities data.
     */
    getSupplyEntitiesActives(params: QueryParams): Observable<SupplyEntitiesOut>;
    /**
     * Retrieves supply entities based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter and fetch the supply entities.
     * @return {Observable<SupplyEntitiesOut>} An observable that emits the supply entities data.
     */
    getSupplyEntities(params: QueryParams): Observable<SupplyEntitiesOut>;
    /**
     * Sends supply entities information to the server and receives the processed supply entities data in response.
     *
     * @param {SupplyEntitiesIn} body - The supply entities data to be sent to the server.
     * @return {Observable<SupplyEntitiesOut>} An observable containing the processed supply entities data.
     */
    putSupplyEntities(body: SupplyEntitiesIn): Observable<SupplyEntitiesOut>;
    /**
     * Fetches a list of employees based on the specified query parameters.
     *
     * @param {QueryParams} params - The parameters to filter and sort the employees.
     * @return {Observable<EmployeesOut>} An observable that emits the list of employees.
     */
    getEmployees(params: QueryParams): Observable<EmployeesOut>;
    /**
     * Fetches an employee's details based on the provided employee ID.
     *
     * @param {number} id - The unique identifier of the employee.
     * @return {Observable<EmployeeOut>} An observable that emits the employee's details.
     */
    getEmployee(id: number): Observable<EmployeeOut>;
    /**
     * Sends a POST request to create a new employee record.
     *
     * @param {EmployeeIn} body - The data of the employee to be created.
     * @return {Observable<EmployeeOut>} An observable containing the created employee data.
     */
    postEmployee(body: EmployeeIn): Observable<EmployeeOut>;
    /**
     * Updates an existing employee record with the specified data.
     *
     * @param {number} id - The unique identifier of the employee to be updated.
     * @param {EmployeeIn} body - The employee data to update the record with.
     * @return {Observable<EmployeeOut>} An observable containing the updated employee data.
     */
    putEmployee(id: number, body: EmployeeIn): Observable<EmployeeOut>;
    /**
     * Updates an employee with the specified ID using the provided partial data.
     * @param id - The unique identifier of the employee to update
     * @param body - Partial employee data containing the fields to update
     * @returns An Observable that emits the updated employee data
     */
    patchEmployee(id: number, body: Partial<EmployeeIn>): Observable<EmployeeOut>;
    /**
     * Enable an employee with the specified ID.
     * @param id - The unique identifier of the employee to update
     * @returns An Observable that emits the enabled employee data
     */
    patchEmployeeEnable(id: number): Observable<EmployeeOut>;
    /**
     * Deletes an employee based on the provided ID.
     *
     * @param {number} id - The unique identifier of the employee to delete.
     * @return {Observable<{}>} An observable containing the response data after the employee is deleted.
     */
    deleteEmployee(id: number): Observable<{}>;
    /**
     * Retrieves the list of employees for a specified location based on provided query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter and retrieve the location employees.
     * @returns {Observable<LocationEmployeesOut>} An observable that emits the list of employees for the specified location.
     */
    getLocationEmployees(params: QueryParams): Observable<LocationEmployeesOut>;
    /**
     * Fetches the location employee details for a given employee ID.
     *
     * @param {number} id - The unique identifier of the employee whose location details are to be retrieved.
     * @return {Observable<LocationEmployeeOut>} An observable containing the location employee details.
     */
    getLocationEmployee(id: number): Observable<LocationEmployeeOut>;
    /**
     * Deletes a specific location employee by their unique identifier.
     *
     * @param {number} id - The unique identifier of the employee to be deleted.
     * @return {Observable<{}>} - An observable emitting the server's response after the deletion.
     */
    deleteLocationEmployee(id: number): Observable<{}>;
    /**
     * Sends a batch of location-employee associations to the server for processing.
     *
     * @param {LocationEmployeeBatchIn} body - The object containing a batch of location-employee data to be posted.
     * @return {Observable<EmployeeOut>} An observable emitting the processed employee data from the server's response.
     */
    postLocationEmployeeBatch(body: LocationEmployeeBatchIn): Observable<EmployeeOut>;
    /**
     * Retrieves a list of countries where the company operates.
     *
     * @param {QueryParams} params - The query parameters for the API request.
     * @return {Observable<CompanyCountriesOut>} An observable containing the list of company countries.
     */
    getCompanyCountries(params: QueryParams): Observable<CompanyCountriesOut>;
    /**
     * Retrieves the country information for a specified company by its ID.
     *
     * @param {number} id - The unique identifier of the company.
     * @return {Observable<CompanyCountryOut>} An observable containing the country information of the company.
     */
    getCompanyCountry(id: number): Observable<CompanyCountryOut>;
    /**
     * Sends a request to update or create a company country entry on the server.
     *
     * @param {CompanyCountryIn} body The data object representing the company country information to be sent to the server.
     * @return {Observable<CompanyCountryOut>} An observable containing the server response with the updated or created company country data.
     */
    postCompanyCountry(body: CompanyCountryIn): Observable<CompanyCountryOut>;
    /**
     * Updates the country information for a specific company.
     *
     * @param {number} id - The unique identifier of the company whose country information needs to be updated.
     * @param {CompanyCountryIn} body - The updated country information to be applied to the company.
     * @return {Observable<CompanyCountryOut>} An observable that emits the updated company country information.
     */
    putCompanyCountry(id: number, body: CompanyCountryIn): Observable<CompanyCountryOut>;
    /**
     * Deletes a company-country association by its unique identifier.
     *
     * @param {number} id - The unique identifier of the company-country record to be deleted.
     * @return {Observable<{}>} An observable emitting the result of the delete operation.
     */
    deleteCompanyCountry(id: number): Observable<{}>;
    /**
     * Fetches the reference currencies for a given country.
     *
     * @param {QueryParams} params - The query parameters to include in the request.
     * @return {Observable<CountryReferenceCurrenciesOut>} The observable containing the country reference currencies data.
     */
    getCountryReferenceCurrencies(params: QueryParams): Observable<CountryReferenceCurrenciesOut>;
    /**
     * Retrieves the reference currency details for a specific country using its ID.
     *
     * @param {number} id - The unique identifier of the country.
     * @return {Observable<CountryReferenceCurrencyOut>} An observable emitting the country's reference currency details.
     */
    getCountryReferenceCurrency(id: number): Observable<CountryReferenceCurrencyOut>;
    /**
     * Retrieves a list of currencies for different countries along with their current exchange rates.
     *
     * @param {QueryParams} params - The query parameters used to fetch the country reference currencies.
     * @return {Observable<CountryCurrencyRate[]>} An observable that emits an array of country currency rates.
     */
    getCountryCurrenciesWithRate(params: QueryParams): Observable<CountryCurrencyRate[]>;
    /**
     * Updates the reference currency for a specified country.
     *
     * @param {number} id - The unique identifier of the country.
     * @param {CountryReferenceCurrencyIn} body - The data for updating the country's reference currency.
     * @return {Observable<CountryReferenceCurrencyOut>} An Observable emitting the updated country reference currency data.
     */
    putCountryReferenceCurrency(id: number, body: CountryReferenceCurrencyIn): Observable<CountryReferenceCurrencyOut>;
    /**
     * Sends a POST request to create a country reference currency.
     *
     * @param {CountryReferenceCurrencyIn} body - The payload containing the country reference currency data.
     * @return {Observable<CountryReferenceCurrencyOut>} An observable emitting the created country reference currency.
     */
    postCountryReferenceCurrency(body: CountryReferenceCurrencyIn): Observable<CountryReferenceCurrencyOut>;
    /**
     * Sends a POST request to create or update a country reference extra charge.
     *
     * @param {CountryReferenceExtraChargeIn} body - The request payload containing details about the country reference extra charge.
     * @return {Observable<CountryReferenceExtraChargeOut>} An observable containing the response with the created or updated country reference extra charge.
     */
    postCountryReferenceExtraCharge(body: CountryReferenceExtraChargeIn): Observable<CountryReferenceExtraChargeOut>;
    /**
     * Updates a country reference extra charge by its ID.
     *
     * @param {number} id - The unique identifier of the country reference extra charge to be updated.
     * @param {CountryReferenceExtraChargeIn} body - The data to update the country reference extra charge with.
     * @return {Observable<CountryReferenceExtraChargeOut>} An observable that emits the updated country reference extra charge.
     */
    putCountryReferenceExtraCharge(id: number, body: CountryReferenceExtraChargeIn): Observable<CountryReferenceExtraChargeOut>;
    /**
     * Enables or disables a country reference extra charge based on the provided parameters.
     *
     * @param {CountryReferenceExtraCharge} extraCharge - The country reference extra charge object to be updated.
     * @param {boolean} [isActive] - Optional parameter to explicitly set the active status of the extra charge.
     *                               If not provided, the current active status will be toggled.
     * @return {Observable<EmployeeCustomersOut>} An Observable that emits the updated employee customers output.
     */
    patchCountryReferenceExtraCharge(extraCharge: CountryReferenceExtraCharge, isActive?: boolean): Observable<EmployeeCustomersOut>;
    /**
     * Fetches exchange data based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters for retrieving exchange data.
     * @return {Observable<ExchangesOut>} An observable containing the exchange data.
     */
    getExchanges(params: QueryParams): Observable<ExchangesOut>;
    /**
     * Sends a POST request to create or update an exchange.
     *
     * @param {ExchangeIn} body - The request body containing the exchange data to be sent.
     * @return {Observable<ExchangeOut>} An observable that emits the response containing the created or updated exchange data.
     */
    postExchange(body: ExchangeIn): Observable<ExchangeOut>;
    /**
     * Updates an existing exchange with new data.
     *
     * @param {number} id - The unique identifier of the exchange to update.
     * @param {ExchangeIn} body - The data to update the exchange with.
     * @return {Observable<ExchangeOut>} An observable that emits the updated exchange data.
     */
    putExchange(id: number, body: ExchangeIn): Observable<ExchangeOut>;
    /**
     * Retrieves the current exchanges based on the given query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the exchanges.
     *
     * @returns {Observable<ExchangesOut>} - An observable that emits the API response data containing the current exchanges.
     */
    getCurrentExchanges(params: QueryParams): Observable<ExchangesOut>;
    /**
     * Fetches the country-specific tax information for a company.
     *
     * @param {QueryParams} params - The parameters used to filter and query the taxes.
     * @return {Observable<CompanyCountryTaxesOut>} An observable that emits the tax information.
     */
    getCompanyCountryTaxes(params: QueryParams): Observable<CompanyCountryTaxesOut>;
    /**
     * Fetches account information based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters for fetching account data.
     * @return {Observable<AccountsOut>} An observable emitting the account data.
     */
    getAccounts(params: QueryParams): Observable<AccountsOut>;
    /**
     * Fetches the account information for the specified account ID.
     *
     * @param {number} id - The unique identifier of the account to retrieve.
     * @return {Observable<AccountOut>} An observable that emits the account details.
     */
    getAccount(id: number): Observable<AccountOut>;
    /**
     * Creates a new account by sending account details in the body.
     *
     * @param {AccountIn} body - The account information to be sent in the request body.
     * @return {Observable<AccountOut>} Observable that emits the created account details upon success.
     */
    postAccount(body: AccountIn): Observable<AccountOut>;
    /**
     * Updates an account with the specified ID using the provided data.
     *
     * @param {number} id - The unique identifier of the account to be updated.
     * @param {AccountIn} body - The data to update the account with.
     * @return {Observable<AccountOut>} An observable emitting the updated account details.
     */
    putAccount(id: number, body: AccountIn): Observable<AccountOut>;
    /**
     * Updates the status of an account.
     *
     * This method sends an HTTP PATCH request to the accounts endpoint
     * in order to activate or deactivate a specific account.
     *
     * @param id Unique identifier of the account.
     * @param isActive Status to assign to the account.
     * - `true`: activates the account.
     * - `false`: deactivates the account.
     */
    patchAccount(id: number, isActive: boolean): Observable<AccountOut>;
    /**
     * Retrieves the list of active accounts.
     *
     * This method sends an HTTP GET request to the active accounts endpoint,
     * allowing query parameters for filtering or pagination.
     *
     * @param params Query parameters used to filter
     * or paginate the results.
     */
    getAccountsActives(params: QueryParams): Observable<AccountsActivesOut>;
    /**
     * Updates an account entity using the provided details.
     *
     * @param {AccountEntitiesIn} body The account entity data to be updated.
     * @return {Observable<AccountEntitiesOut>} An observable containing the updated account entity details.
     */
    putAccountEntity(body: AccountEntitiesIn): Observable<AccountEntitiesOut>;
    /**
     * Retrieves the list of active account entities based on the provided query parameters.
     *
     * @param {QueryParams} params - The parameters to filter and query active account entities.
     * @return {Observable<AccountEntitiesOut>} An observable that emits the list of active account entities.
     */
    getAccountEntitiesActives(params: QueryParams): Observable<AccountEntitiesOut>;
    /**
     * Fetches a list of account categories based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter the account categories.
     * @return {Observable<AccountCategoriesOut>} An observable that emits the fetched account categories data.
     */
    getAccountCategories(params: QueryParams): Observable<AccountCategoriesOut>;
    /**
     * Retrieves a list of account types from the server.
     *
     * @param {QueryParams} params - The query parameters to filter or customize the request.
     * @return {Observable<AccountTypesOut>} An observable emitting the account types data.
     */
    getAccountTypes(params: QueryParams): Observable<AccountTypesOut>;
    /**
     * Retrieves the account type for the given account ID.
     *
     * @param {number} id - The unique identifier of the account.
     * @return {Observable<AccountTypeOut>} An observable that emits the account type data.
     */
    getAccountType(id: number): Observable<AccountTypeOut>;
    /**
     * Sends a POST request to create a new account type.
     *
     * @param {AccountTypeIn} body - The data for the account type to be created.
     * @return {Observable<AccountTypeOut>} An observable that emits the created account type object.
     */
    postAccountType(body: AccountTypeIn): Observable<AccountTypeOut>;
    /**
     * Updates an account type with the specified ID using the provided data.
     *
     * @param {number} id - The unique identifier of the account type to update.
     * @param {AccountTypeIn} body - The data to update the account type with.
     * @return {Observable<AccountTypeOut>} An observable containing the updated account type data.
     */
    putAccountType(id: number, body: AccountTypeIn): Observable<AccountTypeOut>;
    /**
     * Retrieves parameters based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter or fetch the desired parameters.
     * @return {Observable<ParametersOut>} An observable that emits the fetched parameters.
     */
    getParameters(params: QueryParams): Observable<ParametersOut>;
    /**
     * Retrieves the parameter values based on the provided parameter names.
     *
     * @param {Object} params - An object containing the required parameters.
     * @param {string[]} params.paramNames - An array of parameter names for which the values need to be fetched.
     * @return {Observable<ParametersValuesOut>} An observable that emits the fetched parameter values.
     */
    postParametersValues({ paramNames }: ParametersValuesIn): Observable<ParametersValuesOut>;
    /**
     * Retrieves parameter values based on the provided level configuration.
     *
     * @param {ParametersByLevelIn} parameters - The input object containing the criteria or level details to retrieve the parameters.
     * @return {Observable<ParametersValuesOut>} An observable that emits the parameter values fetched from the server.
     */
    postParameterValueByModel(parameters: ParametersByLevelIn): Observable<ParametersValuesOut>;
    /**
     * Retrieves the value of a specified parameter.
     *
     * @param {Object} input - The input object containing the parameter details.
     * @param {string} input.paramName - The name of the parameter whose value is to be retrieved.
     * @return {Observable<ParameterValueOut>} An observable emitting the value of the specified parameter.
     */
    getParameterValue({ paramName, }: ParameterValueIn): Observable<ParameterValueOut>;
    /**
     * Retrieves a list of country references based on the given query parameters.
     *
     * @param {QueryParams} params - The query parameters for retrieving country references.
     * @return {Observable<CountryReferencesOut>} An observable containing the country reference data.
     */
    getCountryReferences(params: QueryParams): Observable<CountryReferencesOut>;
    /**
     * Fetches the country reference data for a given country ID.
     *
     * @param {number} id - The unique identifier of the country for which the reference data is to be retrieved.
     * @return {Observable<CountryReferenceOut>} An observable containing the country reference data.
     */
    getCountryReference(id: number): Observable<CountryReferenceOut>;
    /**
     * Updates a country reference resource with the specified ID and data.
     *
     * @param {number} id - The unique identifier of the country reference to be updated.
     * @param {CountryReferenceIn} body - The data to update the country reference with.
     * @return {Observable<CountryReferenceOut>} An observable that emits the updated country reference object.
     */
    putCountryReference(id: number, body: CountryReferenceIn): Observable<CountryReferenceOut>;
    /**
     * Fetches the list of workflows based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter workflows.
     * @return {Observable<WorkflowsOut>} An observable containing the workflow data.
     */
    getWorkflows(params: QueryParams): Observable<WorkflowsOut>;
    /**
     * Fetches the list of employee customer
     *
     * @param {QueryParams} params - The query parameters used to filter employee customers.
     * @return {Observable<EmployeeCustomersOut>} An observable containing the employee customer data.
     */
    getEmployeesCustomers(params: QueryParams): Observable<EmployeesCustomersOut>;
    /**
     * Sends a POST request to create or update employee customer records and processes the server response.
     *
     * @param {EmployeeCustomersIn} body - The request payload containing employee customer data to be sent to the server.
     * @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee customer data on successful response.
     */
    postEmployeeCustomers(body: EmployeeCustomersIn): Observable<EmployeeCustomersOut>;
    /**
     * Updates the employee-customer association record identified by the given ID with the provided data.
     *
     * @param {number} id - The identifier of the employee-customer record to update.
     * @param {EmployeeCustomersIn} body - The data to update the employee-customer record with.
     * @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee-customer data.
     */
    putEmployeeCustomers(id: number, body: EmployeeCustomersIn): Observable<EmployeeCustomersOut>;
    /**
     * Fetches the employee-customer details based on the provided employee customer ID.
     *
     * @param {number} id - The identifier of the employee-customer record to update.
     * @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee-customer data.
     */
    getEmployeeCustomer(id: number): Observable<EmployeeCustomersOut>;
    /**
     * Enables or disables an employee customer's active state.
     *
     * @param {EmployeeCustomerDhl} employee - The employee customer object to be updated.
     * @param {boolean} [isActive] - Optional parameter to explicitly set the active state.
     *                                If null or undefined, the active state will be toggled.
     * @return {Observable<EmployeeCustomersOut>} An observable containing the updated employee customer output.
     */
    patchEmployeeCustomers(employee: EmployeeCustomerDhl, isActive?: boolean): Observable<EmployeeCustomersOut>;
    /**
     * Submits a file containing employee customer data for a specific country to the server.
     *
     * @param {number} countryId - The identifier of the country for which the data is being uploaded.
     * @param {File} file - The file contains employee customer data to be uploaded.
     * @return {Observable<BoardingProcessIdIn>} Observable that emits the processed boarding process ID on success.
     */
    postEmployeeCustomersLoad(countryId: number, file: File): Observable<BoardingProcessIdIn>;
    /**
     * Downloads a file containing customer data for a specific employee based on the provided country ID.
     *
     * @param {number} id - The ID of the country used as a filter for fetching the employee's customers.
     * @return {Observable<Blob>} An observable that emits the file blob containing the customer data.
     */
    getEmployeeCustomersDownload(id: number): Observable<Blob>;
    /**
     * Retrieves the boarding process details for a given ID.
     *
     * @param {number} id - The unique identifier of the boarding process to retrieve.
     * @return {Observable<BoardingProcessIn>} An observable containing the boarding process details.
     */
    getBoardingProcess(id: number): Observable<BoardingProcessIn>;
    /**
     * Fetches a list of systems based on the provided query parameters.
     *
     * @param {QueryParams} params - The parameters used to filter the systems.
     * @return {Observable<SystemsOut>} An observable that emits the retrieved systems data.
     */
    getSystems(params: QueryParams): Observable<SystemsOut>;
    /**
     * Retrieves the system by the specified ID.
     *
     * @param {number} id - The unique identifier of the system to be retrieved.
     * @return {Observable<SystemOut>} An observable that emits the requested system information.
     */
    getSystem(id: number): Observable<SystemOut>;
    /**
     * Sends a POST request to create or update a system.
     *
     * @param {SystemIn} body - The data representing the system to be created or updated.
     * @return {Observable<SystemOut>} An observable emitting the resulting system output after the API request succeeds.
     */
    postSystem(body: SystemIn): Observable<SystemOut>;
    /**
     * Updates the system identified by the given ID with the provided request body and returns the updated system details.
     *
     * @param {number} id - The unique identifier of the system to be updated.
     * @param {SystemIn} body - The payload containing the updated system details.
     * @return {Observable<SystemOut>} An observable emitting the updated system data.
     */
    putSystem(id: number, body: SystemIn): Observable<SystemOut>;
    /**
     * Retrieves a list of system entities based on the specified query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter or specify the system entities to retrieve.
     * @return {Observable<SystemEntitiesOut>} An Observable that emits the retrieved system entities.
     */
    getSystemEntities(params: QueryParams): Observable<SystemEntitiesOut>;
    /**
     * Updates the system entities by sending the provided data to the server.
     *
     * @param {SystemEntitiesIn} body - The data object representing the system entities to be updated.
     * @return {Observable<SystemEntitiesOut>} An observable containing the updated system entities data.
     */
    putSystemEntities(body: SystemEntitiesIn): Observable<SystemEntitiesOut>;
    /**
     * Retrieves workflow configurations based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the workflow configurations.
     * @return {Observable<WorkflowConfigsOut>} An observable emitting the workflow configurations.
     */
    getWorkflowConfigs(params: QueryParams): Observable<WorkflowConfigsOut>;
    /**
     * Sends a batch of workflow configuration data to the server for processing.
     *
     * @param {WorkflowConfigsBatchIn} body - The input data containing a batch of workflow configurations to be sent.
     * @return {Observable<WorkflowConfigsOut>} An observable that emits the processed batch of workflow configuration data as a response.
     */
    postWorkflowConfigsBatch(body: WorkflowConfigsBatchIn): Observable<WorkflowConfigsOut>;
    /**
     * Retrieves a list of companies based on the provided query parameters.
     * @param params - The query parameters to filter and paginate the companies list
     * @returns An Observable that emits the companies data
     */
    getCompanies(params: QueryParams): Observable<CompaniesOut>;
    /**
     * Retrieves a company by its ID.
     * @param id - The unique identifier of the company to retrieve.
     * @returns An Observable that emits the company data.
     */
    getCompany(id: number): Observable<CompanyOut>;
    /**
     * Sends a POST request to create a new company and returns the created company's details.
     *
     * @param {CompanyIn} body - The payload containing the details of the company to be created.
     * @return {Observable<CompanyOut>} An Observable emitting the response with the created company's details.
     */
    postCompany(body: CompanyIn): Observable<CompanyOut>;
    /**
     * Updates the details of an existing company using its ID.
     *
     * @param {number} id - The unique identifier of the company to update.
     * @param {CompanyIn} body - The object containing the updated company data.
     * @return {Observable<CompanyOut>} An observable that emits the updated company details.
     */
    putCompany(id: number, body: CompanyIn): Observable<CompanyOut>;
    /**
     * Deletes a company by its unique identifier.
     *
     * @param {number} id - The unique identifier of the company to be deleted.
     * @return {Observable<{}>} An observable that emits an empty object upon successful deletion or an error if the operation fails.
     */
    deleteCompany(id: number): Observable<{}>;
    /**
     * Fetches product entities from the server based on the provided query parameters.
     *
     * @param {QueryParams} params The query parameters used to modify the request for product entities.
     * @return {Observable<ProductEntitiesOut>} An observable that emits the product entities retrieved from the server.
     */
    getProductEntities(params: QueryParams): Observable<ProductEntitiesOut>;
    /**
     * Sends a PUT request to update product entities and returns the updated entity.
     *
     * @param {ProductEntitiesIn} body - The payload containing the data to update the product entity.
     * @return {Observable<ProductEntitiesOut>} Observable that emits the updated product entity.
     */
    putProductEntities(body: ProductEntitiesIn): Observable<ProductEntitiesOut>;
    /**
     * Retrieves the country reference products based on the given query parameters.
     *
     * @param {QueryParams} params The query parameters used to filter and retrieve the country reference products.
     * @return {Observable<CountryReferenceProductsOut>} An observable emitting the fetched country reference products data.
     */
    getCountryReferenceProducts(params: QueryParams): Observable<CountryReferenceProductsOut>;
    /**
     * Sends a request to update or create country reference products.
     *
     * @param {CountryReferenceProductIn} body - The payload containing the details of the country reference products to post.
     * @return {Observable<CountryReferenceProductOut>} An observable that emits the updated or created country reference product data.
     */
    postCountryReferenceProducts(body: CountryReferenceProductIn): Observable<CountryReferenceProductOut>;
    /**
     * Updates a country reference product with the specified ID using the provided data.
     *
     * @param {number} id - The unique identifier of the country reference product to update.
     * @param {CountryReferenceProductIn} body - The updated country reference product data to be sent in the request body.
     * @return {Observable<CountryReferenceProductOut>} An observable emitting the updated country reference product.
     */
    putCountryReferenceProducts(id: number, body: CountryReferenceProductIn): Observable<CountryReferenceProductOut>;
    /**
     * Fetches the extra charge entities from the server based on the provided query parameters.
     *
     * @param {QueryParams} params - An object containing the query parameters to filter the extra charge entities.
     * @return {Observable<ExtraChargeEntitiesOut>} An observable that emits the extra charge entities retrieved from the server.
     */
    getExtraChargeEntities(params: QueryParams): Observable<ExtraChargeEntitiesOut>;
    /**
     * Updates extra charge entities by sending the provided data to the server.
     *
     * @param {ExtraChargeEntitiesIn} body - The data to update the extra charge entities.
     * @return {Observable<ExtraChargeEntitiesOut>} An observable that emits the updated extra charge entities.
     */
    putExtraChargeEntities(body: ExtraChargeEntitiesIn): Observable<ExtraChargeEntitiesOut>;
    /**
     * Retrieves the parameter configurations based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the parameter configurations.
     * @return {Observable<ParameterConfigsOut>} An observable that emits the parameter configurations data.
     */
    getParameterConfigs(params: QueryParams): Observable<ParameterConfigsOut>;
    /**
     * Sends a POST request to create or update a parameter configuration.
     *
     * @param {ParameterConfigIn} body - The input data object containing the parameter configuration to be sent in the request body.
     * @return {Observable<ParameterConfigOut>} An observable that emits the server's response containing the updated or newly created parameter configuration.
     */
    postParameterConfig(body: ParameterConfigIn): Observable<ParameterConfigOut>;
    /**
     * Updates the configuration of a parameter with the provided ID and input data.
     *
     * @param {number} id - The unique identifier of the parameter configuration to be updated.
     * @param {ParameterConfigIn} body - The input data containing the updated configuration for the parameter.
     * @return {Observable<ParameterConfigOut>} An observable that emits the updated parameter configuration.
     */
    putParameterConfig(id: number, body: ParameterConfigIn): Observable<ParameterConfigOut>;
    /**
     * Deletes a parameter configuration specified by its ID.
     *
     * @param {number} id - The unique identifier of the parameter configuration to be deleted.
     * @return {Observable<ParameterConfigOut>} An observable containing the deleted parameter configuration data.
     */
    deleteParameterConfig(id: number): Observable<ParameterConfigOut>;
    /**
     * Retrieves a list of TDX account settings based on the given query parameters.
     *
     * @param {QueryParams} params - Query parameters used to filter or paginate the results.
     * @returns {Observable<TDXAccountsSettingsOut>} An observable containing the list of TDX account settings.
     */
    getTDXAccountsSettings(params: QueryParams): Observable<TDXAccountsSettingsOut>;
    /**
     * Retrieves a single TDX account setting by its ID.
     *
     * @param {number} id - The unique identifier of the TDX account setting to be retrieved.
     * @returns {Observable<TDXAccountSettingsOut>} An observable containing the requested TDX account setting.
     */
    getTDXAccountSettings(id: number): Observable<TDXAccountSettingsOut>;
    /**
     * Creates a new TDX account setting with the provided data.
     *
     * @param {TDXAccountSettingsIn} body - The data used to create the new TDX account setting.
     * @returns {Observable<TDXAccountSettingsOut>} An observable containing the newly created TDX account setting.
     */
    postTDXAccountSettings(body: TDXAccountSettingsIn): Observable<TDXAccountSettingsOut>;
    /**
     * Updates an existing TDX account setting identified by its ID.
     *
     * @param {number} id - The unique identifier of the TDX account setting to be updated.
     * @param {TDXAccountSettingsIn} body - The updated data for the TDX account setting.
     * @returns {Observable<TDXAccountSettingsOut>} An observable containing the updated TDX account setting.
     */
    putTDXAccountSettings(id: number, body: TDXAccountSettingsIn): Observable<TDXAccountSettingsOut>;
    /**
     * Retrieves the employees of a specific location using a provided token.
     *
     * @param params - Input parameters for the request, defined by the `LocationEmployeesIn` interface.
     * @returns An `Observable<LocationEmployeesOut>` that emits the employees
     * associated with the given location.
     * @returns The response type is `ApiSuccess<LocationEmployeesOut>`, from which the `data` field is extracted.
     */
    getLocationEmployeesByToken(params: {
        token: string;
        queryParams: QueryParams;
    }): Observable<LocationEmployeesOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiCompaniesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiCompaniesService>;
}

declare enum CustomerType$1 {
    SHIPPER = "SP",
    CONSIGNEE = "RV",
    IMPORTER = "IP",
    EXPORTER = "EP"
}

interface Supply extends ActiveLessSymfonyModel {
    name: string;
    description: string;
    countryId: number;
    enabledForDropoff: boolean;
    supplyType: SupplyType;
    supplyPacking: SupplyPacking | null;
}
interface SupplyType extends SymfonyModel {
    name: string;
}
interface SupplyPacking extends SymfonyModel {
    value: number;
    weight: number;
    height: number;
    depth: number;
    width: number;
    emobileCode: string | null;
}
interface SupplyLocation extends SymfonyModel {
    supply: Supply;
    locationId: number;
    stock: number;
    lastInventoryDate: string;
    lastInventoryDifference: number;
    locationName: string;
}
interface SupplyTransactionType extends ActiveLessSymfonyModel {
    code: string;
    description: string;
    sign: number;
}
interface SupplyLocationTransaction extends ActiveLessSymfonyModel {
    supplyLocation: SupplyLocation;
    supplyTransactionType: SupplyTransactionType;
    userId: number;
    quantity: number;
    stock: number;
}

interface ShipmentComposition extends SymfonyModel {
    currencyCode: string;
    extraCharges: ExtraChargeComposition[];
    globalProductCode: string;
    globalProductName: string;
    localProductCode: string;
    localProductName: string;
    trackingNumber: string;
    contentDescription: string;
    realWeight: number;
    piecesNumber: number;
    productSubtotal: number;
    productTax: number;
    productTotal: number;
    declaredValue: number;
    insuredValue: number;
    accountNumber: string;
    userId: number;
    installationId: number;
    companyCountryId: number;
    productId: number;
    countryReferenceCurrencyId: number;
    commercialExchangeRate: number;
    ibsExchangeRate: number;
    shipmentStatusId: number;
    shipmentAddresses: ShipmentAddresses[];
    shipmentPieces: ShipmentPieces[];
    shipmentCompanyCountryExtraCharges: ShipmentCompanyCountryExtraCharges[];
    shipmentGsop: ShipmentGsop;
    additionalData: AdditionalData;
    transactionId: string;
    requiresPayment: boolean;
    originServiceAreaCode: string;
    originFacilityCode: string;
    destinationServiceAreaCode: string;
    destinationFacilityCode: string;
    productTaxes: string[];
    isInspected: boolean;
    extraFields: {
        [key: string]: string | number | boolean;
    };
    shipmentContentTypeId: number;
    commercialInvoice: CommercialInvoice;
    shipmentScopeId: number;
    shipmentGroupId: number;
    product: string[];
    declaredCurrency: string;
    insuredCurrency: string;
    deliveryDateTime: string;
    date: string;
    promotionCode: string;
    priceOverrideApproverId: number;
    priceOverrideReasonId: number;
    customs: Customs;
    exportReasonId: number;
    exportReason: string[];
    shipmentBookPickup: ShipmentBookPickup;
    questionId: number;
    isInsured: boolean;
    itnNumber: string;
    einNumber: string;
    otherAccountNumber: string;
    dutiesAndTaxesAccountNumber: string;
    discountId: string;
    discountReference: string;
    totalPublishedValue: number;
    totalPartnerAccountValue: number;
    isMarketingConsent: boolean;
    isTermCondition: boolean;
    isDocument: boolean;
    isCash: boolean;
    isPriceOverride: boolean;
    isProforma: boolean;
    isPromotionCode: boolean;
    isRetailRate: boolean;
    isOtherOrigin: boolean;
    isOccurs: boolean;
    isDutiesAndTaxes: boolean;
}
interface ExtraChargeComposition {
    globalServiceCode: string;
    localServiceCode: string;
    globalServiceName: string;
    localServiceName: string;
    subtotal: number;
    tax: number;
    total: number;
    taxes: Tax[];
}
interface Tax {
    code: string;
    percent: number;
    baseAmount: number;
    amount: number;
}
interface ShipmentAddresses extends SymfonyModel {
    index: number;
    identificationTypeId: number;
    identificationNumber: string;
    companyName: string;
    fullName: string;
    email: string;
    phoneCode: string;
    phoneNumber: string;
    postalCode: string;
    stateCode: string;
    countyName: string;
    cityName: string;
    addressLine1: string;
    addressLine2: string;
    addressLine3: string;
    countryId: number;
    identificationType: IdentificationTypeComposition;
    roleType: CustomerType$1;
}
interface IdentificationTypeComposition extends SymfonyModel {
    name: string;
    companyCountryId: number;
}
interface ShipmentPieces extends ActiveLessSymfonyModel {
    number: number;
    height: number;
    length: number;
    width: number;
    realWeight: number;
    volumetricWeight: number;
    dataIdentifier: string;
    trackingNumber: string;
    licensePlateBarCode: string;
    shipmentPieceCompanyCountrySupplies: ShipmentPieceCompanyCountrySupplies[];
}
interface ShipmentPieceCompanyCountrySupplies extends ActiveLessSymfonyModel {
    supplyId: number;
    quantity: number;
    subtotal: number;
    taxBase: number;
    taxPercent: number;
    tax: number;
    total: number;
    description: string;
    supply: Supply;
}
interface CommercialInvoice extends ActiveLessSymfonyModel {
    documentTypeId: number;
    tradingTransactionTypeId: number;
    documentFunctionId: number;
    number: string;
    remarks: string;
    items: Item[];
    documentType: DocumentTypeComposition;
    tradingTransactionType: TradingTransactionType;
    documentFunction: DocumentFunction;
}
interface Item extends ActiveLessSymfonyModel {
    description: string;
    quantity: number;
    quantityUnitId: number;
    subtotal: number;
    manufactureCountryCode: string;
    realWeight: number;
    commodityId: number;
    quantityUnit: QuantityUnit;
    manufactureCountry: ManufactureCountry;
    commodity: Commodity;
}
interface QuantityUnit extends SymfonyModel {
    code: string;
    name: string;
}
interface ManufactureCountry {
    id: string;
    code: string;
    name: string;
    locationType: string[];
    unit: string[];
    timezone: string;
    hasImportService: boolean;
    isActive: boolean;
    regions: string[];
    zones: string[];
    isoCode: string;
}
interface Commodity extends SymfonyModel {
    code: string;
    name: string;
    countryId: number;
}
interface DocumentTypeComposition extends SymfonyModel {
    code: string;
    name: string;
    description: string;
}
interface TradingTransactionType extends SymfonyModel {
    code: string;
    name: string;
    description: string;
}
interface DocumentFunction extends SymfonyModel {
    code: string;
    name: string;
}
interface ShipmentGsop extends ActiveLessSymfonyModel {
    productContentCode: string;
    originServiceAreaCode: string;
    destinationServiceAreaCode: string;
    internalServiceCode: string;
    awbBarCode: string;
    dhlRoutingBarCode: string;
}
interface ShipmentCompanyCountryExtraCharges extends ActiveLessSymfonyModel {
    subtotal: number;
    tax: number;
    total: number;
    extraChargeId: number;
    extraChargeCode: string;
}
interface AdditionalData {
    awbTypeCode: string;
    countryCode: string;
    shipmentTypeCode: string;
    productGlobalCode: string;
    productLocalCode: string;
    currencyCode: string;
    userUsername: string;
    locationFacilityCode: string;
}
interface Customs {
    criteria: Criteria;
    rules: Rules[];
}
interface Criteria {
    origin: string;
    destination: string;
    dutiable: boolean;
    declaredValue: number;
}
interface Rules {
    id: number;
    level: string;
    attributes: Attributes[];
}
interface Attributes {
    id: number;
    field: string;
    dhlCode: string;
    values: Values;
}
interface Values {
    shipment: string;
    customer: CustomerComposition;
    invoiceHeader: string;
    invoiceItem: string[];
}
interface CustomerComposition {
    SP: string;
    RV: string;
}
interface ShipmentBookPickup extends ActiveLessSymfonyModel {
    pickupDate: string;
    readyByTime: string;
    closeTime: string;
    confirmationNumber: string;
    packageLocationId: number;
    remarks: string;
    packageLocation: PackageLocation;
}

type ShipmentOut = {
    shipment: ShipmentComposition;
};
type CompositionCountryReferencesOut = {
    country_references: CountryReference[];
    total: number;
};

declare class ApiCompositionService {
    private environments;
    private http;
    /**
     * Retrieves the API security URL from the environment configuration.
     *
    * @returns {string} The API security URL.
     */
    get url(): string;
    /**
     * Retrieves shipment details based on the provided shipment ID.
     *
     * @param {number} id - The unique identifier of the shipment to retrieve.
    * @returns {Observable<ShipmentOut>} An observable that emits the details of the shipment.
     */
    getShipment(id: number): Observable<ShipmentOut>;
    /**
     * Fetches the country references data based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters for the API request.
    * @returns {Observable<CompositionCountryReferencesOut>} An observable emitting the country references.
     */
    getCountryReferences(params: QueryParams): Observable<CompositionCountryReferencesOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiCompositionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiCompositionService>;
}

interface Field extends ActiveLessSymfonyModel {
    name: string;
    label: string;
    level: string;
    dhlCodes: DhlCode[];
}
interface DhlCode extends ActiveLessSymfonyModel {
    code: string;
    customerCode: string;
    description: string;
}
interface Override extends ApiModel {
    field: string;
    name: string;
    level: string;
}
interface Catalog extends SymfonyModel {
    name: string;
}
interface Rule extends SymfonyModel {
    ruleType: string;
    criteria: CriteriaCustom | null;
    name: string;
    description: string | null;
    level: string;
    roleTypes: string[];
    warning: string | null;
    attributes: Attribute[];
}
interface CriteriaCustom extends ApiModel {
    origins: string[];
    originGroups: string[];
    originExclusions: string[];
    destinations: string[];
    destinationGroups: string[];
    destinationExclusions: string[];
    dutiable: boolean;
    declaredValue: null | {
        operator: number;
    };
}
interface Attribute extends ActiveLessSymfonyModel {
    field: FieldLess | null;
    dhlCode: DhlCodeLess | null;
    inputType: string;
    inputLabel: string;
    inputTooltip: string | null;
    exclusive: boolean;
    exclusiveDefault: boolean;
    required: boolean;
    text: TextConfig | null;
    dropdown: DropdownConfig | null;
    number: null | {
        min: number;
        max: number;
    };
    dependentRules: DependentRules | null;
    fillFrom: FillFrom | null;
    override: Override | null;
}
interface FieldLess extends ApiModel {
    name: string;
    label: string;
}
interface TextConfig {
    minLength: number | null;
    maxLength: number | null;
    regex: string | null;
    alphaNumeric: string | null;
    placeHolder: string | null;
    format: string | null;
    prefix: string | null;
    suffix: string | null;
    masked: boolean;
    isFormat?: boolean;
}
interface DropdownConfig extends Dropdown {
    catalog: CatalogLess | null | number;
}
interface DependentRules {
    conditionType: string;
    ruleIds: number[];
}
interface FillFrom {
    attributeIndex: number;
    attributeId: number;
    using: string;
    disabled: boolean;
}
interface CatalogLess extends ApiModel {
    name: string;
    isActive: boolean;
}
interface CriteriaWithTimestamps {
    createdAt: string;
    updatedAt: string;
}
interface CountryGroups extends ActiveLessSymfonyModel {
    code: string;
    name: string;
    countries: string[];
}
interface DhlCodeLess extends ApiModel {
    code: string;
    customerCode: string;
    description: string;
}
interface RuleByCriteria extends ApiModel {
    ruleType: string;
    criteria: CriteriaCustom | null;
    name: string;
    description: string | null;
    level: string;
    roleTypes: string[];
}
interface Dropdown {
    values: string[];
    catalogId: number;
    loadOnDemand: boolean;
    defaultValue: string | null;
    prefix: string | null;
    suffix: string | null;
    _catalogName?: string | null;
}

type FieldsOut = {
    total: number;
    fields: Field[];
};
type OverridesOut = {
    total: number;
    overrides: Override[];
};
type CatalogsOut = {
    total: number;
    catalogs: Catalog[];
};
type RulesOut = {
    total: number;
    rules: Rule[];
};
type RuleOut = {
    rule: Rule;
};
type CriteriaIn = {
    origins: string[];
    originGroups: string[];
    originExclusions: string[];
    destinations: string[];
    destinationGroups: string[];
    destinationExclusions: string[];
    dutiable: boolean;
    declaredValue: {
        operator: number;
    } | null;
    touched?: boolean;
    valid?: boolean;
};
type CriteriaOut = {
    criteria: CriteriaCustom & CriteriaWithTimestamps;
};
type RuleIn = {
    ruleType: string;
    criteriaId: number | null;
    name: string;
    description: string | null;
    level: string;
    roleTypes: string[];
    warning: string | null;
    attributes: AttributeIn[];
    isActive: boolean;
};
type AttributeIn = {
    fieldId: number | null;
    dhlCodeId: number | null;
    inputType: string;
    inputLabel: string;
    inputTooltip: string | null;
    exclusive: boolean;
    exclusiveDefault: boolean;
    required: boolean;
    text: TextConfig | null;
    dropdown: Dropdown | null;
    number: number | null | {
        min: number | null;
        max: number | null;
    };
    dependentRules: DependentRules | null;
    fillFrom: FillFromIn | null;
    overrideId: number | null;
    isActive: boolean;
};
type FillFromIn = {
    attributeIndex: number;
    using: string;
    disabled: boolean;
};
type RuleCriteriaIn = CriteriaIn & {
    ruleType: string | null;
};
type AttributeWithId = AttributeIn & {
    id: number;
};
type RulesIn = Omit<RuleIn, 'attributes'> & {
    id: number | null;
    attributes: AttributeWithId[];
};
type CountryGroupsOut = {
    countryGroups: CountryGroups[];
};
type RulesByCriteriaOut = {
    total: number;
    rules: RuleByCriteria[];
};

declare class ApiCustomsService {
    private environments;
    private http;
    /**
     * Retrieves the URL for the cash operations API from the environment configurations.
     *
     * @return {string} The URL of the cash operations API.
     */
    get url(): string;
    /**
     * Fetches the available fields for a given level.
     *
     * @return {Observable<FieldsOut>} An Observable that emits the list of fields.
     * @param params
     */
    getFields(params: QueryParams): Observable<FieldsOut>;
    /**
     * Retrieves override configurations for a given level.
     *
     * @return {Observable<OverridesOut>} An Observable that emits the overrides configuration.
     * @param params
     */
    getOverrides(params: QueryParams): Observable<OverridesOut>;
    /**
     * Fetches the catalogs used in customs operations.
     *
     * @return {Observable<CatalogsOut>} An Observable that emits the catalogs.
     */
    getCatalogs(params: QueryParams): Observable<CatalogsOut>;
    /**
     * 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: QueryParams): Observable<RulesOut>;
    /**
     * 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: number): Observable<RuleOut>;
    /**
     * Creates a new criteria.
     *
     * @param {CriteriaIn} body - The criteria payload to create.
     * @return {Observable<CriteriaOut>} An Observable that emits the created criteria.
     */
    postCriteria(body: CriteriaIn): Observable<CriteriaOut>;
    /**
     * Creates a new rule.
     *
     * @param {RuleIn} body - The rule payload to create.
     * @return {Observable<RuleOut>} An Observable that emits the created rule.
     */
    postRules(body: RuleIn): Observable<RuleOut>;
    /**
     * 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: RuleCriteriaIn): Observable<RulesByCriteriaOut>;
    /**
     * 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: number): Observable<{}>;
    /**
     * 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: number): Observable<{}>;
    /**
     * 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: number, body: CriteriaIn): Observable<CriteriaOut>;
    /**
     * 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: number, body: RulesIn): Observable<RuleOut>;
    /**
     * Retrieves the list of country groups used in customs operations.
     *
     * @return {Observable<CountryGroupsOut>} An Observable that emits the list of country groups.
     */
    getCountryGroups(params: QueryParams): Observable<CountryGroupsOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiCustomsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiCustomsService>;
}

interface Discount extends LaravelModel {
    code: string;
    company_country_id: number;
    name: string;
    description: string | null;
    account_number: string;
    percentage: string;
    start_date: string;
    end_date: string | null;
    start_weight: number;
    end_weight: number | null;
    shipment_scopes: number[];
    country_reference_products: number[];
    applies_to_all_locations: boolean;
    locations: number[] | null;
    reference_required: boolean;
    reference_restriction: boolean | null;
    reference_restriction_period: number | null;
    reference_restriction_amount: number | null;
    reference_restriction_message: string | null;
    shipment_scope_names: string;
    applies_to_all_locations_langs: {
        [key: string]: string;
    };
    reference_required_langs: {
        [key: string]: string;
    };
    status_langs: {
        [key: string]: string;
    };
    applies_to_all_locations_lang: string | null;
    reference_required_lang: string | null;
    status_lang: string | null;
}
interface TopCustomer extends ActiveLessLaravelModel {
    identification_type_id: number;
    identification_number: string;
    contact_name_1: string;
    contact_name_2: string;
    contact_name_3: string;
    email: string;
    phone_number: string;
    discount_percentage: string;
    account: string | null;
    shipment_scopes: string | null;
    company_country_id: number;
    company_name: string | null;
    level: string | null;
}
interface LoyaltyPeriod extends LaravelModel {
    company_country_id: number;
    days: number;
    shipment_scopes: number[];
    products: string[];
}
interface LoyaltyRule extends LaravelModel {
    name: string;
    loyalty_period_id: number;
    min_quantity: number;
    max_quantity: number;
    discount_percentage: number;
    account: string;
    products: string[];
    valid_since: string;
    valid_until: string;
}
interface CustomerRestriction extends ActiveLessLaravelModel {
    identification_type_id?: number;
    identification_number?: string;
    company_country_id: number;
    identificationType?: IdentificationType;
    email?: string;
    phone_number?: string;
    phone_code?: string;
    phone_country_code?: string;
}

type DiscountIn = {
    code: string;
    company_country_id: number;
    name: string;
    description: string;
    account_number: string;
    percentage: number;
    start_date: string;
    end_date: string;
    start_weight: number;
    end_weight: number;
    shipment_scopes: number[];
    country_reference_products: number[];
    applies_to_all_locations: boolean;
    locations: number[];
    reference_required: boolean;
    reference_restriction: boolean;
    reference_restriction_period: number;
    reference_restriction_amount: number;
    reference_restriction_message: string;
    is_active: boolean;
};
type DiscountOut = {
    discount: Discount;
};
type DiscountsOut = {
    discounts: Discount[];
    total: number;
};
type TopCustomersOut = {
    top_customers: TopCustomer[];
    total: number;
};
type OperationsLoadTopCustomerV2In = {
    company_country_id: number;
    file: File;
};
type LoyaltyPeriodsOut = {
    loyalty_periods: LoyaltyPeriod[];
    total: number;
};
type LoyaltyPeriodIn = {
    company_country_id: number;
    days: number;
    shipment_scopes: number[];
    products: string[];
    is_active: boolean;
};
type LoyaltyPeriodOut = {
    loyalty_period: LoyaltyPeriod;
};
type LoyaltyRulesOut = {
    loyalty_rules: LoyaltyRule[];
    total: number;
};
type LoyaltyRuleIn = {
    name: string;
    loyalty_period_id: number;
    min_quantity: number;
    max_quantity: number;
    discount_percentage: number;
    products: string[];
    account: string;
    valid_since: string;
    valid_until: string;
    is_active: boolean;
};
type LoyaltyRuleOut = {
    loyalty_rule: LoyaltyRule;
};
type CustomerRestrictionsOut = {
    customer_restrictions: CustomerRestriction[];
    total: number;
};
type CustomerRestrictionIn = {
    identification_type_id?: number;
    identification_number?: string;
    company_country_id: number;
};
type CustomerRestrictionInV2 = CustomerRestrictionIn & {
    email?: string;
    phone_number?: string;
    phone_code?: string;
    phone_country_code?: string;
};
type CustomerRestrictionOut = {
    customer_restriction: CustomerRestriction;
};

declare class ApiDiscountsService {
    private environments;
    private 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(): string;
    /**
     * 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: QueryParams): Observable<DiscountsOut>;
    /**
     * 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: DiscountIn): Observable<DiscountOut>;
    /**
     * 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: number, body: DiscountIn): Observable<DiscountOut>;
    /**
     * 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: QueryParams): Observable<TopCustomersOut>;
    /**
     * 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: OperationsLoadTopCustomerV2In): Observable<{}>;
    /**
     * 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: QueryParams): Observable<LoyaltyPeriodsOut>;
    /**
     * 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: number): Observable<LoyaltyPeriodOut>;
    /**
     * Creates a new loyalty period.
     * @param body - The loyalty period input data
     * @returns An observable that emits the created loyalty period output data
     */
    postLoyaltyPeriod(body: LoyaltyPeriodIn): Observable<LoyaltyPeriodOut>;
    /**
     * 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: number, body: LoyaltyPeriodIn): Observable<LoyaltyPeriodOut>;
    /**
     * 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: QueryParams): Observable<LoyaltyRulesOut>;
    /**
     * 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: number): Observable<LoyaltyRuleOut>;
    /**
     * 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: LoyaltyRuleIn): Observable<LoyaltyRuleOut>;
    /**
     * 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: number, body: LoyaltyRuleIn): Observable<LoyaltyRuleOut>;
    /**
     * 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: QueryParams): Observable<CustomerRestrictionsOut>;
    /**
     * 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: number): Observable<CustomerRestrictionOut>;
    /**
     * 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: CustomerRestrictionIn): Observable<CustomerRestrictionOut>;
    /**
     * 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: number, body: CustomerRestrictionIn): Observable<CustomerRestrictionOut>;
    /**
     * 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: number): Observable<{}>;
    /**
     * 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: CustomerRestrictionInV2): Observable<CustomerRestrictionOut>;
    /**
     * 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: number, body: CustomerRestrictionInV2): Observable<CustomerRestrictionOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiDiscountsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiDiscountsService>;
}

interface ExternalShipmentAddress extends ActiveLessSymfonyModel {
    addressLine1: string;
    addressLine2: string;
    addressLine3: string;
    cityName: string;
    companyName: string;
    countryId: number;
    email: string;
    externalShipmentId: number;
    fullName: string;
    identificationNumber: string;
    identificationTypeId: number;
    phoneCode: string;
    phoneNumber: string;
    postalCode: string;
    roleType: string;
    serviceAreaCode: string;
    countyName: string | null;
    businessActivity: string | null;
}
interface ExternalShipmentStatus extends ActiveLessSymfonyModel {
    name: string;
    isActive: boolean;
}
interface ExternalShipmentHistory extends ActiveLessSymfonyModel {
    externalShipmentId: number;
    externalShipmentStatus: ExternalShipmentStatus;
    messages: string[];
}
interface ExternalShipmentFile extends ActiveLessSymfonyModel {
    companyCountryId: string;
    name: string;
    finished: false;
    statusId: number;
    externalShipmentFileHistories: ExternalShipmentFileHistory[];
    externalShipmentId: number;
    content: string;
}
interface ExternalShipmentFileHistory extends ActiveLessSymfonyModel {
    statusId: number;
    messages: string[];
    externalShipmentFileId: number;
}
interface ExternalShipmentStatuses extends SymfonyModel {
    name: string;
}
interface ExternalShipmentAddressCancellation {
    companyName: string;
    fullName: string;
    cityName: string;
    postalCode: string;
    countyName: string | null;
    addressLine1: string;
    addressLine2: string;
    addressLine3: string;
    identificationTypeId: number;
    identificationNumber: string;
    email: string;
    phoneCode: string | null;
    phoneNumber: string | null;
    businessActivity?: string | null;
}

type ExternalShipmentAddressesIn = {
    id: number;
    addressLine1: string;
    addressLine2: string;
    addressLine3: string;
    cityName: string;
    companyName: string;
    email: string;
    fullName: string;
    identificationNumber: string;
    identificationTypeId: number;
    phoneCode: string | null;
    phoneNumber: string | null;
    postalCode: string;
    countyName?: string | null;
    businessActivity?: string | null;
};
type ExternalShipmentAddressesOut = {
    externalShipmentAddress: ExternalShipmentAddress;
};
type ExternalShipmentFileOut = {
    externalShipmentFile: ExternalShipmentFile;
};
type ExternalShipmentHistoriesOut = {
    total: number;
    externalShipmentHistories: ExternalShipmentHistory[];
};
type ExternalShipmentStatusOut = {
    total: number;
    externalShipmentStatuses: ExternalShipmentStatuses[];
};
type InvoiceCancellationIn = {
    id: number;
    documentId: number | null;
    cancellationReasonId: number;
};
type ExternalShipmentCancellationIn = {
    externalShipmentAddressesId: number;
    externalShipmentAddresses: ExternalShipmentAddressCancellation;
    cancellationReasonId: number;
    documentId: number;
};

declare class ApiEToolsAutoBillingService {
    private environments;
    private http;
    /**
     * Retrieves the URL for the shipments API from the environment configurations.
     *
     * @return {string} The URL of the shipments API.
     */
    get url(): string;
    /**
     * 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 }: ExternalShipmentAddressesIn): Observable<ExternalShipmentAddressesOut>;
    /**
     * 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: number): Observable<ExternalShipmentFileOut>;
    /**
     * 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: number): Observable<ExternalShipmentHistoriesOut>;
    /**
     * 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: QueryParams): Observable<ExternalShipmentStatusOut>;
    /**
     * Cancels the billing of an external shipment.
     *
     * This method sends a POST request to the backend in order to cancel
     *
     * @param params Object containing the required cancellation data
     * @param params.id External shipment ID
     * @param params.documentId Billing document ID
     * @param params.cancellationReasonId Cancellation reason ID
     *
     * @returns Observable that emits an empty array when the operation is successful
     */
    postExternalShipmentCancelBilling({ id, documentId, cancellationReasonId }: InvoiceCancellationIn): Observable<[]>;
    /**
     * Re-bills an external shipment.
     *
     * This method sends a POST request to the backend to regenerate
     * @param id External shipment ID
     * @param body Data required to perform the re-billing
     * @returns Observable that emits an empty array when the operation is successful
     */
    postExternalShipmentReBilling(id: number, body: ExternalShipmentCancellationIn): Observable<[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiEToolsAutoBillingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiEToolsAutoBillingService>;
}

declare enum OperationModuleStatus {
    CANCELED = "canceled",
    COMPLETED = "completed",
    IN_PROGESS = "in_progress"
}

interface OperationModule extends SymfonyModel {
    lastUserId: number;
    event: OperationEvent;
    lastAction: OperationAction;
    status: OperationModuleStatus;
    extraFields: {
        [key: string]: string | number | boolean | null;
    };
}
interface OperationEvent extends SymfonyModel {
    code: string;
    name: string;
    description: string;
}
interface OperationAction extends SymfonyModel {
    code: string;
    name: string;
    description: string;
}

type OperationModuleStartIn = {
    eventCode: string;
};
type OperationModuleEndIn = {
    status: OperationModuleStatus;
    extraFields?: {
        [key: string]: string | number | boolean | null;
    };
};
type OperationModuleOut = {
    operationModule: OperationModule;
};

declare class ApiEventsService {
    private environments;
    private http;
    /**
     * Gets the API endpoint URL for Events from the environments configuration.
     *
    * @returns {string} The URL for the Events API. Returns an empty string if not defined.
     */
    get url(): string;
    /**
     * Sends a request to start an event
     *
     * @param {OperationModuleStartIn} body - The event information to be submitted.
    * @returns {Observable<OperationModuleOut>} An Observable emitting the server's response containing the created event details.
     */
    postOperationModulesStart(body: OperationModuleStartIn): Observable<OperationModuleOut>;
    /**
     * Updates the discount information for a specific item.
     *
     * @param {number} id - The unique identifier of the item whose event is to be updated.
     * @param {OperationModuleEndIn} body - The payload containing the updated event details.
    * @returns {Observable<OperationModuleOut>} An observable emitting the updated event details.
     */
    putOperationModulesEnd(id: number, body: OperationModuleEndIn): Observable<OperationModuleOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiEventsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiEventsService>;
}

interface Operation extends LaravelModel {
    _id: string;
    operation_id: number;
    status: 'Pending' | 'Completed' | 'Canceled';
    code: number;
    signature: {
        signature_base_64: string;
        mime_type: 'image/png';
        client: {
            full_name: string;
        };
        package_detail: {
            shipment_tracking_number: string;
            pieces: {
                tracking_number: string;
                status: null | 'damaged' | 'lost';
            }[];
        }[];
    };
}

type DeliveryConfirmationGenerateOut = {
    code: string;
};
type DeliveryConfirmationGenerateIn = {
    operation_id: number;
    signature: {
        client: {
            full_name: string;
        };
        package_detail: {
            shipment_tracking_number: string;
            pieces: {
                tracking_number: string;
                status: string;
            }[];
        }[];
    };
};
type DeliveryConfirmationCompleteIn = {
    operationId: number;
    keyOTP: string;
};
type DeliveryConfirmationIn = {
    signature: {
        status: string;
        operation_id: number;
        signature_base_64: string;
        mime_type: string;
    };
    otp?: string;
};
type DeliveryConfirmationSearchOut = {
    operation: Operation;
};

declare class ApiExternalOperationsService {
    private http;
    private environment;
    private appKey;
    /**
     * Getter method to retrieve the API's external operations URL.
     * Fetches the URL from the `apiExternalOperationsUrl` property of the environment object.
     * Defaults to an empty string if the property is undefined or null.
     *
     * @return {string} The external operations URL or an empty string if unavailable.
     */
    get url(): string;
    /**
     * Retrieves delivery confirmation details based on the provided OTP code.
     *
     * @param {string} otpCode - The OTP code used to search for delivery confirmation.
     * @return {Observable<DeliveryConfirmationData>} An observable containing the delivery confirmation data.
     */
    getDeliveryConfirmation(otpCode: string): Observable<DeliveryConfirmationSearchOut>;
    /**
     * Generates a delivery confirmation by sending the provided payload to the API.
     *
     * @param {DeliveryConfirmationGenerateIn} payload - The input payload required to generate the delivery confirmation.
     * @return {Observable<DeliveryConfirmationGenerateOut>} An observable that emits the generated delivery confirmation data.
     */
    postDeliveryConfirmationGenerate(payload: DeliveryConfirmationGenerateIn): Observable<DeliveryConfirmationGenerateOut>;
    /**
     * Confirms the completion of a delivery operation by making a PATCH request.
     *
     * @param {Object} input - The input parameters for the method.
     * @param {string} input.operationId - The unique identifier of the delivery operation to be confirmed.
     * @param {string} input.keyOTP - The one-time password (OTP) key associated with the delivery confirmation.
     * @return {Observable<Object>} - An observable containing the response data from the API.
     */
    patchDeliveryConfirmationComplete({ keyOTP, operationId, }: DeliveryConfirmationCompleteIn): Observable<{}>;
    /**
     * Cancels a delivery confirmation by sending an OTP and additional data to the server.
     *
     * @param {Object} param0 - The parameter object containing the required properties.
     * @param {string} param0.otp - The one-time password to authenticate the cancellation request.
     * @param {Object} param0.body - Additional body data required for cancellation.
     * @return {Observable<Object>} An observable that emits the server's response when the cancellation is processed.
     */
    putDeliveryConfirmation({ otp, ...body }: DeliveryConfirmationIn): Observable<{}>;
    private getAppKeyHeader;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiExternalOperationsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiExternalOperationsService>;
}

declare enum Event {
    damage = "damage",
    lost = "lost",
    rejected = "rejected",
    return = "return "
}
declare enum DefaultValueType {
    payment_type = "payment_type",
    currency_code = "currency_code",
    destination = "destination",
    payment_amount = "payment_amount"
}
declare enum AlphaNumeric {
    alpha_numeric = "alpha_numeric",
    numeric = "numeric",
    alphabetic = "alphabetic",
    amount = "amount"
}

interface Checkpoint extends ActiveLessSymfonyModel {
    code: string;
    name: string;
    event: Event;
    isFinisher: boolean;
}
interface CheckpointEventReason extends ActiveLessSymfonyModel {
    code: string;
    name: string;
    extraFields: {
        [key: string]: string;
    };
    checkpoint: Checkpoint | null;
}
interface Incident extends SymfonyModel {
    checkpoint: Checkpoint | null;
    countryId: string;
    event: Event;
    name: string;
    isFinisher: boolean;
}
interface IncidentReason extends SymfonyModel {
    checkpointEventReason: CheckpointEventReason | null;
    description: string;
    incident: Incident | null;
    isDefaultChecking: boolean;
    name: string;
}
interface IncidentReasonComplement extends SymfonyModel {
    alphaNumeric: AlphaNumeric | null;
    eventReasonCodeKey: string;
    description: string;
    defaultValueType: DefaultValueType | null;
    incidentReason: IncidentReason;
    maxLength: number;
    name: string;
    readOnly: boolean;
}
interface PackageMissing {
    id: string;
    shipmentTrackingNumber: string;
    trackingNumber: string;
    checkInOperation: {
        operationType: {
            name: string;
            shortName: string | null;
        };
    };
}
interface ReEntryOfMissingPackage {
    package: PackageMissing;
}
interface ReEntryOfMissingPackages {
    number: string;
    operationPackages: {
        packages: PackageMissing[];
    };
}

type CheckpointsOut = {
    total: number;
    checkpoints: Checkpoint[];
};
type CheckpointEventReasonsOut = {
    total: number;
    checkpointEventReasons: CheckpointEventReason[];
};
type IncidentsOut = {
    total: number;
    incidents: Incident[];
};
type IncidentOut = {
    incident: Incident;
};
type IncidentIn = {
    checkpointId: Number | null;
    countryId: string;
    name: string;
    isActive: boolean;
    event: Event | null;
};
type IncidentReasonsOut = {
    total: number;
    incidentReasons: IncidentReason[];
};
type IncidentReasonOut = {
    incidentReason: IncidentReason;
};
type IncidentReasonIn = {
    checkpointEventReasonId?: number;
    description: string;
    incidentId?: number;
    isActive: boolean;
    name: string;
};
type IncidentReasonComplementsOut = {
    total: number;
    incidentReasonComplements: IncidentReasonComplement[];
};
type IncidentReasonComplementOut = {
    incidentReasonComplement: IncidentReasonComplement;
};
type IncidentReasonComplementIn = {
    alphaNumeric?: AlphaNumeric;
    eventReasonCodeKey: string;
    description: string;
    defaultValueType?: DefaultValueType;
    incidentReasonId?: Number;
    maxLength: number;
    name: string;
    readOnly?: boolean;
    isActive?: boolean;
};
type PackagesInStockIn = {
    packageTrackingNumbers: string[];
};
type PackagesInStockOut = {
    inStock: boolean;
};
type ReEntryOfMissingPackageOut = {
    reEntryOfMissingPackage: ReEntryOfMissingPackage;
};
type ReEntryOfMissingPackagesOut = {
    reEntryOfMissingPackages: ReEntryOfMissingPackages;
};
type ReEntryOfMissingPackagesIn = {
    packagesIds: number[];
};

declare class ApiInventoriesService {
    private environments;
    private http;
    /**
     * Retrieves the URL for the Inventories API from the environment configurations.
     *
     * @return {string} The URL of the Inventories API.
     */
    get url(): string;
    /**
     * Retrieves a list of checkpoints based on query parameters.
     *
     * @param {QueryParams} params - Query parameters for filtering the checkpoints.
     * @returns {Observable<CheckpointsOut>} The list of checkpoints.
     */
    getCheckpoints(params: QueryParams): Observable<CheckpointsOut>;
    /**
     * Retrieves a list of checkpoint event reasons based on query parameters.
     *
     * @param {QueryParams} params - Query parameters for filtering the checkpoint event reasons.
     * @returns {Observable<CheckpointEventReasonsOut>} The list of checkpoint event reasons.
     */
    getCheckpointEventReasons(params: QueryParams): Observable<CheckpointEventReasonsOut>;
    /**
     * Retrieves a list of incidents based on query parameters.
     *
     * @param {QueryParams} params - Query parameters for filtering the incidents.
     * @returns {Observable<IncidentsOut>} An observable that emits the list of incidents.
     */
    getIncidents(params: QueryParams): Observable<IncidentsOut>;
    /**
     * Fetches the incident details based on the provided incident ID.
     *
     * @param {number} id - The identifier of the incident record to get detail.
     * @return {Observable<IncidentOut>} An observable that emits the detail incident data.
     */
    getIncident(id: Number): Observable<IncidentOut>;
    /**
     * Creates a new incident.
     *
     * @param {IncidentIn} body - The data for the new incident.
     * @returns {Observable<IncidentOut>} An observable the created incident detail.
     */
    postIncident(body: IncidentIn): Observable<IncidentOut>;
    /**
     * Updates an existing incident.
     *
     * @param {number} id - The identifier of the incident record to update.
     * @param {IncidentIn} body - The incident data to be updated.
     * @returns {Observable<IncidentOut>} An observable detail of the updated incident.
     */
    putIncident(id: Number, body: IncidentIn): Observable<IncidentOut>;
    /**
     * Delete an existing incident.
     *
     * @param {number} id - The unique identifier of the incident to be deleted.
     * @returns {Observable<IncidentOut>} An observable that emits the result of the delete incident.
     */
    deleteIncident(id: Number): Observable<IncidentOut>;
    /**
     * Retrieves a list of incident reasons based on query parameters.
     *
     * @param {QueryParams} params - Query parameters for filtering the incident reasons.
     * @returns {Observable<IncidentReasonsOut>} An observable that emits the list of incident reasons.
     */
    getIncidentReasons(params: QueryParams): Observable<IncidentReasonsOut>;
    /**
     * Fetches the incident reason details based on the provided incident reason ID.
     *
     * @param {number} id - The identifier of the incident reason record to get detail.
     * @return {Observable<IncidentReasonOut>} An observable that emits the detail incident reason data.
     */
    getIncidentReason(id: Number): Observable<IncidentReasonOut>;
    /**
     * Creates a new incident reason.
     *
     * @param {IncidentReasonIn} body - The data for the new incident reason.
     * @returns {Observable<IncidentReasonOut>} An observable the created incident reason detail.
     */
    postIncidentReason(body: IncidentReasonIn): Observable<IncidentReasonOut>;
    /**
     * Updates an existing incident reason.
     *
     * @param {number} id - The identifier of the incident reason record to update.
     * @param {IncidentIn} body - The incident reason data to be updated.
     * @returns {Observable<IncidentReasonOut>} An observable detail of the updated incident reason.
     */
    putIncidentReason(id: Number, body: IncidentReasonIn): Observable<IncidentReasonOut>;
    /**
     * Delete an existing incident reason.
     *
     * @param {number} id - The unique identifier of the incident reason to be deleted.
     * @returns {Observable<IncidentReasonOut>} An observable that emits the result of the delete incident reason.
     */
    deleteIncidentReason(id: Number): Observable<IncidentReasonOut>;
    /**
     * Retrieves a list of incident reason complements based on query parameters.
     *
     * @param {QueryParams} params - Query parameters for filtering the incident reason complements.
     * @returns {Observable<IncidentReasonComplementsOut>} An observable that emits the list of incident reason complements.
     */
    getIncidentReasonComplements(params: QueryParams): Observable<IncidentReasonComplementsOut>;
    /**
     * Creates a new incident reason complement.
     *
     * @param {IncidentReasonIn} body - The data for the new incident reason complement.
     * @returns {Observable<IncidentReasonComplementOut>} An observable the created incident reason complement detail.
     */
    postIncidentReasonComplement(body: IncidentReasonComplementIn): Observable<IncidentReasonComplementOut>;
    /**
     * Updates an existing incident reason complement.
     *
     * @param {number} id - The identifier of the incident reason complement record to update.
     * @param {IncidentIn} body - The incident reason complement data to be updated.
     * @returns {Observable<IncidentReasonComplementOut>} An observable detail of the updated incident reason complement.
     */
    putIncidentReasonComplement(id: Number, body: IncidentReasonComplementIn): Observable<IncidentReasonComplementOut>;
    /**
     * Delete an existing incident reason complement.
     *
     * @param {number} id - The unique identifier of the incident reason complement to be deleted.
     * @returns {Observable<IncidentReasonComplementOut>} An observable that emits the result of the delete incident reason complement.
     */
    deleteIncidentReasonComplement(id: Number): Observable<IncidentReasonComplementOut>;
    /**
     * Posts packages that are currently in stock.
     *
     * @param body - The input data containing package stock information
     * @returns {Observable<PackagesInStockOut>} An Observable that emits the packages in stock output data
     *
     * @remarks
     * This method sends a POST request to the `/packages/in-stock` endpoint and
     * extracts the data property from the API success response.
     */
    postPackagesInStock(body: PackagesInStockIn): Observable<PackagesInStockOut>;
    /**
     * Fetches the missing package details based on query parameters.
     *
     * @param {QueryParams} params - The query parameters for filtering the missing package details.
     * @return {Observable<ReEntryOfMissingPackageOut>} An observable that emits the detail missing package data.
     */
    getReEntryOfMissingPackages(params: QueryParams): Observable<ReEntryOfMissingPackageOut>;
    /**
     * Re-entry missing packages
     *
     * @param {ReEntryOfMissingPackagesIn} body - The missing packages data to be re-entry.
     * @returns {Observable<ReEntryOfMissingPackagesOut>} An observable detail of the updated incident reason complement.
     */
    putReEntryOfMissingPackages(body: ReEntryOfMissingPackagesIn): Observable<ReEntryOfMissingPackagesOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiInventoriesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiInventoriesService>;
}

interface Document extends LaravelModel {
    document_type_range_id: number;
    document_number: number;
    document_prefix: string;
    document_suffix: string;
    document_number_original: number;
    document_prefix_original: string;
    document_suffix_original: string;
    customer_id: number;
    customer_company_name: string;
    customer_email: string;
    customer_address_line1: string;
    customer_identification_number: string;
    customer_identification_type_id: number;
    provider_name: string;
    provider_identification_number: number;
    document_authorization_number: string;
    provider_extra_fields: {
        phone: string;
        fax: string;
    };
    document_id: number;
    transaction_id: string;
    extra_fields: {
        observation: string;
        document_date: string;
    };
    customer_address_line2: string;
    customer_address_line3: string;
    customer_postal_code: string;
    customer_state: string;
    customer_county_name: string;
    customer_city_name: string;
    customer_country_id: number;
    status: number;
    user_id: number;
    customer_full_name: string;
    customer_phone_code: string;
    customer_phone_number: string;
    gmt_offset: string;
    customer_type_id: number;
    customer_extra_fields: string;
    installation_id: number;
    exchange: number;
    authorization_numbers: string;
    extra_fields_json: string;
    provider_extra_fields_json: string;
    document_type_range: DocumentTypeRange;
    items: DocumentItem[];
    document_payments: DocumentPayment[];
    payments: Payment[];
    document: Document | null;
}
interface DocumentTypeRange extends LaravelModel {
    activation_key: string | null;
    authorization_label: string | null;
    authorization_number: string | null;
    auto_activation: boolean;
    country_document_type_id: number;
    current_number: number;
    days_until_expire_mail: number;
    environment: string;
    external_generated: boolean;
    final_number: number;
    init_number: number;
    is_manual: boolean;
    min_until_mail: number;
    model_id: number;
    model_type: string;
    prefix: string;
    provider_id: number;
    sap_prefix: string;
    sap_suffix: string | null;
    suffix: string | null;
    used_numbers: number;
    valid_since: string;
    valid_until: string;
}
interface DocumentItem extends LaravelModel {
    id: number;
    document_id: number;
    details: {
        code: string;
        description: string;
        relation: string;
    } | {
        code: string;
        description: string;
        header: {
            awbNumber: string;
            accountNumber: string;
            pieces: string[];
            total: number;
        };
        ticket_data: Record<string, string | null>;
    } | {
        account: number;
        country_reference_currency_id: number;
        customer_company_name: string;
    };
    model_origin: string;
    model_type: string;
    model_id: number;
    quantity: number;
    unit_price: number;
    subtotal: number;
    tax_detail: {};
    total: number;
    created_at: string;
    updated_at: string;
    discount: 0;
    details_json: string;
}
interface DocumentPayment extends LaravelModel {
    document_id: number;
    payment_id: number;
    amount: number;
    payment: Payment;
}
interface Payment extends LaravelModel {
    amount: number;
    country_reference_currency_id: number;
    exchange: number;
    company_country_payment_type_id: number;
    due_date: string;
    received: number;
    status: number;
    details: {};
    transaction_id: string;
    gmt_offset: string;
    country_payment_type_id: number;
    opening_id: number;
    installation_id: number;
    details_json: string;
    payment_adjustment: {};
    pivot: {
        document_id: number;
        payment_id: number;
        amount: number;
    };
    countryPaymentType: CountryPaymentType;
}
interface Customer extends LaravelModel {
    identification_number: number;
    company_name: string;
    full_name: string;
    email: string;
    phone_code: string | null;
    phone_number: number | null;
    birth_date: string | null;
    postal_code: number | null;
    state: string | null;
    county_name: string | null;
    city_name: string | null;
    address_line1: string;
    address_line2: string | null;
    address_line3: string | null;
    company_id: number;
    identification_type_id: number;
    extra_fields: Record<string, string | number | boolean | null>;
    country_id: number;
    customer_type_id: number;
}
interface CustomerType extends LaravelModel {
    country_id: number;
    identification_type_customer_types: IdentificationTypeCustomer[];
    name: string;
}
interface IdentificationTypeCustomer extends LaravelModel {
    customer_type_id: number;
    identification_type_id: number;
    customer_id: number | null;
    identificationType: IdentificationType;
}
interface CountryPaymentType extends LaravelModel {
    payment_type_id: number;
    country_id: number;
    name: string;
    billing_payment_code: string;
    can_tolerance: boolean;
    code: string;
    country_payment_type_fields: CountryPaymentTypeField[];
    payment_type: PaymentType;
    translations: Translations;
    accountable_account: string | null;
    accountable_account_usd: string | null;
    item_text_code: string | null;
}
interface CountryPaymentTypeField extends LaravelModel {
    country_payment_type_id: number;
    code: string;
    name: string;
    description: string | null;
    format: string;
    is_required: boolean;
    catalog: string[] | null;
    regex: string | null;
    is_interface: boolean;
    is_bank_reference: boolean;
}
interface PaymentType extends LaravelModel {
    code: string;
    fields: {
        [key: string]: string;
    };
    name: string;
}
interface PaymentTypeFieldCardType extends LaravelModel {
    country_payment_type_field_id: number;
    name: string;
    code: string;
    accountable_account: string;
    accountable_account_usd: string | null;
}
interface PaymentTypeFieldAccount extends LaravelModel {
    country_payment_type_field_id: number;
    name: string;
    account: string;
    accountable_account: string;
    currency_id: number;
    currency: Currency;
}
interface Tolerance extends LaravelModel {
    tolerance_type: number;
    min_amount: number;
    max_amount: number;
    tolerance: number;
}
interface CustomerCountryDocumentType extends LaravelModel {
    identification_type_customer_type_id: number;
    country_document_type_id: number;
    country_document_type: CountryDocumentType;
}
interface CountryDocumentType extends LaravelModel {
    document_type_id: number;
    document_category_id: number;
    country_id: number;
    associated_payment: boolean;
    name: string;
    document_type: DocumentType;
    document_category: DocumentCategory;
}
interface DocumentType extends LaravelModel {
    name: string;
    code: string;
    movement_type: number;
    local_code: string;
}
interface DocumentCategory extends LaravelModel {
    name: string;
    code: string;
    is_electronic: boolean;
    taxable: number;
}
interface DocumentRequests extends ActiveLessLaravelModel {
    document_id: string;
    document_status_code: string;
    service: string;
    times: string[];
    observation: string;
}
interface DocumentStatus extends LaravelModel {
    name: string;
    code: number;
}
interface Provider extends LaravelModel {
    model_type: string;
    model_id: number;
    busyness_name: string;
    identification_number: string;
    identification_type_id: number;
    address_line1: string;
    address_line2: string;
    address_line3: string;
    extra_fields: [];
    company_country_id: number;
    footer: string;
}

interface OperationAccountPaymentIn {
    document_type_range_id: number | null;
    document_number: string | null;
    observation: string | null;
    document_date: string | null;
    total_amount: number;
    country_reference_currency_id: number;
    customer: {
        company_name: string;
        full_name: string;
        account_number: string;
        country_id: number;
    };
    payments: AccountPayment[];
}
type AccountPayment = {
    country_payment_type_id: number;
    country_reference_currency_id: number;
    amount: number;
    exchange: string;
    due_date: string;
    received: number;
    status?: boolean;
    details?: {};
};
interface OperationAccountPaymentOut {
    document: Document;
    transaction_id: string;
}
type PrintCollectionReceiptOut = {
    collection_receipt: string;
};
type CancelPaymentReceiptIn = {
    document_id: number;
    is_canceled_invoice: boolean;
    cancellation_reason_id: number;
};
type OperationCancelBillingIn = {
    invoiceId: number;
    cancellation_reason_id: number;
    cancel_payment: boolean;
    send_shipments: boolean;
    local_cancel?: boolean;
};
type OperationCancelBillingOut = {
    creditNoteDocument: Document | null;
};
type OperationDocumentIn = {
    country_document_type_id: number;
    document_id: number;
    customer: {
        customer_type_id: number;
        company_name: string;
        full_name: string;
        email: string;
        phone_code: string | null;
        phone_number: string | null;
        address_line1: string | null;
        address_line2: string | null;
        address_line3: string | null;
        identification_number: string;
        identification_type_id: number;
        postal_code: string | null;
        state: string | null;
        county_name: string | null;
        city_name: string | null;
        country_id: number;
        extra_fields: {
            [key: string]: string | number | boolean;
        } | null;
    };
    document_extra_fields: {
        [key: string]: string | number | boolean;
    } | null;
};
type OperationDocumentOut = {
    document: Document;
};
type InvoiceTypeCustomParamsIn = {
    identificationNumber: string;
    identificationTypeid: number;
};
type OperationPrintDocumentOut = {
    document: string;
};
type CustomerTypesOut = {
    customer_types: CustomerType[];
    total: number;
};
type CustomersOut = {
    customers: Customer[];
};
type OperationShipmentExternalOut = {
    document: Document;
};
type OperationShipmentExternalIn = {};
type CustomerDocumentTypesOut = {
    customer_country_document_types: CustomerCountryDocumentType[];
    total: number;
};
type CountryPaymentTypesOut = {
    country_payment_types: CountryPaymentType[];
    total: number;
};
type CountryPaymentTypeOut = {
    country_payment_type: CountryPaymentType;
};
type CountryPaymentTypeIn = {
    payment_type_id: number;
    country_id: number;
    name: string;
    billing_payment_code: string;
    can_tolerance: boolean;
    is_active: boolean;
    accountable_account: string | null;
    accountable_account_usd: string | null;
    item_text_code: string | null;
};
type CountryPaymentTypeFieldsOut = {
    country_payment_type_fields: CountryPaymentTypeField[];
    total: number;
};
type CountryPaymentTypeFieldOut = {
    country_payment_type_field: CountryPaymentTypeField;
};
type CountryPaymentTypeFieldIn = {
    country_payment_type_id: number;
    code: string;
    name: string;
    description: string | null;
    format: string;
    is_required: boolean;
    catalog: string[] | null;
    is_interface: boolean;
};
type PaymentTypesOut = {
    payment_types: PaymentType[];
    total: number;
};
type PaymentTypeFieldCardTypesOut = {
    country_payment_type_field_card_types: PaymentTypeFieldCardType[];
    total: number;
};
type PaymentTypeFieldCardTypeIn = {
    country_payment_type_field_id: number;
    name: string;
    code: string;
    accountable_account: string;
    is_active: boolean;
};
type PaymentTypeFieldCardTypeOut = {
    country_payment_type_field_card_type: PaymentTypeFieldCardType;
};
type PaymentTypeFieldAccountsOut = {
    country_payment_type_field_accounts: PaymentTypeFieldAccount[];
    total: number;
};
type PaymentTypeFieldAccountIn = {
    country_payment_type_field_id: number;
    name: string;
    account: string;
    accountable_account: string;
    currency_id: number;
    is_active: boolean;
};
type PaymentTypeFieldAccountOut = {
    country_payment_type_field_account: PaymentTypeFieldAccount;
};
type TolerancesOut = {
    tolerances: Tolerance[];
    total: number;
};
type ToleranceIn = {
    company_country_id: number;
    tolerance_type: number;
    min_amount: number;
    max_amount: number;
    tolerance: number;
    is_active: boolean;
};
type ToleranceOut = {
    tolerance: Tolerance;
};
type OperationDocumentRequestsOut = {
    requests: DocumentRequests[];
};
type GetDocumentsOut = {
    documents: Document[];
    total: number;
};
type DocumentStatusesOut = {
    document_status: DocumentStatus[];
    total: number;
};
type OperationPrintXmlOut = {
    xml: string;
};
type DocumentTypeRangesOut = {
    document_type_ranges: DocumentTypeRange[];
    total: number;
};
type DocumentTypeRangeIn = {
    activation_key?: string;
    authorization_label?: string;
    authorization_number?: string;
    auto_activation: boolean;
    country_document_type_id: number;
    current_number: number;
    days_until_expire_mail: number;
    environment?: string;
    external_generated?: boolean;
    final_number: number;
    init_number: number;
    is_active: boolean;
    is_manual?: boolean;
    min_until_mail: number;
    model_id: number;
    model_type: string;
    prefix: string;
    provider_id: number;
    sap_prefix: string;
    sap_suffix?: string;
    suffix?: string;
    used_numbers?: number;
    valid_since: string;
    valid_until: string;
};
type DocumentTypeRangeOut = {
    document_type_range: DocumentTypeRange;
};
interface ProvidersOut {
    providers: Provider[];
    total: number;
}
interface CountryDocumentTypesOut {
    country_document_types: CountryDocumentType[];
    total: number;
}
interface DocumentsTypesRangesCurrentStatusOut {
    invoices: {
        country_document_type_id: number;
        country_document_type_name: string;
        has_active_range: boolean;
    }[];
    collections: boolean;
}

declare class ApiInvoicesService {
    private environments;
    private http;
    /**
     * Retrieves the API URL for invoices from the environments configuration.
     *
     * @return {string} The API URL for invoices.
     */
    get url(): string;
    /**
     * Sends an operation document to the server and processes the response.
     *
     * @param {OperationDocumentIn} body - The input data for the operation document.
     * @return {Observable<OperationDocumentOut>} An observable containing the processed operation document output.
     */
    postOperationDocument(body: OperationDocumentIn): Observable<OperationDocumentOut>;
    /**
     * Fetches and returns the collection receipt data for a given collection ID.
     *
     * @param {number} id - The unique identifier of the collection for which the receipt needs to be retrieved.
     * @return {Observable<PrintCollectionReceiptOut>} An observable containing the collection receipt data.
     */
    getPrintCollectionReceipt(id: number): Observable<PrintCollectionReceiptOut>;
    /**
     * Handles the account payment operation by sending a POST request to the specified endpoint.
     * Processes the response and returns the operation data.
     *
     * @param {OperationAccountPaymentIn} body The payload containing information for the account payment operation.
     * @return {Observable<OperationAccountPaymentOut>} An observable emitting the processed account payment operation data.
     */
    postOperationAccountPayment(body: OperationAccountPaymentIn): Observable<OperationAccountPaymentOut>;
    /**
     * Cancels a payment receipt based on the provided input.
     * This method sends a POST request to cancel a document.
     *
     * @param body The data required to cancel the payment receipt, encapsulated in a CancelPaymentReceiptIn object.
     * @return An Observable representing the result of the cancellation. Emits an empty object on success.
     */
    postOperationCancelDocument(body: CancelPaymentReceiptIn): Observable<{}>;
    /**
     * Sends a POST request to cancel billing for a specific operation.
     *
     * @param {Object} params - The parameters for the cancellation request.
     * @param {string} params.invoiceId - The ID of the invoice to be canceled.
     * @param {Object} params.body - Additional data to be sent in the request body.
     * @return {Observable<OperationCancelBillingOut>} An observable emitting the result of the cancellation operation.
     */
    postOperationCancelBilling({ invoiceId, ...body }: OperationCancelBillingIn): Observable<OperationCancelBillingOut>;
    /**
     * Fetches a list of customer types from the server.
     *
     * @param {QueryParams} params - Query parameters to filter or customize the request.
     * @return {Observable<CustomerTypesOut>} An observable emitting the customer types fetched from the server.
     */
    getCustomerTypes(params: QueryParams): Observable<CustomerTypesOut>;
    /**
     * Retrieves document types specific to a given country.
     *
     * @param {QueryParams} params - The query parameters containing country-specific information.
     * @return {Observable<CustomerDocumentTypesOut>} An observable emitting the document types available for the specified country.
     */
    getCustomerDocumentTypes(params: QueryParams): Observable<CustomerDocumentTypesOut>;
    /**
     * Fetches customer invoice details filtered by a custom invoice type.
     *
     * @param {InvoiceTypeCustomParamsIn} params - An object containing the filter parameters for the custom invoice type.
     * @return {Observable<CustomersOut>} An observable containing customer invoice details of the specified type.
     */
    getCustomers(params: QueryParams): Observable<CustomersOut>;
    /**
     * Sends a POST request to create or update an external shipment operation.
     *
     * @param {OperationShipmentExternalIn} params - The input parameters for the external shipment operation.
     * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external shipment operation.
     */
    postOperationShipmentExternal(params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut>;
    /**
     * Processes an external payment operation for a shipment.
     *
     * @param {OperationShipmentExternalIn} params - The input parameters required for the external payment operation.
     * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external payment operation for a shipment.
     */
    postOperationShipmentExternalPayment(params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut>;
    /**
     * Retrieves and returns billing operation print details for a given document ID.
     *
     * @param {number} documentId - The ID of the document for which to fetch the print billing operation details.
     * @return {Observable<OperationPrintDocumentOut>} An observable emitting the print billing operation details for the specified document.
     */
    getOperationPrintDocument(documentId: number): Observable<OperationPrintDocumentOut>;
    /**
     * Fetches all country payment types.
     *
     * @param {QueryParams} params - Query parameters to filter or customize the request.
     * @return {Observable<CountryPaymentTypesOut>} An observable emitting the country payment types fetched from the server.
     */
    getCountryPaymentTypes(params: QueryParams): Observable<CountryPaymentTypesOut>;
    /**
     * Updates an existing country payment type.
     *
     * @param {number} id - The ID of the country payment type to update.
     * @param {CountryPaymentTypeIn} body - The updated data for the country payment type.
     * @returns {Observable<CountryPaymentTypeOut>} An observable that emits the result of the update operation.
     */
    putCountryPaymentType(id: number, body: CountryPaymentTypeIn): Observable<CountryPaymentTypeOut>;
    /**
     * Delete an existing country payment type.
     *
     * @param {number} id - The unique identifier of the country payment type to be deleted.
     * @returns {Observable<CountryPaymentTypeOut>} An observable that emits the result of the delete operation.
     */
    deleteCountryPaymentType(id: number): Observable<CountryPaymentTypeOut>;
    /**
     * Create a new country payment type resource.
     *
     * @param {CountryPaymentTypeIn} body - The input parameters required for create a new country payment type.
     * @return {Observable<CountryPaymentTypeOut>} An observable that emits the result of create operation.
     */
    postCountryPaymentType(body: CountryPaymentTypeIn): Observable<CountryPaymentTypeOut>;
    /**
     * Retrieves and returns a country payment type for a given ID.
     *
     * @param {number} id - The ID of the country payment type.
     * @return {Observable<CountryPaymentTypeOut>} An observable that emits the result of show operation.
     */
    getCountryPaymentType(id: number): Observable<CountryPaymentTypeOut>;
    /**
     * Fetches all country payment type fields.
     *
     * @param {QueryParams} params - Query parameters to filter or customize the request.
     * @return {Observable<CountryPaymentTypeFieldsOut>} An observable emitting the country payment type fields fetched from the server.
     */
    getCountryPaymentTypeFields(params: QueryParams): Observable<CountryPaymentTypeFieldsOut>;
    /**
     * Create a new country payment type field resource.
     *
     * @param {CountryPaymentTypeFieldIn} body - The input parameters required for create a new country payment type field.
     * @return {Observable<CountryPaymentTypeFieldOut>} An observable that emits the result of create operation.
     */
    postCountryPaymentTypeField(body: CountryPaymentTypeFieldIn): Observable<CountryPaymentTypeFieldOut>;
    /**
     * Updates an existing country payment type field.
     *
     * @param {number} id - The ID of the country payment type field to update.
     * @param {CountryPaymentTypeFieldIn} body - The updated data for the country payment type field.
     * @returns {Observable<CountryPaymentTypeFieldOut>} An observable that emits the result of the update operation.
     */
    putCountryPaymentTypeField(id: number, body: CountryPaymentTypeFieldIn): Observable<CountryPaymentTypeFieldOut>;
    /**
     * Fetches all payment types.
     *
     * @param {QueryParams} params - Query parameters to filter or customize the request.
     * @return {Observable<PaymentTypesOut>} An observable emitting the payment types fetched from the server.
     */
    getPaymentTypes(params: QueryParams): Observable<PaymentTypesOut>;
    /**
     * Fetches all payment type fields card.
     *
     * @param {QueryParams} params - Query parameters to filter or customize the request.
     * @return {Observable<PaymentTypeFieldCardTypesOut>} An observable emitting the payment type fields card fetched from the server.
     */
    getPaymentTypeFieldCardTypes(params: QueryParams): Observable<PaymentTypeFieldCardTypesOut>;
    /**
     * Create a new payment type field card resource.
     *
     * @param {PaymentTypeFieldCardTypeIn} body - The input parameters required for create a new payment type field card.
     * @return {Observable<PaymentTypeFieldCardTypeOut>} An observable that emits the result of create operation.
     */
    postCountryPaymentTypeFieldCardType(body: PaymentTypeFieldCardTypeIn): Observable<PaymentTypeFieldCardTypeOut>;
    /**
     * Updates an existing payment type field card.
     *
     * @param {number} id - The ID of the payment type field card to update.
     * @param {PaymentTypeFieldCardTypeIn} body - The updated data for the payment type field card.
     * @returns {Observable<PaymentTypeFieldCardTypeOut>} An observable that emits the result of the update operation.
     */
    putCountryPaymentTypeFieldCardType(id: number, body: PaymentTypeFieldCardTypeIn): Observable<PaymentTypeFieldCardTypeOut>;
    /**
     * Fetches all payment type fields accounts.
     *
     * @param {QueryParams} params - Query parameters to filter or customize the request.
     * @return {Observable<PaymentTypeFieldAccountsOut>} An observable emitting the payment type fields accounts fetched from the server.
     */
    getPaymentTypeFieldAccounts(params: QueryParams): Observable<PaymentTypeFieldAccountsOut>;
    /**
     * Create a new payment type field account resource.
     *
     * @param {PaymentTypeFieldAccountIn} body - The input parameters required for create a new payment type field account.
     * @return {Observable<PaymentTypeFieldAccountOut>} An observable that emits the result of create operation.
     */
    postCountryPaymentTypeFieldAccount(body: PaymentTypeFieldAccountIn): Observable<PaymentTypeFieldAccountOut>;
    /**
     * Updates an existing payment type field account.
     *
     * @param {number} id - The ID of the payment type field account to update.
     * @param {PaymentTypeFieldAccountIn} body - The updated data for the payment type field account.
     * @returns {Observable<PaymentTypeFieldAccountOut>} An observable that emits the result of the update operation.
     */
    putCountryPaymentTypeFieldAccount(id: number, body: PaymentTypeFieldAccountIn): Observable<PaymentTypeFieldAccountOut>;
    /**
     * Fetches tolerance data from the server based on the provided query parameters.
     *
     * @param {QueryParams} params - The parameters to use for querying tolerances.
     * @return {Observable<TolerancesOut>} An observable emitting the tolerance data.
     */
    getTolerances(params: QueryParams): Observable<TolerancesOut>;
    /**
     * Retrieves the tolerance detail for a given identifier.
     *
     * @param {number} id - The unique identifier for the tolerance to retrieve.
     * @return {Observable<ToleranceOut>} An observable containing the tolerance data.
     */
    getTolerance(id: number): Observable<ToleranceOut>;
    /**
     * Sends a request to update or create a tolerance record using the provided data.
     *
     * @param {ToleranceIn} body - The tolerance input object containing the data to be sent in the request.
     * @return {Observable<ToleranceOut>} An observable that emits the updated or created tolerance output object.
     */
    postTolerance(body: ToleranceIn): Observable<ToleranceOut>;
    /**
     * Updates the tolerance with the specified ID using the provided data.
     *
     * @param {number} id - The unique identifier of the tolerance to update.
     * @param {ToleranceIn} body - The data to update the tolerance with.
     * @return {Observable<ToleranceOut>} An observable containing the updated tolerance information.
     */
    putTolerance(id: number, body: ToleranceIn): Observable<ToleranceOut>;
    /**
     * Deletes the tolerance entry corresponding to the given ID.
     *
     * @param {number} id - The unique identifier of the tolerance to be deleted.
     * @return {Observable<{}>} An Observable that emits the result of the delete operation.
     */
    deleteTolerance(id: number): Observable<{}>;
    /**
     * Retrieves the document requests associated with a document ID.
     *
     * @param id - The unique identifier for the document.
     * @returns An observable that emits the document requests data.
     */
    getOperationDocumentRequests(id: number): Observable<OperationDocumentRequestsOut>;
    /**
     * Retrieves a list of documents based on the provided query parameters.
     *
     * @param params - The query parameters to filter and paginate the documents
     * @returns An Observable that emits the documents data when the HTTP request completes
     */
    getDocuments(params: QueryParams): Observable<GetDocumentsOut>;
    /**
     * Fetches document status values from the API.
     *
     * Sends an HTTP GET request to the service's `/document-status` endpoint using the supplied query parameters
     * and returns the decoded `data` payload from the API success envelope.
     *
     * @param params - Query parameters to apply to the request (e.g. filtering, pagination, search).
     * @returns An Observable that emits a DocumentStatusesOut object containing the document status data.
     */
    getDocumentStatuses(params: QueryParams): Observable<DocumentStatusesOut>;
    /**
     * Retrieves the XML print representation for a given operation (invoice).
     *
     * Sends an HTTP GET request to the backend endpoint `/operation/print/xml/{documentId}` and
     * unwraps the `data` field from the API success response before emitting it.
     *
     * @param documentId - The numeric identifier of the document to fetch.
     * @returns An Observable that emits the OperationPrintXmlOut payload on success and completes.
     *          The Observable will error if the HTTP request fails or the response does not contain the expected data.
     */
    getOperationPrintXml(documentId: number): Observable<OperationPrintXmlOut>;
    /**
     * Retrieves a list of providers based on the provided query parameters.
     * @param params - Query parameters to filter or paginate the providers list
     * @returns An Observable that emits the providers data
     */
    getProviders(params: QueryParams): Observable<ProvidersOut>;
    /**
     * Retrieves the document type ranges based on the provided query parameters.
     * @param params - The query parameters to filter document type ranges
     * @returns An Observable that emits the document type ranges data
     */
    getDocumentsTypesRanges(params: QueryParams): Observable<DocumentTypeRangesOut>;
    /**
     * Retrieves the currently active document type ranges.
     *
     * @returns {Observable<DocumentsTypesRangesCurrentStatusOut>} An observable that emits the currently active document type ranges data.
     */
    getDocumentsTypesRangesCurrentStatus(): Observable<DocumentsTypesRangesCurrentStatusOut>;
    /**
     * Creates a new document type range.
     * @param body - The document type range data to create
     * @returns An observable that emits the created document type range
     */
    postDocumentTypeRange(body: DocumentTypeRangeIn): Observable<DocumentTypeRangeOut>;
    /**
     * Deletes a document type range by its identifier.
     * @param id - The unique identifier of the document type range to delete
     * @returns An Observable that emits the deleted DocumentTypeRangeOut object
     */
    deleteDocumentsTypesRange(id: number): Observable<{}>;
    /**
     * Updates a document type range for a given ID.
     * @param id - The unique identifier of the document type range to update
     * @param data - The document type range data to update
     * @returns An Observable that emits the updated DocumentTypeRangeOut object
     */
    putDocumentsTypeRange(id: number, data: DocumentTypeRangeIn): Observable<DocumentTypeRangeOut>;
    /**
     * Retrieves the list of document types available for a specific country.
     * @param params - Query parameters to filter or customize the country document types request
     * @returns Observable containing the country document types data
     */
    getCountryDocumentsTypes(params: QueryParams): Observable<CountryDocumentTypesOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiInvoicesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiInvoicesService>;
}

interface Notification extends SymfonyModel {
    name: string;
    notificationType: NotificationType;
    notificationStatus: NotificationStatus;
    userId: string;
    content: string;
    url: string;
    image: string;
    starDate: string;
    endDate: string;
    countryId: string;
}
interface NotificationConfiguration extends SymfonyModel {
    notification: Notification;
    entity: Entity;
}
interface NotificationType extends SymfonyModel {
    name: string;
}
interface NotificationStatus extends SymfonyModel {
    name: string;
}
interface Entity {
    id: number;
    level: string;
    modelId: string;
    modelType: string;
    extraFields: {
        countryId: number;
        companyCountryId: number;
        locationId: number;
        installationId: number;
        systemId: number;
    };
}

type NotificationsOut = {
    notifications: Notification[];
    total: number;
};
type NotificationIn = {
    name: string;
    notificationTypeId: number;
    userId?: string;
    content: string;
    url: string;
    image: string;
    starDate: string;
    endDate: string;
    isActive: boolean;
};
type NotificationOut = {
    notification: Notification;
};
type NotificationConfigurationIn = {
    modelId: number[];
    modelType: string;
    notificationId: number;
    extraFields: {
        [key: string]: string;
    };
};
type NotificationConfigurationOut = {
    notificationConfiguration: NotificationConfiguration;
};
type NotificationsTypeOut = {
    notificationTypes: NotificationType[];
    total: number;
};

declare class ApiNotificationsService {
    private environments;
    private 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(): string;
    /**
     * 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: QueryParams): Observable<NotificationsOut>;
    /**
     * 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: NotificationIn): Observable<NotificationOut>;
    /**
     * 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: number, body: NotificationIn): Observable<NotificationOut>;
    /**
     * 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: number): Observable<{}>;
    /**
     * 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: number): Observable<NotificationOut>;
    /**
     * 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: NotificationConfigurationIn): Observable<NotificationConfigurationOut>;
    /**
     * 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: QueryParams): Observable<NotificationsTypeOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiNotificationsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiNotificationsService>;
}

type CustomerOpenItem = {
    company_name: string;
    full_name: string;
    email: string;
    phone_code: string;
    phone_number: string;
    address_line1: string;
    address_line2: string;
    address_line3: string;
    identification_number: string;
    identification_type_id: number;
    postal_code: string;
    state: string;
    county_name: string;
    city_name: string;
    country_id: number;
};
type CustomerOtherInvoice = {
    identification_number: string;
    company_name: string;
    full_name: string;
    account_number: string;
    country_id: number;
};
type OpenItems = {
    id: string;
    payed_value: number;
};
type OpenItemsOut = {
    open_items: OpenItem[];
    total: number;
};
type OtherInvoices = {
    invoice_number: string;
    shipment_tracking_number: string;
    invoice_issue_datetime: string;
    pending_value: number;
    customer_identification_number: string;
};
type PaymentDetail = {
    amount: number;
    received: number;
    country_reference_currency_id: number;
    exchange: string | number;
    country_payment_type_id: number;
    due_date: string;
    details: {
        [key: string]: string;
    };
};
type PaymentOut = {
    document: Document;
};
type OtherInvoiceOut = {
    document: Document;
};

interface OpenItem {
    id: number;
    invoice_number: string;
    shipment_tracking_number: string;
    invoice_issue_datetime: Date | string;
    invoice_expiration_datetime: Date | string;
    customer_identification_number: string;
    customer_company_name: string;
    account: string;
    country_reference_currency_id: number;
    pending_value: number;
    payed_value: number;
    is_cash: boolean;
    status: string;
    origin: string;
    user_id: string | null;
}
interface OpenItemIn {
    payments: PaymentDetail[];
    customer: CustomerOpenItem | CustomerOtherInvoice;
    document_type_range_id: number;
    document_number: string;
    observation: string;
    document_date: Date;
}
interface PaymentOpenItemIn extends OpenItemIn {
    open_items: OpenItems[];
}
interface OtherInvoiceIn extends OpenItemIn {
    other_invoices: OtherInvoices[];
}

declare class ApiOpenItemsService {
    private environments;
    private http;
    /**
     * Retrieves the API URL for open-items from the environments' configuration.
     *
    * @returns {string} The API URL for open-items.
     */
    get url(): string;
    /**
     * Retrieves a list of open-items based on the provided query parameters.
     *
     * @param {QueryParams} params - The parameters to use for querying open-items.
    * @returns {Observable<OpenItemsOut>} An observable that emits the open-item data.
     */
    getOpenItems(params: QueryParams): Observable<OpenItemsOut>;
    /**
     * Processes a payment for an open item.
     *
     * @param {PaymentOpenItemIn} body - The payment details for the open item.
    * @returns {Observable<PaymentOut>} An observable that emits the result of the payment processing.
     */
    postPayment(body: PaymentOpenItemIn): Observable<PaymentOut>;
    /**
     * Processes a payment for other invoice.
     *
     * @param {OtherInvoiceIn} body - The payment details for the other invoice.
    * @returns {Observable<OtherInvoiceOut>} An observable that emits the result of the payment processing.
     */
    postOtherInvoice(body: OtherInvoiceIn): Observable<OtherInvoiceOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiOpenItemsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiOpenItemsService>;
}

interface QuoteEvent extends ActiveLessSymfonyModel {
    date: string;
    quoteEventType: QuoteEventType;
    comment: string;
    userId: number;
    userUsername: string;
    userName: string;
}
interface QuoteEventType extends SymfonyModel {
    code: string;
    name: string;
}

type QuoteEventsOut = {
    total: number;
    quoteEvents: QuoteEvent[];
};
type QuoteEventIn = {
    date: string;
    quoteEventTypeId: number;
    comment: string;
};
interface QuoteEventOut {
    quoteEvent: QuoteEvent;
}
interface QuoteEventTypesOut {
    total: number;
    quoteEventTypes: QuoteEventType[];
}

declare class ApiQuoteService {
    private environments;
    private http;
    /**
     * Base URL for the Quotes API.
     */
    get url(): string;
    /**
     * Retrieves all registered events for a specific quote.
     *
     * @param id - Quote identifier.
     * @param params - Optional query parameters such as pagination or filtering.
     * @returns Observable containing the list of quote events.
     *
     * @example
     * ```ts
     * this.apiQuoteService.getQuoteEvents(10, { page: 1 })
     *   .subscribe((events) => console.log(events))
     * ```
     */
    getQuoteEvents(id: number, params: QueryParams): Observable<QuoteEventsOut>;
    /**
     * Registers a new event related to a specific quote.
     *
     * @param id - Quote identifier.
     * @param body - Event payload to be created.
     * @returns Observable containing the newly created event.
     *
     * @example
     * ```ts
     * const event: QuoteEventIn = { code: 'WON', note: 'Client approved' }
     * this.apiQuoteService.postQuoteEvents(10, event)
     *   .subscribe((response) => console.log(response))
     * ```
     */
    postQuoteEvents(id: number, body: QuoteEventIn): Observable<QuoteEventOut>;
    /**
     * Retrieves the available quote event types.
     *
     * @param params - Optional query parameters such as pagination or filtering.
     * @returns Observable containing the list of event types.
     *
     * @example
     * ```ts
     * this.apiQuoteService.getQuoteEventTypes({ page: 1 })
     *   .subscribe((types) => console.log(types))
     * ```
     */
    getQuoteEventTypes(params: QueryParams): Observable<QuoteEventTypesOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiQuoteService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiQuoteService>;
}

interface CollectionPayment extends LaravelModel {
    _id: number;
    country_code: string;
    country_id: number;
    country_name: string;
    company_id: number;
    company_name: string;
    company_country_id: number;
    installation_id: number;
    installation_number: number;
    location_facility_code: string;
    location_id: number;
    location_location_code: string;
    location_name: string;
    user_id: number;
    user_username: string;
    document_type_id: number;
    document_type: DocumentTypeReports;
    document_category_id: number;
    document_category: DocumentCategoryReports;
    receipt_number: string;
    customer_name: string;
    account: string;
    amount: number;
    currency_id: number;
    currency_code: string;
    operation_type_id: number;
    operation_type: OperationType;
}
interface DocumentTypeReports extends LaravelModel {
    _id: number;
    name: string;
    code: string;
    movement_type: number;
    local_code: string;
    translations: Translations;
}
interface DocumentCategoryReports extends LaravelModel {
    _id: number;
    name: string;
    is_electronic: true;
    taxable: number;
    created_at: string;
    updated_at: string;
    translations: Translations;
}
interface ShipmentReports {
    authorization_numbers: string[];
    commercial_invoice: boolean;
    company_name: string;
    country_id: number;
    country_name: string;
    currency_code: string;
    customer_identification_number: string | null;
    customer_identification_type_id: number | null;
    document_id: number;
    id: number;
    installation_id: number;
    installation_number: number;
    invoice_document_id: number | null;
    is_document: boolean;
    is_manual: boolean;
    itn_number: string | null;
    location_id: number;
    location_name: string;
    price_override_approver_name: string | null;
    price_override_reason_name: string | null;
    product_subtotal: number;
    product_tax: number;
    question_description: string | null;
    receiver_company_name: string;
    receiver_full_name: string;
    send_to_api_inventories: boolean;
    shipment_id: number;
    shipment_pieces_tracking_numbers: string[];
    shipment_status_code: string;
    shipment_status_description: string;
    shipment_status_id: number;
    shipment_status_translations: Translations;
    shipment_tags: ShipmentTag[];
    shipment_tracking_number: string;
    shipment_type: string;
    shipment_value: string;
    shipper_account: string;
    shipper_address_line1: string;
    shipper_address_line2: string | null;
    shipper_address_line3: string | null;
    shipper_city_name: string;
    shipper_company_name: string;
    shipper_email: string;
    shipper_full_name: string;
    shipper_full_phone_number: string;
    shipper_identification_number: string | null;
    shipper_phone_number: string;
    shipper_postal_code: string;
    shipper_state_name: string | null;
    subtotal: number;
    tax: number;
    total: number;
    tracking: string | null;
    updated_at: string;
    user_id: number;
    user_username: string;
    additional_documents: {
        country_id: number;
        include_indemnity_letter: boolean;
        shipment_content_type_id: number;
        shipment_scope_id: number;
    };
    document_payments: {
        payment: {
            countryPaymentType: {
                code: string;
            };
        };
    }[];
}
interface ShipmentLandingReport extends ActiveLessLaravelModel {
    authorization_numbers: string[] | null;
    commercial_invoice: boolean | null;
    company_country_id: number;
    company_id: number;
    company_name: string;
    country_id: number;
    country_name: string;
    currency_code: string | null;
    document_id: number;
    hasCreditCardPayment: boolean;
    installation_id: number;
    installation_number: number;
    invoice_document_id: number | null;
    is_document: boolean;
    is_manual: boolean;
    itn_number: string | null;
    location_code: string;
    location_facility_code: string;
    location_id: number;
    location_name: string;
    price_override_approver_name: string | null;
    price_override_reason_name: string | null;
    product_global_name: string;
    product_local_name: string;
    question_description: string | null;
    receiver_address_line1: string;
    receiver_address_line2: string | null;
    receiver_address_line3: string | null;
    receiver_city_name: string;
    receiver_company_name: string;
    receiver_country_name: string;
    receiver_county_name: string | null;
    receiver_email: string | null;
    receiver_full_name: string;
    receiver_full_phone_number: string | null;
    receiver_identification_number: string | null;
    receiver_postal_code: string | null;
    receiver_state_name: string;
    send_to_api_inventories: boolean;
    shipment_description: string;
    shipment_group_id: number;
    shipment_group_name: string;
    shipment_pieces_tracking_numbers: string[];
    shipment_status_code: string;
    shipment_status_id: number;
    shipment_status_name_EN: string;
    shipment_status_name_ES: string;
    shipment_status_name_FR: string;
    shipment_status_name_PT: string;
    shipment_tags: ShipmentTag[];
    shipment_tracking_number: string;
    shipment_type: string;
    shipment_value: number;
    shipper_account: string;
    shipper_address_line1: string;
    shipper_address_line2: string | null;
    shipper_address_line3: string | null;
    shipper_city_name: string | null;
    shipper_company_name: string;
    shipper_country_name: string;
    shipper_county_name: string | null;
    shipper_email: string | null;
    shipper_full_name: string;
    shipper_full_phone_number: string;
    shipper_identification_number: string | null;
    shipper_phone_number: string | null;
    shipper_postal_code: string | null;
    shipper_state_name: string | null;
    tracking: string | null;
    user_id: number;
    user_username: string;
    additional_documents: {
        country_id: number;
        include_indemnity_letter: boolean;
        shipment_content_type_id: number;
        shipment_scope_id: number;
    } | null;
    manifest_date_time?: string | null;
    date_time?: string;
}
interface ShipmentTag extends ActiveLessSymfonyModel {
    name: string;
    code: string;
    translations: Translations;
}
interface ReportExternalShipment extends ActiveLessLaravelModel {
    account_number: string;
    collection_date: string;
    document_id: number | null;
    document_number: string | null;
    external_shipment_addresses: ReportExternalShipmentAddress[];
    external_shipment_file_id: number;
    external_shipment_status_id: number;
    external_shipment_status_name: string;
    external_shipment_status_translations: Translations;
    installation_id: number;
    subtotal: number;
    tax: number;
    total: number;
    tracking_number: string;
    user_id: number;
    customer_full_name: string;
    customer_email: string | null;
    customer_phone_code: string | null;
    customer_phone_number: string | null;
    completed_date: string;
}
interface ReportExternalShipmentAddress extends ApiModel {
    address_line_1: string;
    address_line_2: string;
    city_name: string;
    company_name: string;
    country_id: number;
    email: string;
    full_name: string;
    identification_number: string | null;
    identification_type_id: number | null;
    phone_number: string;
    postal_code: string;
    role_type: string;
    service_area_code: string;
    county_name: string | null;
    business_activity: string | null;
}
interface PromotionCodeDiscount extends ApiModel {
    country_id: number;
    company_country_id: number;
    location_id: number;
    installation_id: number;
    user_id: number;
    user_username: string;
    updated_at: Date | string;
    tracking_number: string;
    product_id: number;
    product_global_code: string;
    product_global_name: string;
    origin_facility_code: string;
    destination_facility_code: string;
    origin_company_name: string;
    origin_full_name: string;
    promotion_code: string;
    discount_percentage: number;
    product_subtotals: ProductSubtotal[];
    manifest_date_time?: string | null;
    date_time?: string;
}
interface ProductSubtotal {
    country_reference_currency_id: number;
    currency_id: number;
    currency_code: string;
    value: number;
    shipment_total: number;
    discount_amount: number;
}
interface ProductSubtotal {
    country_reference_currency_id: number;
    currency_id: number;
    currency_code: string;
    value: number;
}
interface WithdrawalAmount {
    country_reference_currency_id: number;
    currency_id: number;
    currency_code: string;
    value: number | null;
}
interface PartialWithdrawal extends ActiveLessLaravelModel {
    country_id: number;
    company_country_id: number;
    location_id: number;
    installation_id: number;
    opening_user_id: number;
    opening_user_username: string;
    opening_user_name: string;
    opening_reference_user_id: number;
    opening_reference_user_username: string;
    opening_reference_user_name: string;
    receipt_number: string;
    amounts: WithdrawalAmount[];
}
interface Invoice extends ActiveLessLaravelModel {
    complete_document_number: string;
    tracking_numbers: string[];
    local_currency_total_amount: number;
    identification_type_name: string;
    identification_number: string;
    customer_full_name: string;
    customer_address: string;
    customer_email: string;
    customer_extra_fields: {
        field: string;
        value: string;
    }[];
    document_type_name: string;
    document_type_name_ES: string;
    document_type_name_EN: string;
    document_category_name: string;
    document_category_name_ES: string;
    document_category_name_EN: string;
    document_status_id: number;
    document_status_code: string;
    transaction_type: string;
    installation_id: number;
    location_id: number;
    company_country_id: number;
    country_id: number;
    customer_phone_code: string;
    customer_phone_number: string;
    customer_city_name: string;
    customer_county_name: string;
    shipment_id: number;
}
interface Sales extends ActiveLessLaravelModel {
    company_country_id: number;
    country_document_type_id: number;
    country_id: number;
    customer_address_line1: string;
    customer_email: string;
    customer_name: string;
    customer_phone: string;
    document_full_number: string;
    document_sap_full_number: string;
    document_status_name: string;
    document_status: number;
    document_type_name_EN: string;
    document_type_name_ES: string;
    document_type_name_FR: string;
    document_type_name_PT: string;
    document_type_name: string;
    exempt: number;
    identification_number: string;
    identification_type_id: number;
    identification_type_name: string;
    installation_id: number;
    location_id: number;
    subtotal: number;
    tax: number;
    total: number;
    user_id: number;
}
interface HistoryReport extends ActiveLessLaravelModel {
    shipment_tracking_number: string;
    package_tracking_number: string;
    country_name: string;
    country_id: number;
    company_name: string;
    company_country_id: number;
    location_name: string;
    location_id: number;
    installation_number: number;
    installation_id: number;
    username: string;
    user_id: number;
    position: string | null;
    operation_type_id: number;
    operation_type_name: string;
    operation_type_translations: {
        name: TranslateLang;
        shortName: TranslateLang;
    };
    status_id: number;
    status_name: string;
    status_translations: {
        name: TranslateLang;
        description: TranslateLang;
    };
    origin: string;
    destination: string;
    is_inspected: boolean | null;
    courier_number: string | null;
    courier_name: string;
    courier_id: string | null;
    receiver_name: string | null;
    shipper_name: string;
    checkpoints: HistoryReportCheckpoint[];
    courier_confirmation_number: string | null;
    operation_datetime: string;
}
interface ParcelReport extends ActiveLessLaravelModel {
    package_id: number;
    location_facility_code: string;
    commission_account: string | null;
    shipment_tracking_number: string;
    package_tracking_number: string;
    receiver_company_name: string | null;
    operation_receiver_name: string | null;
    country_id: number;
    company_country_id: number;
    location_id: number;
    country_name: string;
    company_name: string;
    country_code: string | null;
    location_name: string;
    first_mile_operation_location_address: string;
    last_mile_operation_location_address: string | null;
    gmt_offset: string;
    last_operation_type_id: number;
    last_operation_type_code: string;
    last_operation_type_name: string;
    last_operation_type_translations: {
        name: TranslateLang;
        shortName: TranslateLang;
    };
    last_operation_updated_at: string;
    last_operation_local_updated_at: string;
    local_updated_at: string;
}
interface OperationReport extends ActiveLessLaravelModel {
    number: string;
    country_id: number;
    country_code: string;
    country_name: string;
    company_id: number;
    company_name: string;
    location_id: number;
    location_name: string;
    location_facility_code: string;
    location_location_code: string;
    installation_id: number;
    installation_number: number;
    user_id: number;
    username: string;
    operation_type_id: number;
    operation_type_code: string;
    operation_type_name: string;
    operation_type_translations: {
        name: TranslateLang;
        shortName: TranslateLang;
    };
    courier_id: string | null;
    courier_number: string | null;
    courier_name: string | null;
    is_labelless: boolean;
}
interface PackageReport extends ApiModel {
    package_id: number;
    shipment_tracking_number: string;
    package_tracking_number: string;
    country_code: string;
    country_name: string;
    country_id: number;
    location_name: string;
    location_facility_code: string;
    location_location_code: string;
    location_id: number;
    installation_number: number;
    installation_id: number;
    username: string;
    user_id: number;
    package_in_stock: boolean;
    package_status_id: number;
    package_status_name: string;
    package_status_translations: {
        name: TranslateLang;
        description: TranslateLang | null;
    };
    package_position: string | null;
    operation_type_id: number;
    operation_type_name: string;
    operation_type_translations: {
        name: TranslateLang;
        shortName: TranslateLang;
    };
    checkin_operation_type_id: number;
    checkin_operation_type_name: string;
    checkin_operation_type_translations: {
        name: TranslateLang;
        shortName: TranslateLang;
    };
    checkin_operation_created_at: string;
    checkin_operation_updated_at: string;
    checkin_operation_gmt_offset: string;
    package_last_checkpoint: string;
    package_last_checkpoint_created_at: string;
    origin: string;
    destination: string;
    locker_is_candidate: boolean;
    locker_position: string | null;
}
interface InventoryReport extends ActiveLessLaravelModel {
    shipment_tracking_number: string;
    package_tracking_number: string;
    status_id: number;
    status_name: string;
    status_translations: {
        name: TranslateLang;
        description: TranslateLang | null;
    };
    package_last_incident_code: string | null;
    package_last_incident_name: string | null;
    package_last_incident_is_finisher: string | null;
    checkin_operation_type_id: number;
    checkin_operation_type_code: string;
    checkin_operation_type_name: string;
    checkin_operation_type_translations: {
        name: TranslateLang;
        shortName: TranslateLang;
    };
    last_operation_type_id: number;
    last_operation_type_code: string;
    last_operation_type_name: string;
    last_operation_type_translations: {
        name: TranslateLang;
        shortName: TranslateLang;
    };
    is_first_mile: boolean;
    is_expired: boolean;
    origin: string;
    destination: string;
    last_checkpoint: string;
    last_checkpoint_datetime: string;
    position: string | null;
    package_id: number;
    shipment_id: number;
    country_name: string;
    country_id: number;
    company_name: string;
    company_country_id: number;
    location_name: string;
    location_id: number;
    checkin_datetime: string;
}
interface HistoryReportCheckpoint extends ApiModel {
    event_reason_code: string;
    transaction_id: string;
    remark: string;
    local_created_at: string;
}

type CollectionPaymentsOut = {
    collection_payments: CollectionPayment[];
    total: number;
};
type ShipmentsReportOut = {
    shipments: ShipmentReports[];
    total: number;
};
type ShipmentsLandingReportOut = {
    shipments_landing: ShipmentLandingReport[];
    total: number;
};
type ExternalShipmentsOut = {
    external_shipments: ReportExternalShipment[];
    total: number;
};
type PromotionCodeDiscountsOut = {
    total: number;
    promotion_code_discounts: PromotionCodeDiscount[];
} | {
    transaction_id: string;
};
type FileCheckOut = {
    report_file: {
        user_id: number;
        role_type_level: number;
        type: string;
        status: number;
        progress: number;
        file_size: number;
        file_name: string | null;
        report_request: QueryParams;
        transaction_id: string;
        headers: {
            [key: string]: string;
        };
        user_session: Session;
        role_company_country_id: number;
        updated_at: string;
        created_at: string;
        id: string;
    };
};
type PartialWithdrawalsOut = {
    partial_withdrawals: PartialWithdrawal[];
    total: number;
};
type InvoicesOut = {
    invoices: Invoice[];
    total: number;
};
type SalesBookReportOut = {
    sale_books: Sales[];
    total: number;
    transaction_id?: string;
};
type HistoriesReportOut = {
    histories: HistoryReport[];
    total: number;
    transaction_id?: string;
};
type ParcelsReportOut = {
    parcels: ParcelReport[];
    total: number;
    transaction_id?: string;
};
type OperationsReportOut = {
    operations: OperationReport[];
    total: number;
    transaction_id?: string;
};
type PackagesReportOut = {
    packages: PackageReport[];
    total: number;
    transaction_id?: string;
};
type InventoriesReportOut = {
    inventories: InventoryReport[];
    total: number;
    transaction_id?: string;
};

declare class ApiReportsService {
    private environments;
    private http;
    /**
     * Retrieves the URL for the reports API from the environment configurations.
     *
     * @return {string} The URL of the reports API.
     */
    get url(): string;
    /**
     * Retrieves the list of collection payments
     *
     * @param {QueryParams} params - The query parameters used to fetch the collection payments.
     * @return {Observable<CollectionPaymentsOut[]>} An observable that emits an array of collection payment.
     */
    getCollectionPayments(params: QueryParams): Observable<CollectionPaymentsOut>;
    /**
     * Fetches shipment reports based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters used to filter or define the shipment reports.
     * @return {Observable<ShipmentsReportOut>} An observable emitting the shipment report data.
     */
    getShipmentsReport(params: QueryParams): Observable<ShipmentsReportOut>;
    /**
     * Retrieves the shipments landing report from the reports API.
     *
     * Sends a GET request to the `/shipments-landing-report` endpoint with the provided query parameters.
     * The HTTP response is expected to be wrapped in an `ApiSuccess` envelope, from which the `data`
     * payload is extracted and returned as the stream value.
     *
     * @param params - Query parameters used to filter or paginate the shipments landing report.
     * @returns An observable that emits the parsed `ShipmentsLandingReportOut` data from the API response.
     *
     * @remarks
     * - The underlying HTTP call uses `HttpClient.get` with `params` serialized as query string values.
     * - The response is piped through `map` to unwrap `data` from `ApiSuccess<T>`.
     * - Errors from the HTTP request are propagated through the observable stream.
     *
     * @example
     * ```ts
     * // Basic usage:
     * service.getShipmentsLandingReport({ page: 1, perPage: 25 })
     *   .subscribe(report => {
     *     // handle ShipmentsLandingReportOut
     *   });
     * ```
     */
    getShipmentsLandingReport(params: QueryParams): Observable<ShipmentsLandingReportOut>;
    /**
     * Retrieves a report of external shipments based on the provided query parameters.
     *
     * @param {QueryParams} params - An object representing the query parameters for filtering the external shipments report.
     * @return {Observable<ExternalShipmentsOut>} An observable that emits the external shipments report data.
     */
    getExternalShipmentsReport(params: QueryParams): Observable<ExternalShipmentsOut>;
    /**
     * Retrieves a report of promotion code discounts based on the provided query parameters.
     *
     * @param {QueryParams} params - An object representing the query parameters for filtering the promotion code discounts report.
     * @return {Observable<PromotionCodeDiscountsOut>} An observable that emits the promotion code discounts report data.
     */
    getPromotionCodeDiscounts(params: QueryParams): Observable<PromotionCodeDiscountsOut>;
    /**
     * Retrieves the downloadable resource associated with the given transaction ID.
     *
     * @param {string} transactionId - The unique identifier of the transaction whose download is requested.
     * @return {Observable<HttpResponse<ArrayBuffer>>} An observable that emits the HTTP response containing the resource in the form of an ArrayBuffer.
     */
    getDownload(transactionId: string): Observable<HttpResponse<ArrayBuffer>>;
    /**
     * Retrieves file check information for the specified transaction ID.
     *
     * @param {string} transactionId - The ID of the transaction for which the file check information is to be retrieved.
     * @return {Observable<FileCheckOut>} An observable that emits the file check information associated with the given transaction ID.
     */
    getFileCheck(transactionId: string): Observable<FileCheckOut>;
    /**
     * Deletes the file check associated with the provided transaction ID.
     *
     * @param {string} transactionId - The unique identifier of the transaction whose file check is to be deleted.
     * @return {Observable<{}>} An observable emitting the response data after the deletion is processed.
     */
    deleteFileCheck(transactionId: string): Observable<{}>;
    /**
     * Retrieves partial withdrawals based on the provided query parameters.
     *
     * @param {QueryParams} params - The parameters used to filter the list of partial withdrawals.
     * @returns {Observable<PartialWithdrawalsOut>} An observable that emits the filtered list of partial withdrawals.
     */
    getPartialWithdrawals(params: QueryParams): Observable<PartialWithdrawalsOut>;
    /**
     * Retrieves a list of invoices based on the provided query parameters.
     *
     * @param params - The query parameters used to filter the invoices.
     * @returns An observable that emits the list of invoices.
     */
    getInvoices(params: QueryParams): Observable<InvoicesOut>;
    /**
     * Retrieves the sales book report based on the provided query parameters.
     *
     * @param params - The query parameters to filter or customize the report.
     * @returns An Observable that emits the sales book report data.
     *
     * @example
     * ```typescript
     * this.apiReportsService.getSalesBookReport({ page: 1, limit: 10 })
     *   .subscribe(report => console.log(report));
     * ```
     */
    getSalesBookReport(params: QueryParams): Observable<SalesBookReportOut>;
    /**
     * Retrieves a list of shipment histories based on the provided query parameters.
     *
     * @param params - The query parameters used to filter the shipment histories.
     * @returns An observable that emits the list of shipment histories.
     */
    getHistoriesReport(params: QueryParams): Observable<HistoriesReportOut>;
    /**
     * Retrieves a list of parcels based on the provided query parameters.
     *
     * @param params - The query parameters used to filter the parcels.
     * @returns An observable that emits the list of parcels.
     */
    getParcelsReport(params: QueryParams): Observable<ParcelsReportOut>;
    /**
     * Retrieves a list of operations based on the provided query parameters.
     *
     * @param params - The query parameters used to filter the operations.
     * @returns An observable that emits the list of operations.
     */
    getOperationsReport(params: QueryParams): Observable<OperationsReportOut>;
    /**
     * Retrieves a list of operations based on the provided query parameters.
     *
     * @param params - The query parameters used to filter the operations.
     * @returns An observable that emits the list of operations.
     */
    getPackagesReport(params: QueryParams): Observable<PackagesReportOut>;
    /**
     * Retrieves a list of inventories based on the provided query parameters.
     *
     * @param params - The query parameters used to filter the inventories.
     * @returns An observable that emits the list of inventories.
     */
    getInventoriesReport(params: QueryParams): Observable<InventoriesReportOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiReportsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiReportsService>;
}

declare class ApiSecurityService {
    private cookie;
    private http;
    private environments;
    /**
     * Retrieves the API security URL from the environments configuration.
     *
     * @return {string} The API security URL.
     */
    get url(): string;
    /**
     * Handles the login authentication request by sending the login data to the authentication endpoint.
     *
     * @param {AuthLoginIn} body The payload containing login credentials.
     * @return {Observable<AuthLoginOut>} An observable emitting the authentication response data.
     */
    postAuthLogin(body: AuthLoginIn): Observable<AuthLoginOut>;
    /**
     * Handles the user login process by sending user credentials to the authentication endpoint.
     *
     * @param {AuthUserLoginIn} body - The request payload containing user login details such as username and password.
     * @return {Observable<AuthLoginOut>} An observable that emits the authenticated user's login data upon successful login.
     */
    postAuthUserLogin(body: AuthUserLoginIn): Observable<AuthLoginOut>;
    /**
     * Logs out the current user by making a POST request to the logout endpoint.
     *
     * This method deletes all cookies after a successful logout.
     *
     * @return {Observable<{}>} An observable that emits the server's response to the logout request.
     */
    postAuthLogout(): Observable<{}>;
    /**
     * Creates a new session for a specified model.
     *
     * @param {Object} params - The parameters for creating the session.
     * @param {string} params.modelType - The type of the model.
     * @param {string} params.modelId - The ID of the model.
     * @param {string} [params.token] - Optional authorization token.
     *
     * @return {Observable<SessionOut>} An observable containing the created session details.
     */
    postSession({ modelType, modelId, token, }: SessionIn): Observable<SessionOut>;
    /**
     * Fetches the authenticated user's information.
     * Sends a GET request to the endpoint '/auth/me' to retrieve information
     * about the currently authenticated user.
     *
     * @return {Observable<AuthMeOut>} An observable that emits the authenticated user's data.
     */
    getAuthMe(): Observable<AuthMeOut>;
    /**
     * Fetches the authenticated user's details from the server.
     *
     * @param token The JWT token used for authorization.
     * @return An Observable that emits the user's details encapsulated in a MeOut object.
     */
    getOtherMe(token: string): Observable<AuthMeOut>;
    /**
     * Fetches a user by their unique ID.
     *
     * @param {number} id - The unique identifier of the user to be fetched.
     * @return {Observable<GetUserOut>} An observable containing the user information.
     */
    getUser(id: number): Observable<GetUserOut>;
    /**
     * Fetches a list of users from the server based on the specified query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the list of users.
     * @return {Observable<GetUsersOut>} An observable that emits the list of users retrieved from the server.
     */
    getUsers(params: QueryParams): Observable<GetUsersOut>;
    /**
     * Updates the information of a specified user on the server.
     *
     * @param {Object} params - The parameter object.
     * @param {Object} params.user - The user object containing updated data.
     * @param {string} params.user.id - The unique identifier of the user to be updated.
     *
     * @return {void} This method does not return a value.
     */
    putUsers({ user }: PutUsersIn): Observable<PutUsersOut>;
    /**
     * Changes the language for the authenticated user.
     *
     * @param {Object} params - The input parameters for changing the language.
     * @param {string} params.languageId - The ID of the new language to be set.
     * @return {Observable<ApiSuccess<AuthMeOut>>} An observable that emits the result of the language change request.
     */
    putChangeLanguage({ languageId }: ChangeLanguageIn): Observable<AuthMeOut>;
    /**
     * Retrieves a list of roles with their permissions.
     *
     * @param {QueryParams} params - The query parameters to filter the roles.
     * @returns {Observable<RoleIn[]>} An observable that emits an array of role permissions.
     */
    getRoles(params: QueryParams): Observable<RolesOut>;
    /**
     * Retrieves roles by the specified ID.
     *
     * @param id - The ID of the role to retrieve.
     * @returns An Observable that emits the role data.
     */
    getRole(id: number): Observable<RoleOut>;
    /**
     * Creates a new role with the specified permissions.
     *
     * @param {RoleIn} body - The permissions and details for the new role.
     * @returns {Observable<RoleOut>} An observable containing the created role's permissions.
     */
    postRole(body: RoleIn): Observable<RoleOut>;
    /**
     * Updates the permissions of a specific role.
     *
     * @param id - The unique identifier of the role to update.
     * @param body - The new permissions to assign to the role.
     * @returns An Observable that emits the updated module permissions.
     */
    putRole(id: number, body: RoleIn): Observable<RoleOut>;
    /**
     * Deletes the permissions associated with a specific role.
     *
     * @param {number} id - The unique identifier of the role whose permissions are to be deleted.
     * @returns {Observable<{}>} An observable that emits the result of the delete operation.
     */
    deleteRole(id: number): Observable<{}>;
    /**
     * Retrieves the role types from the API.
     *
     * @param {QueryParams} params - The query parameters to be sent with the request.
     * @returns {Observable<RoleTypesOut>} An observable containing the role types output.
     */
    getRoleTypes(params: QueryParams): Observable<RoleTypesOut>;
    /**
     * Retrieves a list of modules and permissions
     *
     * @param queryParams - The query parameters to filter the modules.
     * @returns Observable<ModulesOut[]> - An observable that emits an array of modules and permissions.
     */
    getModules(queryParams: QueryParams): Observable<ModulesOut>;
    /**
     * Retrieves a list of modules and permissions
     *
     * @param params.token - Custom token for authorization.
     * @param params.queryParams - The query parameters to filter the modules.
     * @returns Observable<ModulesOut[]> - An observable that emits an array of modules and permissions.
     */
    getModulesByToken(params: {
        token: string;
        queryParams: QueryParams;
    }): Observable<ModulesOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiSecurityService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiSecurityService>;
}

interface ServiceArea extends SymfonyModel {
    serviceAreaCodeName: string;
    referenceDataCode: string;
    serviceAreaCode: string;
    serviceAreaName: string;
    serviceAreaStatusCode: string;
    serviceAreaStatusCodeDescription: string;
    iataCode: string;
    iataAirportName: string;
    countryCode: string;
    countryName: string;
    timezoneCode: string;
    timezoneCodeName: string;
    offNetServiceIndicator: string;
    offNetServiceIndicatorDescription: string;
    effectiveDate: string;
}
interface Facility extends SymfonyModel {
    facilityIdentifier: string;
    facilityCode: string;
    serviceAreaCode: string;
    serviceAreaName: string;
    facilityName: string;
    countryCode: string;
    countryName: string;
    facilityStatusCode: string;
    facilityCompanyName: string;
    facilityTypeIndicator: string;
    cityName: string;
    addressLine1: string;
    postcode: string;
    addressLongitude: string;
    addressLatitude: string;
    stateProvinceCode: string;
    stateProvinceName: string;
    regionCode: string;
    regionName: string;
    facilityWeightUnitOfMeasure: string;
    facilityDimensionUnitOfMeasure: string;
    facilityPrintIndicator: string;
    effectiveDate: string;
}
interface PostalLocation {
    city: string | null;
    postalCode: string | null;
    suburb: string | null;
    stateCode: string | null;
}
interface AddressSuggestion {
    address: string;
    mainText: string;
    placeId: string;
}
interface AddressPlaceDetail {
    postCode: string;
    cityName: string;
    stateProvince: string;
    district: string;
    address: {
        line1: string;
        line2: string;
        line3: string;
    };
}

type ServiceAreaIn = {
    countryCodes: string[];
};
type ServiceAreasOut = {
    serviceAreas: ServiceArea[];
    total: number;
};
type ValidateFacilityOut = {
    facility: Facility;
    transactionId: string;
};
type ValidateFacilityIn = {
    facilityIdentifier: string;
};
type EmailErrorIn = {
    transactionId: string;
    details: string;
    extraFields: {
        [key: string]: string;
    };
};
type PromotionIn = {
    code: string;
    destinationCountryCode: string;
    shipmentDatetime: string;
    shipper: {
        countryCode: string;
        accountNumber: string;
    };
};
type PromotionOut = {
    promotion: {
        accountNumber: string;
    };
    transactionId: string;
};
type ValidateNIPOut = {
    nip: {
        valid: string;
        message: string;
    };
};
type ValidateNIPIn = {
    accountValue: string;
    nip: string;
    user: number;
};
type ValidateIdentificationBROut = {
    identification: {
        valid: boolean;
    };
};
type ValidateIdentificationBRIn = {
    identification_number: string;
    validate_state_tax: boolean;
};
type PostalLocationsOut = {
    postalLocations: PostalLocation[];
};
type GetPostalLocationsIn = {
    limit?: number;
    countryId: number;
    city?: string;
    postalCode?: string;
    suburb?: string;
};
type AddressSuggestionsOut = {
    suggestions: AddressSuggestion[];
};
type AddressSuggestionIn = {
    countryCode: string;
    lang: string;
    address: string;
};
type AddressPlaceDetailIn = {
    placeId: string;
    lang: string;
    mainText: string;
};
type AddressPlaceDetailsOut = {
    addressDetails: AddressPlaceDetail;
};

declare class ApiServicesService {
    private environments;
    private 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(): string;
    /**
     * 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: ServiceAreaIn): Observable<ServiceAreasOut>;
    /**
     * 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: ValidateFacilityIn): Observable<ValidateFacilityOut>;
    /**
     * 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: EmailErrorIn): Observable<{}>;
    /**
     * 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: PromotionIn): Observable<PromotionOut>;
    /**
     * 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: ValidateNIPIn): Observable<ValidateNIPOut>;
    /**
     * 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: ValidateIdentificationBRIn): Observable<ValidateIdentificationBROut>;
    /**
     * Fetches postal location details based on the provided query parameters.
     * @param {GetPostalLocationsIn} queryParams - The query parameters to filter and fetch postal location data.
     * @return {Observable<PostalLocationsOut>} An observable that emits the postal location details.
     */
    getPostalLocations(queryParams: GetPostalLocationsIn): Observable<PostalLocationsOut>;
    /**
     * Fetches address suggestions based on the provided query parameters.
     * @param {AddressSuggestionIn} queryParams - The query parameters to filter and fetch address suggestions.
     * @return {Observable<AddressSuggestionsOut>} An observable that emits the address suggestions.
     */
    getAddressSuggestions(queryParams: AddressSuggestionIn): Observable<AddressSuggestionsOut>;
    /**
     * Fetches address place details based on the provided query parameters.
     * @param {AddressPlaceDetailIn} queryParams - The query parameters to filter and fetch address place details.
     * @return {Observable<AddressPlaceDetailsOut>} An observable that emits the address place details.
     */
    getAddressPlaceDetails(queryParams: AddressPlaceDetailIn): Observable<AddressPlaceDetailsOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiServicesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiServicesService>;
}

interface ShipmentEmployeeCustomers extends ActiveLessSymfonyModel {
    trackingNumber: string;
    employeeCustomerId: number;
    shipment: {
        id: number;
    } | null;
}
interface ExportType extends SymfonyModel {
    code: string;
    name: string;
}
interface DestinationCountry extends ActiveLessSymfonyModel {
    code: string;
    name: string;
}
interface EmbassyShipment extends SymfonyModel {
    id: number;
    countryId: number;
    name: string;
    destinationCountry: DestinationCountry;
    destinationCityName: string | null;
    destinationPostalCode: string | null;
    destinationCountyName: string | null;
    contentDescription: string | null;
    shipmentContentType: ShipmentContentType;
    piecesNumber: number | null;
    destinationCompanyName: string | null;
    destinationFullName: string | null;
    destinationAddressLine1: string | null;
    destinationAddressLine2: string | null;
    destinationAddressLine3: string | null;
    destinationPhoneCode: string | null;
    destinationPhoneNumber: string | null;
    destinationEmail: string | null;
    businessPartyTraderTypeId: number | null;
    isActive: boolean;
    createdAt: string;
    updatedAt: string;
}
interface SignaturePageSetting extends SymfonyModel {
    country: Country;
    isDefault: boolean;
    termsAndCondition: string | null;
    marketingConsent: string | null;
    additionalVerbiage: string | null;
}

type ValidateAccountIn = {
    accountValue: string;
};
type AccountResponse = {
    status: true;
    message: string;
    name: string;
    accountStatus: string;
    creditStatus: string;
    activityStatus: string;
    country: string;
    countryName: string;
    isCreditStop: boolean;
    isImportEnabled: boolean;
    accountType: string;
    isCash: boolean;
    contactInfo: string | null;
    registrationInfo: string | null;
    users: {
        id: string;
        name: string;
        valid: boolean;
    }[];
} | {
    status: false;
    message: string;
    users: [];
};
type ValidateAccountOut = {
    account: AccountResponse;
    transactionId: string;
};
type ManifestMultipleIn = {
    shipmentIds: number[];
    customer: {
        companyName: string;
        fullName: string;
        email: string;
        phoneCode: string;
        phoneNumber: string;
        addressLine1: string;
        addressLine2?: string;
        addressLine3?: string;
        identificationNumber?: string;
        identificationTypeId?: number;
        countryCode: string;
        stateCode?: string;
        postalCode?: string;
        cityName?: string;
        countyName?: string;
    };
    paymentDetails: {
        totalAmount: number;
        payments: {
            amount: number;
            received: number;
            countryReferenceCurrencyId: number;
            exchange: number;
            countryPaymentTypeId: number;
            dueDate: string;
            details: Record<string, string>;
        }[];
    };
    priceOverrideApproverId: number | null;
    priceOverrideReasonId: number | null;
    isPendingInvoice?: boolean;
};
type ManifestMultipleOut = {
    shipmentManifests: {
        documentId: number;
    };
    transactionId: string;
};
type ShipmentEmployeeCustomer = {
    currentYear: number;
    currentMonth: number;
    message: string | null;
    shipmentEmployeeCustomers: ShipmentEmployeeCustomers[];
};
type ShipmentCancellationIn = {
    shipmentId: number;
    reasonId: number;
};
type ShipmentCancellationOut = {
    transactionId: string;
};
type ExportTypesOut = {
    exportTypes: ExportType[];
    total: number;
};
type EmbassyShipmentsOut = {
    total: number;
    embassyShipments: EmbassyShipment[];
};
type SignaturePageSettingsOut = {
    total: number;
    signaturePageSettings: SignaturePageSetting[];
};
type SignaturePageSettingOut = {
    signaturePageSetting: SignaturePageSetting;
};
type EmbassyShipmentIn = {
    countryId: number;
    name: string;
    destinationCountryId: number | null;
    destinationCityName: string | null;
    destinationPostalCode: string | null;
    destinationCountyName: string | null;
    contentDescription: string | null;
    shipmentContentTypeId: number | null;
    piecesNumber: number | null;
    destinationCompanyName: string | null;
    destinationFullName: string | null;
    destinationAddressLine1: string | null;
    destinationAddressLine2: string | null;
    destinationAddressLine3: string | null;
    destinationPhoneCode: string | null;
    destinationPhoneNumber: string | null;
    destinationEmail: string | null;
    businessPartyTraderTypeId: number | null;
    isActive: boolean;
};
type SignaturePageSettingIn = {
    countryId: number;
    isDefault: boolean;
    termsAndCondition: string | null;
    marketingConsent: string | null;
    additionalVerbiage: string | null;
    isActive: boolean;
};
interface EmbassyShipmentOut {
    embassyShipment: EmbassyShipment;
}
type ShipmentSignaturePageOut = {
    shipmentSignaturePage: string;
};

declare class ApiShipmentsService {
    private environments;
    private http;
    /**
     * Retrieves the URL for the shipments API from the environment configurations.
     *
     * @return {string} The URL of the shipments API.
     */
    get url(): string;
    /**
     * Retrieves the parameter values based on the provided parameter names.
     *
     * @param {ValidateAccountIn} body - An object of parameter names for which the values need to be fetched.
     * @return {Observable<ValidateAccountIn>} An observable that emits the fetched parameter values
     * @param body
     */
    postValidateAccount(body: ValidateAccountIn): Observable<ValidateAccountOut>;
    /**
     * Sends a POST request to the shipments manifest endpoint with the provided body.
     *
     * @param body - The request payload of type `ManifestMultipleIn`.
     * @returns An observable that emits the response data of type `ManifestMultipleOut`.
     */
    postManifestMultiple(body: ManifestMultipleIn): Observable<ManifestMultipleOut>;
    /**
     * Validates and obtains the number of shipments allowed by an employee customer
     *
     * @return {Observable<ShipmentEmployeeCustomer>} An observable containing the shipments allowed by an employee
     * @param id
     */
    getEmployeeCustomer(id: number): Observable<ShipmentEmployeeCustomer>;
    /**
     * Generate signature page PDF for one shipment
     *
     * @return {Observable<ShipmentSignaturePageOut>} An observable containing base64 file generated
     * @param id - the shipment id.
     */
    postShipmentSignaturePage(id: number): Observable<ShipmentSignaturePageOut>;
    /**
     * Cancels a specific shipment by providing its ID and a reason for cancellation.
     * Sends a PATCH request to update the shipment's cancellation status with the specified reason.
     *
     * @param {Object} param0 - The input object containing shipment cancellation details.
     * @param {string} param0.shipmentId - The unique identifier of the shipment to be canceled.
     * @param {string} param0.reasonId - The unique identifier of the reason for cancellation.
     * @return {Observable<ShipmentCancellationOut>} An observable emitting the result of the cancellation operation.
     */
    patchShipmentsCancellation({ shipmentId, reasonId }: ShipmentCancellationIn): Observable<ShipmentCancellationOut>;
    /**
     * Fetches a list of export types based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the export types.
     * @return {Observable<ExportTypesOut>} An observable containing the list of export types.
     */
    getExportTypes(params: QueryParams): Observable<ExportTypesOut>;
    /**
     * Retrieves a paginated list of embassy shipments
     * @param {QueryParams} params - Query parameters for filtering and pagination
     * @returns {Observable<EmbassyShipmentsOut>} Observable containing the list of shipments and pagination metadata
     */
    getEmbassyShipments(params: QueryParams): Observable<EmbassyShipmentsOut>;
    /**
     * Creates a new embassy shipment
     * @param {EmbassyShipmentIn} body - The shipment data to create
     * @returns {Observable<EmbassyShipmentOut>} Observable containing the created shipment with its assigned ID
     */
    postEmbassyShipments(body: EmbassyShipmentIn): Observable<EmbassyShipmentOut>;
    /**
     * Updates an existing embassy shipment
     * @param {number} id - The unique identifier of the shipment to update
     * @param {EmbassyShipmentIn} body - The updated shipment data
     * @returns {Observable<EmbassyShipmentOut>} Observable containing the updated shipment
     */
    putEmbassyShipments(id: number, body: EmbassyShipmentIn): Observable<EmbassyShipmentOut>;
    /**
     * Retrieves a paginated list of signature page settings
     * @param {QueryParams} params - Query parameters for filtering and pagination
     * @returns {Observable<SignaturePageSettingsOut>} Observable containing the list of signature page settings and pagination metadata
     */
    getSignaturePageSettings(params: QueryParams): Observable<SignaturePageSettingsOut>;
    /**
     * Retrieves the details of a signature page setting based on its ID.
     *
     * @param {number} id - The identifier of the signature page setting to fetch.
     * @return {Observable<SignaturePageSettingOut>} An observable that emits the signature page setting data.
     */
    getSignaturePageSetting(id: number): Observable<SignaturePageSettingOut>;
    /**
     * Creates a new signature page setting
     * @param {SignaturePageSettingIn} body - The signature page setting data to create
     * @returns {Observable<SignaturePageSettingOut>} Observable containing the created signature page setting with its assigned ID
     */
    postSignaturePageSetting(body: SignaturePageSettingIn): Observable<SignaturePageSettingOut>;
    /**
     * Updates an existing signature page setting
     * @param {number} id - The unique identifier of the signature page setting to update
     * @param {SignaturePageSettingIn} body - The updated signature page setting data
     * @returns {Observable<SignaturePageSettingOut>} Observable containing the updated signature page setting
     */
    putSignaturePageSetting(id: number, body: SignaturePageSettingIn): Observable<SignaturePageSettingOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiShipmentsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiShipmentsService>;
}

type SuppliesOut = {
    supplies: Supply[];
    total: number;
};
type SupplyIn = {
    supplyTypeId: number;
    name: string;
    description: string;
    countryId: number;
    enabledForDropoff: boolean;
    supplyPacking: {
        value: number;
        weight: number;
        height: number;
        depth: number;
        width: number;
    };
};
type SupplyOut = {
    supply: Supply;
};
type SupplyTypesOut = {
    supplyTypes: SupplyType[];
    total: number;
};
type SupplyLocationIn = {
    supplyId: number;
    locationId: number;
    stock: number;
};
type SupplyLocationOut = {
    supplyLocation: SupplyLocation;
};
type SupplyLocationsOut = {
    supplyLocations: SupplyLocation[];
    total: number;
};
type SupplyLocationTransactionIn = {
    supplyLocationId: number;
    supplyTransactionTypeId: number;
    quantity: number;
};
type SupplyLocationTransactionOut = {
    supplyLocationTransaction: SupplyLocationTransaction;
};
type SupplyTransactionTypesOut = {
    supplyTransactionTypes: SupplyTransactionType[];
    total: number;
};

declare class ApiSuppliesService {
    private environments;
    private http;
    /**
     * Retrieves the URL for the API supplies endpoint.
     *
     * @return {string} The API supplies URL or an empty string if not defined.
     */
    get url(): string;
    /**
     * 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: QueryParams): Observable<SuppliesOut>;
    /**
     * 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: number): Observable<SupplyOut>;
    /**
     * 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: SupplyIn): Observable<SupplyOut>;
    /**
     * 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: number, body: SupplyIn): Observable<SupplyOut>;
    /**
     * 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: QueryParams): Observable<SupplyTypesOut>;
    /**
     * Creates a new supply location.
     *
     * @param {SupplyLocationIn} body - The supply location data to create.
     * @return {Observable<SupplyLocationOut>} An Observable that emits the created supply location data.
     */
    postSupplyLocations(body: SupplyLocationIn): Observable<SupplyLocationOut>;
    /**
     * Fetches the supply locations based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the supply locations.
     * @return {Observable<SupplyLocationsOut>} An Observable that emits the supply locations data.
     */
    getSupplyLocations(params: QueryParams): Observable<SupplyLocationsOut>;
    /**
     * Creates a new supply location transaction.
     *
     * @param {SupplyLocationTransactionIn} body - The transaction data to create.
     * @return {Observable<SupplyLocationTransactionOut>} An Observable that emits the created transaction data.
     */
    postSupplyLocationTransaction(body: SupplyLocationTransactionIn): Observable<SupplyLocationTransactionOut>;
    /**
     * Fetches the supply transaction types based on the provided query parameters.
     *
     * @param {QueryParams} params - The query parameters to filter the transaction types.
     * @return {Observable<SupplyTransactionTypesOut>} An Observable that emits the supply transaction types data.
     */
    getSupplyTransactionTypes(params: QueryParams): Observable<SupplyTransactionTypesOut>;
    /**
     * Exports the supply locations to an Excel file.
     *
     * @param {QueryParams} params - The query parameters to filter the data before export.
     * @return {Observable<{ mime_type: string; base64: string }>} An Observable that emits the exported file's MIME type and Base64 content.
     */
    getSupplyLocationsExportToExcel(params: QueryParams): Observable<{
        mime_type: string;
        base64: string;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiSuppliesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiSuppliesService>;
}

interface Survey extends LaravelModel {
    company_country_id: number;
    company_name: string;
    country_id: number;
    country_name: string;
    date_from: string;
    date_to: string;
    questions_count: number;
    title: string;
}
interface SurveyQuestion extends LaravelModel {
    ask_client_if_contact: boolean;
    feedback_title: string | null;
    has_feedback: boolean;
    question_options: QuestionOption[];
    question_type_id: number;
    question_type_name: string;
    sequence: number;
    survey_id: number;
    threshold_sequence: number | null;
    title: string;
}
interface QuestionOption extends LaravelModel {
    is_other: boolean;
    sequence: number | null;
    title: string;
}
interface QuestionType extends LaravelModel {
    allows_feedback: boolean;
    code: string;
    has_options: boolean;
    name: string;
}

type SurveysOut = {
    surveys: Survey[];
    total: number;
};
type SurveyIn = {
    company_country_id: number;
    title: string;
    date_from: string;
    date_to: string;
    is_active: boolean;
};
type SurveyOut = {
    survey: Survey;
};
type SurveyQuestionsOut = {
    questions: SurveyQuestion[];
    total: number;
};
type SurveyQuestionIn = {
    ask_client_if_contact?: boolean;
    feedback_title?: string;
    has_feedback?: boolean;
    is_active?: boolean;
    question_type_id: number;
    sequence: number;
    threshold_sequence?: number;
    title: string;
    question_options?: {
        is_other: boolean;
        sequence: number | null;
        title: string;
    }[];
};
type SurveyQuestionOut = {
    question: SurveyQuestion;
};
type QuestionTypesOut = {
    question_types: QuestionType[];
    total: number;
};

declare class ApiSurveysService {
    private environments;
    private http;
    /**
     * Base URL for surveys API endpoints.
     * @returns The configured surveys API URL or an empty string.
     */
    get url(): string;
    /**
     * Retrieves surveys list based on query parameters.
     * @param params Query parameters used to filter, paginate, or sort surveys.
     * @returns Observable stream with surveys response data.
     */
    getSurveys(params: QueryParams): Observable<SurveysOut>;
    /**
     * Creates a new survey.
     * @param body Survey payload to create.
     * @returns Observable stream with created survey data.
     */
    postSurvey(body: SurveyIn): Observable<SurveyOut>;
    /**
     * Replaces an existing survey by id.
     * @param id Survey identifier.
     * @param body Survey payload used to replace the resource.
     * @returns Observable stream with updated survey data.
     */
    putSurvey(id: number, body: SurveyIn): Observable<SurveyOut>;
    /**
     * Partially updates an existing survey by id.
     * @param id Survey identifier.
     * @param body Partial survey payload with fields to update.
     * @returns Observable stream with updated survey data.
     */
    patchSurvey(id: number, body: Partial<SurveyIn>): Observable<SurveyOut>;
    /**
     * Retrieves the questions for a survey.
     * @param id Survey identifier.
     * @param params Query parameters used to filter, paginate, or sort questions.
     * @returns Observable stream with survey questions response data.
     */
    getSurveyQuestions(id: number, params: QueryParams): Observable<SurveyQuestionsOut>;
    /**
     * Creates a new question for a survey.
     * @param surveyId Parent survey identifier.
     * @param body Survey question payload to create.
     * @returns Observable stream with created survey question data.
     */
    postSurveyQuestion(surveyId: number, body: SurveyQuestionIn): Observable<SurveyQuestionOut>;
    /**
     * Replaces an existing survey question by id.
     * @param questionId Survey question identifier.
     * @param body Survey question payload used to replace the resource.
     * @returns Observable stream with updated survey question data.
     */
    putSurveyQuestion(questionId: number, body: SurveyQuestionIn): Observable<SurveyQuestionOut>;
    /**
     * Partially updates an existing survey question by id.
     * @param questionId Survey question identifier.
     * @param body Partial survey question payload with fields to update.
     * @returns Observable stream with updated survey question data.
     */
    patchSurveyQuestion(questionId: number, body: Partial<SurveyQuestionIn>): Observable<SurveyQuestionOut>;
    /**
     * Retrieves the available question types.
     * @param params Query parameters used to filter, paginate, or sort question types.
     * @returns Observable stream with question types response data.
     */
    getQuestionTypes(params: QueryParams): Observable<QuestionTypesOut>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiSurveysService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiSurveysService>;
}

declare class WebSocketsService {
    private pusher;
    private environments;
    constructor();
    /**
     * Publishes an event to the specified channel with the given data.
     *
     * @param {Channel} channel - The channel instance where the event will be published.
     * @param {string} eventName - The name of the event to be published.
     * @param {T} data - The payload data to be sent with the event.
     * @return {Promise<boolean>} A promise that resolves to a boolean indicating
     * whether the event was successfully triggered on the channel.
     */
    pub<T>(channel: Channel, eventName: string, data: T): Promise<boolean>;
    /**
     * Subscribes to a specified channel, retrying multiple times upon failure.
     *
     * @param {string} channelName - The name of the channel to be subscribed to.
     * @return {Promise<Channel>} A promise that resolves to the subscribed channel object if successful.
     * @throws {Error} If the subscription fails after the maximum number of retry attempts.
     */
    channelSub(channelName: string): Promise<Channel>;
    /**
     * Binds an event listener to a specified event on a given channel using Pusher or a Channel object,
     * and returns an Observable that emits event data of type T.
     *
     * @param {Channel|string} channel - The channel to bind the event to. It can be a Channel object or a string representing the channel name.
     * @param {string} event - The name of the event to bind to the channel.
     * @return {Observable<T>} An Observable that emits data of type T when the specified event is triggered.
     */
    eventBind<T>(channel: Channel | string, event: string): Observable<T>;
    /**
     * Unbinds an event from the specified channel and returns an observable
     * that emits data when the event callback is triggered.
     *
     * @param {Channel} channel - The channel object from which the event should be unbound.
     * @param {string} event - The name of the event to unbind.
     * @return {Observable<T>} An observable that emits data from the unbound event callback.
     */
    eventUnbind<T>(channel: Channel, event: string): Observable<unknown>;
    private connect;
    private wait;
    static ɵfac: i0.ɵɵFactoryDeclaration<WebSocketsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WebSocketsService>;
}

declare class CryptoService {
    private environments;
    encryptAES(plaintext: string): Promise<string>;
    decryptAES(payload: string): Promise<string>;
    private loadKey;
    private uint8ArrayToBase64;
    private base64ToUint8Array;
    private arrayBufferToBase64;
    private base64ToArrayBuffer;
    static ɵfac: i0.ɵɵFactoryDeclaration<CryptoService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CryptoService>;
}

/**
 * Intercepts an outgoing HTTP request and modifies its headers to include default values
 * for Cache-Control, Expires, Pragma, Content-Type, Accept, and Accept-Language if they
 * are not already present.
 *
 * @param {HttpRequest<unknown>} req - The outgoing HTTP request to be intercepted and modified.
 * @param {HttpHandlerFn} next - The next handler in the chain to pass the modified request to.
 * @return {Observable<HttpEvent<unknown>>} An observable of the HTTP event resulting from the processed request.
 */
declare function apiHeadersInterceptor(req: HttpRequest<unknown>, next: HttpHandlerFn): Observable<HttpEvent<unknown>>;

/**
 * HTTP interceptor that injects the external operations API key into outbound requests.
 *
 * The interceptor:
 * 1. Reads `apiExternalOperationsKey` from the injected `ENVIRONMENT_TOKEN`.
 * 2. Skips modification if the key is absent.
 * 3. Leaves the request unchanged if it already contains an `AppKey` header (caller override).
 * 4. Otherwise clones the request adding `AppKey: apiExternalOperationsKey`.
 *
 * This enables centralized, transparent authentication for services targeting external
 * operations endpoints while allowing explicit per-request overrides.
 *
 * Example:
 * ```ts
 * provideHttpClient(
 *   withInterceptors([apiKeyInterceptor])
 * );
 * ```
 *
 * @param request The original immutable `HttpRequest` instance.
 * @param next The next handler in the interceptor chain, used to forward the (possibly cloned) request.
 * @returns An `Observable` stream of the HTTP events for the (potentially augmented) request.
 *
 * @remarks
 * - If you need to intentionally send a different key for a specific request, set the `AppKey`
 *   header manually before this interceptor runs.
 * - If `apiExternalOperationsKey` is undefined (e.g., missing configuration), the request is passed through unchanged.
 * - Order matters: place this interceptor before others that rely on the presence of the `AppKey` header.
 *
 * @see HttpRequest
 * @see HttpHandlerFn
 */
declare function apiKeyInterceptor(request: HttpRequest<unknown>, next: HttpHandlerFn): Observable<HttpEvent<unknown>>;

/**
 * An HTTP interceptor to append an Authorization header with a Bearer token
 * to outgoing HTTP requests if certain conditions are met.
 *
 * @param {HttpRequest<unknown>} req - The outgoing HTTP request object which may be modified.
 * @param {HttpHandlerFn} next - The next handler in the HTTP request pipeline.
 * @return {Observable<HttpEvent<unknown>>} An observable of the HTTP event stream resulting from the request.
 */
declare function apiTokenInterceptor(req: HttpRequest<unknown>, next: HttpHandlerFn): Observable<HttpEvent<unknown>>;

/**
 * Interceptor function to handle HTTP caching for GET requests. It retrieves cached responses
 * if available and valid; otherwise, it processes the request and caches the response for future use.
 *
 * @param {HttpRequest<any>} req - The HTTP request object being intercepted.
 * @param {HttpHandlerFn} next - The next HTTP handler function in the chain to process the request.
 * @return {Observable<HttpEvent<any>>} An observable that emits the HTTP event, either from cache
 * or by invoking the next handler.
 */
declare function httpCachingInterceptor(req: HttpRequest<any>, next: HttpHandlerFn): Observable<HttpEvent<any>>;

declare const base64PdfToUrl: (base64: string) => string;
declare const downloadBase64Pdf: (base64: string) => Window | null;

/**
 * Convert an object of key-value pairs into a URL query string.
 *
 * @param {Object} params - The key-value pairs to converted into a query string.
 *
 * @return {string} - The generated query string.
 */
declare const queryString: (params: QueryParams) => string;
/**
 * Creates an instance of HttpParams using the provided params object.
 *
 * @param {Object} params - The object containing the params to the HttpParams constructor.
 *
 * @returns {HttpParams} - An instance of HttpParams created from the params object.
 */
declare const httpParams: (params: QueryParams) => HttpParams;
/**
 * Returns the headers for generating PDF files.
 *
 * @param {string} format - The format of the headers, 'object' or 'http_header'.
 *
 * @returns {HttpHeaders | { [header: string]: string | string[] }} - The headers for generating PDF files.
 */
declare const pdfHeaders: (format?: "object" | "http_header") => HttpHeaders | {
    [header: string]: string | string[];
};
/**
 * Returns the headers for generating XML files.
 *
 * @param {string} format - The format of the headers, 'object' or 'http_header'.
 *
 * @returns {HttpHeaders | { [header: string]: string | string[] }} - The headers for generating XML files.
 */
declare const xmlHeaders: (format?: "object" | "http_header") => HttpHeaders | {
    [header: string]: string | string[];
};

export { AlphaNumeric, ApiBillingDOService, ApiBillingGtService, ApiBillingMxService, ApiBillingPaService, ApiBillingSvService, ApiCashOperationsService, ApiCatalogsService, ApiCompaniesService, ApiCompositionService, ApiCustomsService, ApiDiscountsService, ApiEToolsAutoBillingService, ApiEventsService, ApiExternalOperationsService, ApiInventoriesService, ApiInvoicesService, ApiNotificationsService, ApiOpenItemsService, ApiQuoteService, ApiReportsService, ApiSecurityService, ApiServicesService, ApiShipmentsService, ApiSuppliesService, ApiSurveysService, CryptoService, DefaultValueType, ENVIRONMENT_TOKEN, Event, NgxServicesModule, OperationModuleStatus, ViewSectionOption, WebSocketsService, apiHeadersInterceptor, apiKeyInterceptor, apiTokenInterceptor, base64PdfToUrl, downloadBase64Pdf, httpCachingInterceptor, httpParams, pdfHeaders, provideNgxServices, queryString, xmlHeaders };
export type { Account, AccountCategoriesOut, AccountCategory, AccountCompanyCountry, AccountCompanyCountryLocation, AccountEntitiesIn, AccountEntitiesOut, AccountIn, AccountLocation, AccountLocationId, AccountOut, AccountPayment, AccountResponse, AccountToTDX, AccountType, AccountTypeIn, AccountTypeOut, AccountTypesOut, AccountWithDefault, AccountWithLocations, AccountsActivesOut, AccountsOut, ActiveLessLaravelModel, ActiveLessSymfonyModel, AdditionalData, AddressPlaceDetail, AddressPlaceDetailIn, AddressPlaceDetailsOut, AddressSuggestion, AddressSuggestionIn, AddressSuggestionsOut, ApiBillingConfigurable, ApiModel, ApiResponse, ApiSuccess, Attribute, AttributeIn, AttributeWithId, Attributes, AuthLoginIn, AuthLoginOut, AuthMeOut, AuthUserLoginIn, BillingConfig, BillingConfigIn, BillingConfigOut, BillingConfigsOut, BillingPaCustomer, BillingPaCustomerOut, BoardingProcess, BoardingProcessHistory, BoardingProcessIdIn, BoardingProcessIn, BoardingProcessStatus, BusinessPartyTraderType, BusinessPartyTraderTypesOut, CFDI, CancelPaymentReceiptIn, CancellationReason, CancellationReasonIn, CancellationReasonOut, CancellationReasonsOut, CashValueSummary, CashValueSummaryOut, Catalog, CatalogLess, CatalogsOut, ChangeLanguageIn, Checkpoint, CheckpointEventReason, CheckpointEventReasonsOut, CheckpointsOut, City, CollectionPayment, CollectionPaymentsOut, CommercialInvoice, Commodity, CompaniesOut, Company, CompanyCountriesOut, CompanyCountry, CompanyCountryIn, CompanyCountryOut, CompanyCountryTax, CompanyCountryTaxesOut, CompanyIn, CompanyOut, CompositionCountryReferencesOut, CountriesOut, Country, CountryAccount, CountryCurrencyRate, CountryDocumentType, CountryDocumentTypesOut, CountryExchange, CountryGroups, CountryGroupsOut, CountryIn, CountryOut, CountryPaymentType, CountryPaymentTypeField, CountryPaymentTypeFieldIn, CountryPaymentTypeFieldOut, CountryPaymentTypeFieldsOut, CountryPaymentTypeIn, CountryPaymentTypeOut, CountryPaymentTypesOut, CountryReference, CountryReferenceCurrenciesOut, CountryReferenceCurrency, CountryReferenceCurrencyIn, CountryReferenceCurrencyOut, CountryReferenceExtraCharge, CountryReferenceExtraChargeIn, CountryReferenceExtraChargeOut, CountryReferenceIn, CountryReferenceOut, CountryReferenceProduct, CountryReferenceProductIn, CountryReferenceProductOut, CountryReferenceProductsOut, CountryReferencesOut, Criteria, CriteriaCustom, CriteriaIn, CriteriaOut, CriteriaWithTimestamps, CurrenciesOut, Currency, CurrencyOut, Customer, CustomerComposition, CustomerCountryDocumentType, CustomerDocumentTypesOut, CustomerOpenItem, CustomerOtherInvoice, CustomerRestriction, CustomerRestrictionIn, CustomerRestrictionInV2, CustomerRestrictionOut, CustomerRestrictionsOut, CustomerType, CustomerTypesOut, CustomersOut, Customs, DeliveryConfirmationCompleteIn, DeliveryConfirmationGenerateIn, DeliveryConfirmationGenerateOut, DeliveryConfirmationIn, DeliveryConfirmationSearchOut, Department, DepartmentsOut, DependentRules, DepositSlipOut, DestinationCountry, DhlCode, DhlCodeLess, Discount, DiscountIn, DiscountOut, DiscountsOut, District, DistrictsOut, Document, DocumentCategory, DocumentCategoryReports, DocumentFunction, DocumentItem, DocumentPayment, DocumentRequests, DocumentStatus, DocumentStatusesOut, DocumentType, DocumentTypeComposition, DocumentTypeRange, DocumentTypeRangeIn, DocumentTypeRangeOut, DocumentTypeRangesOut, DocumentTypeReports, DocumentsTypesRangesCurrentStatusOut, Dropdown, DropdownConfig, EconomicActivitiesOut, EconomicActivity, EmailErrorIn, EmbassyShipment, EmbassyShipmentIn, EmbassyShipmentOut, EmbassyShipmentsOut, Employee, EmployeeCustomerDhl, EmployeeCustomersIn, EmployeeCustomersOut, EmployeeIn, EmployeeOut, EmployeesCustomersOut, EmployeesOut, Entity, Environment, EstablishmentType, EstablishmentTypesOut, Exchange, ExchangeIn, ExchangeOut, ExchangesOut, ExportType, ExportTypesOut, ExternalShipmentAddress, ExternalShipmentAddressCancellation, ExternalShipmentAddressesIn, ExternalShipmentAddressesOut, ExternalShipmentCancellationIn, ExternalShipmentFile, ExternalShipmentFileHistory, ExternalShipmentFileOut, ExternalShipmentHistoriesOut, ExternalShipmentHistory, ExternalShipmentStatus, ExternalShipmentStatusOut, ExternalShipmentStatuses, ExternalShipmentsOut, ExtraCharge, ExtraChargeComposition, ExtraChargeEntitiesIn, ExtraChargeEntitiesOut, ExtraChargeEntity, ExtraChargeIn, ExtraChargeOut, ExtraChargesOut, Facility, Field, FieldLess, FieldsOut, FileCheckOut, FillFrom, FillFromIn, FiscalRegimen, FiscalRegimensAcceptedOut, FiscalRegimensOut, GenericFolio, GenericFolioIn, GenericFolioOut, GenericFoliosOut, GetDocumentsOut, GetPostalLocationsIn, GetUserOut, GetUsersOut, HistoriesReportOut, HistoryReport, HistoryReportCheckpoint, Holiday, HolidayIn, HolidayOut, HolidaysOut, IdentificationType, IdentificationTypeComposition, IdentificationTypeCustomer, IdentificationTypeIn, IdentificationTypeNumberValidationIn, IdentificationTypeNumberValidationOut, IdentificationTypeOut, IdentificationTypesOut, Incident, IncidentIn, IncidentOut, IncidentReason, IncidentReasonComplement, IncidentReasonComplementIn, IncidentReasonComplementOut, IncidentReasonComplementsOut, IncidentReasonIn, IncidentReasonOut, IncidentReasonsOut, IncidentsOut, IncomeType, IncomeTypesOut, Installation, InstallationCountryReferenceCurrenciesOut, InstallationCountryReferenceCurrency, InstallationCountryReferenceCurrencyIn, InstallationCountryReferenceCurrencyOut, InstallationIn, InstallationOut, InstallationsOut, InventoriesReportOut, InventoryReport, Invoice, InvoiceCancellationIn, InvoiceTypeCustomParamsIn, InvoicesOut, Item, Language, LanguagesOut, LaravelModel, Location, LocationEmployee, LocationEmployeeBatchIn, LocationEmployeeOut, LocationEmployeesIn, LocationEmployeesOut, LocationIn, LocationOut, LocationType, LocationTypeFields, LocationsOut, LoyaltyPeriod, LoyaltyPeriodIn, LoyaltyPeriodOut, LoyaltyPeriodsOut, LoyaltyRule, LoyaltyRuleIn, LoyaltyRuleOut, LoyaltyRulesOut, ManagementArea, ManagementAreasOut, ManifestMultipleIn, ManifestMultipleOut, ManufactureCountry, Module, ModuleType, ModulesOut, MunicipalitiesOut, Municipality, Notification, NotificationConfiguration, NotificationConfigurationIn, NotificationConfigurationOut, NotificationIn, NotificationOut, NotificationStatus, NotificationType, NotificationsOut, NotificationsTypeOut, OpenItem, OpenItemIn, OpenItems, OpenItemsOut, OpeningTransference, OpeningTransferenceIn, OpeningTransferenceOut, Operation, OperationAccountPaymentIn, OperationAccountPaymentOut, OperationAction, OperationCancelBillingIn, OperationCancelBillingOut, OperationDocumentIn, OperationDocumentOut, OperationDocumentRequestsOut, OperationEvent, OperationModule, OperationModuleEndIn, OperationModuleOut, OperationModuleStartIn, OperationPrintDocumentOut, OperationPrintXmlOut, OperationReport, OperationShipmentExternalIn, OperationShipmentExternalOut, OperationType, OperationTypesOut, OperationsLoadTopCustomerV2In, OperationsReportOut, OtherInvoiceIn, OtherInvoiceOut, OtherInvoices, Override, OverridesOut, PackageLocation, PackageLocationsData, PackageMissing, PackageReport, PackagesInStockIn, PackagesInStockOut, PackagesReportOut, Parameter, ParameterConfig, ParameterConfigIn, ParameterConfigOut, ParameterConfigsOut, ParameterValueIn, ParameterValueOut, ParametersByLevelIn, ParametersOut, ParametersValuesIn, ParametersValuesOut, ParcelReport, ParcelsReportOut, Parish, ParishesOut, PartialWithdrawal, PartialWithdrawalsOut, Payment, PaymentDetail, PaymentOpenItemIn, PaymentOut, PaymentType, PaymentTypeFieldAccount, PaymentTypeFieldAccountIn, PaymentTypeFieldAccountOut, PaymentTypeFieldAccountsOut, PaymentTypeFieldCardType, PaymentTypeFieldCardTypeIn, PaymentTypeFieldCardTypeOut, PaymentTypeFieldCardTypesOut, PaymentTypesOut, Permission, PersonType, PersonTypesOut, Pivot, PostalCode, PostalCodeBillings, PostalCodeFormat, PostalCodesOut, PostalLocation, PostalLocationsOut, PrintCollectionReceiptOut, Product, ProductEntitiesIn, ProductEntitiesOut, ProductEntity, ProductIn, ProductOut, ProductSubtotal, PromotionCodeDiscount, PromotionCodeDiscountsOut, PromotionIn, PromotionOut, Provider, ProvidersOut, Province, ProvincesOut, PutUsersIn, PutUsersOut, QuantityUnit, QueryParams, Question, QuestionIn, QuestionOption, QuestionOut, QuestionType, QuestionTypesOut, QuestionsOut, QuoteEvent, QuoteEventIn, QuoteEventOut, QuoteEventType, QuoteEventTypesOut, QuoteEventsOut, ReEntryOfMissingPackage, ReEntryOfMissingPackageOut, ReEntryOfMissingPackages, ReEntryOfMissingPackagesIn, ReEntryOfMissingPackagesOut, ReceiptFile, ReceiptFileOut, Region, RegionsOut, ReportExternalShipment, ReportExternalShipmentAddress, Role, RoleIn, RoleOut, RoleType, RoleTypesOut, RolesOut, Rule, RuleByCriteria, RuleCriteriaIn, RuleIn, RuleOut, Rules, RulesByCriteriaOut, RulesIn, RulesOut, Sales, SalesBookReportOut, ServiceArea, ServiceAreaIn, ServiceAreasOut, Session, SessionIn, SessionOut, ShipmentAddresses, ShipmentBookPickup, ShipmentCancellationIn, ShipmentCancellationOut, ShipmentCompanyCountryExtraCharges, ShipmentComposition, ShipmentContentType, ShipmentContentTypesOut, ShipmentEmployeeCustomer, ShipmentEmployeeCustomers, ShipmentGroup, ShipmentGroupsOut, ShipmentGsop, ShipmentIncomeType, ShipmentIncomeTypeIn, ShipmentIncomeTypeOut, ShipmentIncomeTypesOut, ShipmentLandingReport, ShipmentOut, ShipmentPieceCompanyCountrySupplies, ShipmentPieces, ShipmentReports, ShipmentScope, ShipmentScopesOut, ShipmentSignaturePageOut, ShipmentStatus, ShipmentStatusesOut, ShipmentTag, ShipmentsLandingReportOut, ShipmentsReportOut, SignaturePageSetting, SignaturePageSettingIn, SignaturePageSettingOut, SignaturePageSettingsOut, State, Suburb, SuppliesOut, Supply, SupplyEntitiesIn, SupplyEntitiesOut, SupplyEntity, SupplyEntityPacking, SupplyEntityType, SupplyIn, SupplyLocation, SupplyLocationIn, SupplyLocationOut, SupplyLocationTransaction, SupplyLocationTransactionIn, SupplyLocationTransactionOut, SupplyLocationsOut, SupplyOut, SupplyPacking, SupplyTransactionType, SupplyTransactionTypesOut, SupplyType, SupplyTypesOut, Survey, SurveyIn, SurveyOut, SurveyQuestion, SurveyQuestionIn, SurveyQuestionOut, SurveyQuestionsOut, SurveysOut, SymfonyModel, System, SystemEntitiesIn, SystemEntitiesOut, SystemIn, SystemOut, SystemsOut, TDXAccountSetting, TDXAccountSettingsIn, TDXAccountSettingsOut, TDXAccountsSettingsOut, Tax, TextConfig, Tolerance, ToleranceIn, ToleranceOut, TolerancesOut, TopCustomer, TopCustomersOut, TradingTransactionType, TransferenceType, TranslateLang, Translations, UniqueFolio, UniqueFolioIn, UniqueFolioOut, UniqueFoliosOut, Unit, UnitsOut, User, UserMe, ValidateAccountIn, ValidateAccountOut, ValidateFacilityIn, ValidateFacilityOut, ValidateIdentificationBRIn, ValidateIdentificationBROut, ValidateNIPIn, ValidateNIPOut, Values, WithdrawalAmount, WorkflowConfig, WorkflowConfigsBatchIn, WorkflowConfigsOut, WorkflowsOut, Zone, ZonesOut };