/// <reference types="node" />
import { AxiosResponse, Method } from 'axios';
import { Logger } from '@medusajs/medusa/dist/types/global';
import { BaseEntity, EventBusService, Product, ProductCollectionService, ProductService, ProductTypeService, ProductVariantService, RegionService, TransactionBaseService, ProductCategoryService } from '@medusajs/medusa';
import { StrapiMedusaPluginOptions, Tokens, StrapiSendParams, MedusaUserType, AuthInterface, CreateInStrapiParams, GetFromStrapiParams, userCreds as UserCreds, StrapiAdminSendParams } from '../types/globals';
import { EntityManager } from 'typeorm';
import { AxiosError } from 'axios';
export type StrapiEntity = BaseEntity & {
    medusa_id?: string;
};
export type AdminResult = {
    data: any;
    status: number;
};
export type AdminGetResult = {
    data: {
        data: {
            results: [];
        };
        meta: any;
    };
    status: number;
};
export type MedusaGetResult<T> = {
    data: T;
    meta?: any;
    status: number;
    medusa_id?: string;
    id?: number;
};
export type StrapiResult = {
    medusa_id?: string;
    id?: number;
    data?: any | any[];
    meta?: Record<string, any>;
    status: number;
    query?: string;
};
export type StrapiGetResult = StrapiResult | {
    data: any[];
    meta?: any;
    status: number;
    medusa_id?: string;
    id?: number | string;
};
export interface StrapiQueryInterface {
    fields: string[];
    filters: Record<string, unknown>;
    populate?: any;
    sort?: string[];
    pagination?: {
        pageSize: number;
        page: number;
    };
    publicationState?: string;
    locale?: string[];
}
export interface UpdateStrapiServiceParams {
    manager: EntityManager;
    regionService: RegionService;
    productService: ProductService;
    redisClient: any;
    productVariantService: ProductVariantService;
    productTypeService: ProductTypeService;
    eventBusService: EventBusService;
    productCollectionService: ProductCollectionService;
    productCategoryService: ProductCategoryService;
    logger: Logger;
}
export interface LoginTokenExpiredErrorParams extends Partial<StrapiSendParams> {
    response?: {
        status: number;
    };
    message?: string;
    error?: AxiosError;
    time?: Date;
}
export declare class LoginTokenExpiredError extends AxiosError {
    private readonly error;
    constructor(error: LoginTokenExpiredErrorParams);
}
export declare class UpdateStrapiService extends TransactionBaseService {
    protected manager_: EntityManager;
    protected transactionManager_: EntityManager;
    static lastHealthCheckTime: number;
    productService_: ProductService;
    productVariantService_: ProductVariantService;
    productTypeService_: ProductTypeService;
    regionService_: RegionService;
    eventBus_: EventBusService;
    algorithm: string;
    options_: StrapiMedusaPluginOptions;
    strapi_protocol: string;
    strapi_url: string;
    encryption_key: string;
    userTokens: Tokens;
    redis_: any;
    key: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>;
    defaultAuthInterface: AuthInterface;
    strapiSuperAdminAuthToken: string;
    defaultUserEmail: string;
    defaultUserPassword: string;
    userAdminProfile: {
        email: string;
    };
    logger: Logger;
    static isHealthy: boolean;
    lastAdminLoginAttemptTime: number;
    static isServiceAccountRegistered: boolean;
    productCollectionService: ProductCollectionService;
    productCategoryService: any;
    private enableAdminDataLogging;
    selfTestMode: boolean;
    strapi_port: number;
    constructor(container: UpdateStrapiServiceParams, options: StrapiMedusaPluginOptions);
    withTransaction(transactionManager?: EntityManager): this;
    startInterface(): Promise<any>;
    waitForServiceAccountCreation(): Promise<void>;
    addIgnore_(id: any, side: any): Promise<any>;
    shouldIgnore_(id: any, side: any): Promise<any>;
    getVariantEntries_(variants: any, authInterface: AuthInterface): Promise<StrapiResult>;
    createImageAssets(product: Product, authInterface: AuthInterface): Promise<StrapiResult>;
    getCustomField(field: any, type: any): string;
    createEntityInStrapi<T extends BaseEntity>(params: CreateInStrapiParams<T>): Promise<StrapiResult>;
    getEntitiesFromStrapi(params: GetFromStrapiParams): Promise<StrapiGetResult>;
    createProductTypeInStrapi(productTypeId: string, authInterface: AuthInterface): Promise<StrapiResult>;
    createProductInStrapi(productId: any, authInterface: AuthInterface): Promise<StrapiResult>;
    updateCollectionInStrapi(data: any, authInterface: AuthInterface): Promise<StrapiResult>;
    strapiPluginLog(logType: string, message: string, data?: Record<string, any>): void;
    createCollectionInStrapi(collectionId: string, authInterface: AuthInterface): Promise<StrapiResult>;
    updateCategoryInStrapi(data: any, authInterface: AuthInterface): Promise<StrapiResult>;
    createCategoryInStrapi(categoryId: string, authInterface: AuthInterface): Promise<StrapiResult>;
    createProductVariantInStrapi(variantId: any, authInterface: AuthInterface): Promise<StrapiResult>;
    convertOptionValueToMedusaReference(data: any): Record<string, any>;
    createRegionInStrapi(regionId: any, authInterface: AuthInterface): Promise<StrapiResult>;
    updateRegionInStrapi(data: any, authInterface?: AuthInterface): Promise<StrapiResult>;
    /**
     * Product metafields id is the same as product id
     * @param data
     * @param authInterface
     * @returns
     */
    createProductMetafieldInStrapi(data: {
        id: string;
        value: Record<string, unknown>;
    }, authInterface?: AuthInterface): Promise<StrapiResult>;
    updateProductMetafieldInStrapi(data: {
        id: string;
        value: Record<string, unknown>;
    }, authInterface: AuthInterface): Promise<StrapiResult>;
    updateProductsWithinCollectionInStrapi(data: any, authInterface?: AuthInterface): Promise<StrapiResult>;
    updateProductsWithinCategoryInStrapi(data: any, authInterface?: AuthInterface): Promise<StrapiResult>;
    updateProductInStrapi(data: Partial<Product>, authInterface?: AuthInterface): Promise<StrapiResult>;
    private adjustProductAndUpdateInStrapi;
    checkType(type: any, authInterface: any): Promise<boolean>;
    updateProductVariantInStrapi(data: any, authInterface: AuthInterface): Promise<StrapiResult>;
    deleteProductMetafieldInStrapi(data: {
        id: string;
    }, authInterface: AuthInterface): Promise<StrapiResult>;
    deleteProductInStrapi(data: any, authInterface: AuthInterface): Promise<StrapiResult>;
    deleteProductTypeInStrapi(data: any, authInterface: AuthInterface): Promise<StrapiResult>;
    deleteProductVariantInStrapi(data: any, authInterface: AuthInterface): Promise<StrapiResult>;
    deleteRegionInStrapi(data: any, authInterface: any): Promise<StrapiResult>;
    deleteCollectionInStrapi(data: any, authInterface: any): Promise<StrapiResult>;
    deleteCategoryInStrapi(data: any, authInterface: any): Promise<StrapiResult>;
    getType(type: string, authInterface: AuthInterface): Promise<StrapiResult>;
    private executeStrapiHealthCheck;
    checkStrapiHealth(): Promise<boolean>;
    /**
     *
     * @param text the text to encrpyt
     * @returns encrypted text
     */
    encrypt(text: string): string;
    /**
     * @todo  implement decryption
     * @param text
     * @returns
     */
    decrypt(text: any): string;
    /**
     *
     * @returns the default user  - service account for medusa requests
     */
    registerDefaultMedusaUser(): Promise<{
        id: string;
    }>;
    /**
     * Deletes the service account
     * @returns the deleted default user
     */
    deleteDefaultMedusaUser(): Promise<StrapiResult>;
    /**
     * Deletes a medusa user from strapi
     * @param authInterface - the user authorisation parameters
     * @returns
     */
    deleteMedusaUserFromStrapi(authInterface: AuthInterface): Promise<StrapiResult>;
    /**
     * @Todo Create API based access
  async fetchMedusaUserApiKey(emailAddress) {

    return await this.strapiAdminSend("get")
  }

  */
    executeSync(token: string): Promise<AxiosResponse>;
    /**
     * Readies the server to be used with a service account
     */
    configureStrapiMedusaForUser(authInterface: AuthInterface): Promise<StrapiResult>;
    retrieveRefreshedToken(authInterface: AuthInterface, errorCode?: string | number): Promise<UserCreds>;
    strapiLoginSendDatalayer(authInterface?: AuthInterface): Promise<UserCreds>;
    executeLoginAsStrapiUser(authInterface?: AuthInterface): Promise<AxiosResponse>;
    getRoleId(requestedRole: string): Promise<number>;
    processStrapiEntry(command: StrapiSendParams): Promise<StrapiResult>;
    doesEntryExistInStrapi(type: string, id: string, authInterface: AuthInterface): Promise<StrapiResult>;
    createEntryInStrapi(command: StrapiSendParams): Promise<StrapiResult>;
    getEntriesInStrapi(command: StrapiSendParams): Promise<StrapiGetResult>;
    updateEntryInStrapi(command: StrapiSendParams): Promise<StrapiResult>;
    deleteEntryInStrapi(command: StrapiSendParams): Promise<StrapiResult>;
    private isEntity;
    private translateRelationNamesToStrapiFormat;
    private translateRelationNamesToMedusaFormat;
    translateDataToStrapiFormat(dataToSend: StrapiEntity): StrapiEntity;
    translateDataToMedusaFormat(dataReceived: StrapiGetResult): MedusaGetResult<typeof dataReceived.data>;
    strapiSendDataLayer(params: StrapiSendParams): Promise<StrapiResult>;
    /**
     * Blocks the process until strapi is healthy
     *
     *
     */
    waitForHealth(): Promise<void>;
    executeStrapiSend({ method, type, token, id, data, query, }: {
        method: Method;
        type: string;
        token: string;
        id?: string;
        data?: any;
        query?: string;
    }): Promise<AxiosResponse>;
    appendIdToStrapiFilter(query: string, id?: string): string;
    _axiosError(error: AxiosError, id?: string, type?: string, data?: any, method?: Method, endPoint?: string): void;
    refreshResend(error: any, id: string, type: string, data: any, method: string, endPoint: string): Promise<void>;
    handleError(error: any, id?: string, type?: string, data?: any, method?: Method, endPoint?: string): void;
    executeStrapiAdminSend(method: Method, type: string, id?: string, action?: string, data?: any, query?: string): Promise<AxiosResponse | undefined>;
    executeRegisterMedusaUser(auth: MedusaUserType): Promise<AxiosResponse | undefined>;
    /** *
     * send the command using elevated privileges
     */
    strapiAdminSendDatalayer(command: StrapiAdminSendParams): Promise<AdminResult>;
    registerSuperAdminUserInStrapi(): Promise<any>;
    registerAdminUserInStrapi(email: string, firstname: string, password?: string, role?: string): Promise<AdminResult>;
    updateAdminUserInStrapi(email: string, firstname: string, password?: string, role?: string, isActive?: boolean): Promise<AdminResult>;
    getAdminUserInStrapi(email: string): Promise<AdminResult>;
    getAllAdminUserInStrapi(): Promise<AdminResult>;
    deleteAdminUserInStrapi(email: string, role?: string): Promise<AdminResult>;
    fetchUserToken(email?: string): string;
    executeLoginAsStrapiSuperAdmin(): Promise<{
        data: {
            user: any;
            token: string;
        };
    }>;
    intializeServer(): Promise<any>;
    registerOrLoginAdmin(): Promise<{
        data: {
            user: any;
            token: string;
        };
    }>;
    loginAsDefaultMedusaUser(): Promise<UserCreds>;
    registerOrLoginDefaultMedusaUser(): Promise<UserCreds>;
    verifyDataContainsFields(data: any, updateFields: any[]): boolean;
    /**
     * This function allows you to create a strapi query
     */
    createStrapiRestQuery(strapiQuery: StrapiQueryInterface): string;
}
export default UpdateStrapiService;