import { BaseRestModel, IEnvironment, RestTypeConnection, FilterableQuery, TSimpleCondition, TComplexCondition, BaseModel as BaseModel$1, BaseRestResource, FileLogger } from 'ecloud-base-connector';

declare abstract class BaseModel extends BaseRestModel {
    constructor(modelData?: any);
    protected static checkPopulateData(modelData: any, requiredFields: string[]): void;
    protected static checkOneOfManyFields(baseData: any, oneOfManyRequiredFiels: string[]): void;
    abstract toJson(): any;
    abstract clone(): BaseModel;
    abstract getChanges(existentModel: BaseModel): any;
}

declare class ImportResult extends BaseModel {
    static readonly modelName = "stockOrder";
    static readonly fields: {
        success: string;
        result: string;
        errorTrace: string;
        errorMessage: string;
    };
    static readonly requiredFields: never[];
    success: boolean;
    result: any;
    errorTrace: string;
    errorMessage: string;
    populate(modelData: any): void;
    toJson(): any;
    getChanges(newModel: ImportResult): any;
    clone(): ImportResult;
}

declare abstract class MagentoEnv implements IEnvironment {
    abstract readonly code: string;
    abstract readonly name: string;
    protected readonly baseUrl: string;
    protected readonly apiKey: string;
    constructor(baseUrl: string, apiKey: string);
    validate(): void;
    getConnection(): RestTypeConnection;
}

declare class Request extends FilterableQuery {
    private orderBy;
    private limit;
    constructor(modelName: string);
    getQueryData(): any;
    compileQuery(): {
        queryString: string;
        queryData: any;
    };
    addOrderBy(orderField: string, orderType?: "ASC" | "DESC"): this;
    addLimit(limit: number): this;
    private checkAddOrderBy;
    private checkAddLimit;
    private prepareOrderBy;
    private prepareLimit;
    protected compileFilters(): any;
    protected compileQueryFilter(queryFilters: any[]): any;
    protected compileLineFilter(lineFilters: {
        [fieldName: string]: any;
    }): any;
    protected compileFieldConditions(fieldName: string, conditions: (TSimpleCondition | TComplexCondition)[]): any;
    protected compileConditions(fieldName: string, condition: TSimpleCondition | TComplexCondition): any;
    protected compileOrderByData(): string[];
    protected compileLimitData(): number | null;
}

declare abstract class BaseResource<T extends BaseModel$1> extends BaseRestResource {
    abstract modelName: string;
    constructor({ logger }?: {
        logger?: FileLogger | null;
    }, connection?: RestTypeConnection);
    getLoggerExtension(): string;
    getRequest(): Request;
    abstract parse(data: any): T;
    filter(request: Request): Promise<T[]>;
    getOne(modelID: number): Promise<T>;
}

declare enum TIntegrationRunTypes {
    importNow = "import_now",
    generateFile = "generate_file"
}

declare class ImportResource extends BaseResource<ImportResult> {
    modelName: string;
    parse(modelData: any): ImportResult;
    run(integrationCode: string, integrationData: any, runType?: TIntegrationRunTypes): Promise<ImportResult>;
}

declare const initEnv: (selectedStore: MagentoEnv) => any;

export { BaseResource as BaseMagentoResource, MagentoEnv, ImportResource as MagentoImportResource, ImportResult as MagentoImportResult, TIntegrationRunTypes as MagentoIntegrationRunTypes, Request as MagentoRequest, initEnv };