import { TaxoNode } from "./taxonomy/types.js";
import { FetchFn } from "./types.js";
import { components, operations, paths } from "./schemas/server/v2.js";
import { ProductDataType } from "./off-v3.js";
import * as _$openapi_fetch0 from "openapi-fetch";
import createClient from "openapi-fetch";

//#region src/off-v2.d.ts
type SearchQuery = operations["get-search"]["parameters"]["query"];
type AttributeGroups = components["schemas"]["get_attribute_groups"];
type Product = components["schemas"]["Product"];
type SearchResult = components["schemas"]["search_for_products"];
type ProductAttribute = NonNullable<components["schemas"]["product_attribute_groups"]["attribute_groups"]>[number];
type ProductAttributeGroup = {
  id: string;
  name: string;
  warning?: string;
  attributes: ProductAttribute[];
};
/**
 * The OpenFoodFacts main API client for version 2.
 *
 * You should not use this class directly, instead use the `OpenFoodFactsApi` class.
 */
declare class ProductOpenerApiV2 {
  private readonly fetch;
  private readonly baseUrl;
  readonly client: ReturnType<typeof createClient<paths>>;
  constructor(fetch: FetchFn, options: {
    host: string;
  });
  /**
   * Get a taxonomy entry by its type and ID.
   * @param taxo - The type of taxonomy (e.g., "categories", "brands").
   * @param entry - The ID of the taxonomy entry.
   */
  getTaxoEntry<T extends TaxoNode>(taxo: string, entry: string): Promise<T>;
  /**
   * Performs OCR on a product image.
   * @example const {data, error} = await performOCR(barcode, photoId, ocrEngine);
   */
  performOCR(barcode: string, photoId: string, ocrEngine?: "google_cloud_vision"): Promise<_$openapi_fetch0.FetchResponse<{
    parameters: {
      query: {
        id: components["parameters"]["id"];
        code: components["parameters"]["Code"];
        process_image: components["parameters"]["process_image"];
        ocr_engine: components["parameters"]["ocr_engine"];
      };
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["ocr_on_product"];
        };
      };
    };
  }, {
    params: {
      query: {
        code: string;
        id: string;
        ocr_engine: "google_cloud_vision";
        process_image: string;
      };
    };
  }, `${string}/${string}`>>;
  /**
   * @example const {data, error} = await search(query);
   */
  search(query: SearchQuery): Promise<_$openapi_fetch0.FetchResponse<{
    parameters: {
      query?: {
        additives_tags?: components["parameters"]["additives_tags"];
        allergens_tags?: components["parameters"]["allergens_tags"];
        brands_tags?: components["parameters"]["brands_tags"];
        categories_tags?: components["parameters"]["categories_tags"];
        countries_tags_en?: components["parameters"]["countries_tags"];
        emb_codes_tags?: components["parameters"]["emb_codes_tags"];
        labels_tags?: components["parameters"]["labels_tags"];
        manufacturing_places_tags?: components["parameters"]["manufacturing_places_tags"];
        nutrition_grades_tags?: components["parameters"]["nutrition_grades_tags"];
        origins_tags?: components["parameters"]["origins_tags"];
        packaging_tags_de?: components["parameters"]["packaging_tags"];
        purchase_places_tags?: components["parameters"]["purchase_places_tags"];
        states_tags?: components["parameters"]["states_tags"];
        stores_tags?: components["parameters"]["stores_tags"];
        traces_tags?: components["parameters"]["traces_tags"];
        "<tag_name>_tags_<language_code>"?: components["parameters"]["tag_name_with_language_code"];
        "<nutrient>_lt_<value>"?: components["parameters"]["nutrient_lower_than"];
        "<nutrient>_gt_<value>"?: components["parameters"]["nutrient_greater_than"];
        "<nutrient>_eq_<value>"?: components["parameters"]["nutrient_equal"];
        fields?: components["parameters"]["ProductAvailableFields"];
        sort_by?: components["parameters"]["sort_by"];
        page?: components["parameters"]["page"];
        page_size?: components["parameters"]["page_size"];
      };
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["search_for_products"];
        };
      };
    };
  }, {
    params: {
      query: {
        additives_tags?: components["parameters"]["additives_tags"];
        allergens_tags?: components["parameters"]["allergens_tags"];
        brands_tags?: components["parameters"]["brands_tags"];
        categories_tags?: components["parameters"]["categories_tags"];
        countries_tags_en?: components["parameters"]["countries_tags"];
        emb_codes_tags?: components["parameters"]["emb_codes_tags"];
        labels_tags?: components["parameters"]["labels_tags"];
        manufacturing_places_tags?: components["parameters"]["manufacturing_places_tags"];
        nutrition_grades_tags?: components["parameters"]["nutrition_grades_tags"];
        origins_tags?: components["parameters"]["origins_tags"];
        packaging_tags_de?: components["parameters"]["packaging_tags"];
        purchase_places_tags?: components["parameters"]["purchase_places_tags"];
        states_tags?: components["parameters"]["states_tags"];
        stores_tags?: components["parameters"]["stores_tags"];
        traces_tags?: components["parameters"]["traces_tags"];
        "<tag_name>_tags_<language_code>"?: components["parameters"]["tag_name_with_language_code"];
        "<nutrient>_lt_<value>"?: components["parameters"]["nutrient_lower_than"];
        "<nutrient>_gt_<value>"?: components["parameters"]["nutrient_greater_than"];
        "<nutrient>_eq_<value>"?: components["parameters"]["nutrient_equal"];
        fields?: components["parameters"]["ProductAvailableFields"];
        sort_by?: components["parameters"]["sort_by"];
        page?: components["parameters"]["page"];
        page_size?: components["parameters"]["page_size"];
      } | undefined;
    };
  }, `${string}/${string}`>>;
  /**
   * Returns all available attribute groups
   * @returns A promise that resolves to an array of attribute groups
   * @example
   * const {data, error} = await getAttributeGroups();
   */
  getAttributeGroups(): Promise<_$openapi_fetch0.FetchResponse<{
    parameters: {
      query?: {
        lc?: components["parameters"]["Lc"];
      };
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["get_attribute_groups"];
        };
      };
    };
  }, _$openapi_fetch0.FetchOptions<{
    parameters: {
      query?: {
        lc?: components["parameters"]["Lc"];
      };
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["get_attribute_groups"];
        };
      };
    };
  }> | undefined, `${string}/${string}`>>;
  /**
   * Unselects an image for a product
   * @param barcode - The barcode of the product
   * @param id - Image field (image id) of the photo to unselect (e.g., "front_fr")
   * @returns A promise that resolves to the unselect response
   */
  unselectImage(barcode: string, id: string): Promise<_$openapi_fetch0.FetchResponse<{
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody?: {
      content: {
        "multipart/form-data": components["schemas"]["unselect_a_photo"];
      };
    };
    responses: {
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": {
            status?: string;
            status_code?: number;
            imagefield?: string;
          };
        };
      };
    };
  }, {
    body: {
      code: string;
      id: string;
    };
  }, `${string}/${string}`>>;
  /**
   * Returns product attributes for a given barcode
   * @param barcode - The barcode of the product
   * @returns A promise that resolves to an array of product attributes
   */
  getProductAttributes(code: string): Promise<ProductAttributeGroup[]>;
  /**
   * Adds or edits a product using the V2 API
   * @param product - The product data to add or edit
   * @param credentials - Optional credentials for authentication
   * @returns A promise that resolves to true if successful, false otherwise
   */
  addOrEditProductV2(product: ProductDataType & {
    comment?: string;
  }, credentials?: {
    username: string;
    password: string;
  }): Promise<boolean>;
  /**
   * Crops and selects an image for a product
   * @param barcode - The barcode of the product
   * @param imgid - Identifier of the image to select (should be a number)
   * @param id - Identifier of the selected image field (format: {IMAGE_TYPE}_{LANG})
   * @param cropData - Crop coordinates and options
   * @returns A promise that resolves to the crop response
   *
   * @example
   * const {data, error} = await cropImage(barcode, imgid, id, cropData);
   */
  cropImage(barcode: string, imgid: number, id: string, cropData: {
    x1: number;
    y1: number;
    x2: number;
    y2: number;
    angle?: number;
    normalize?: boolean;
    white_magic?: boolean;
    comment?: string;
    app_name?: string;
    app_version?: string;
    app_uuid?: string;
    user_agent?: string;
  }): Promise<_$openapi_fetch0.FetchResponse<{
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody: {
      content: {
        "multipart/form-data": components["schemas"]["crop_a_photo"] & components["schemas"]["change_ref_properties"];
      };
    };
    responses: {
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["product_image_crop"];
        };
      };
    };
  }, _$openapi_fetch0.FetchOptions<{
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody: {
      content: {
        "multipart/form-data": components["schemas"]["crop_a_photo"] & components["schemas"]["change_ref_properties"];
      };
    };
    responses: {
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["product_image_crop"];
        };
      };
    };
  }> | undefined, `${string}/${string}`>>;
  /**
   * Uploads an image to OpenFoodFacts for a product.
   * @param barcode - The barcode of the product
   * @param imageFile - The image file to upload
   * @param imagefield - The field name for the image (e.g., "front", "ingredients", "nutrition")
   * @returns A promise that resolves to the upload response
   */
  uploadImage(barcode: string, imageFile: File, imagefield: string): Promise<_$openapi_fetch0.FetchResponse<{
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody?: {
      content: {
        "multipart/form-data": components["schemas"]["add_photo_to_existing_product"] & components["schemas"]["change_ref_properties"];
      };
    };
    responses: {
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["add_photo_to_existing_product-2"];
        };
      };
    };
  }, _$openapi_fetch0.FetchOptions<{
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody?: {
      content: {
        "multipart/form-data": components["schemas"]["add_photo_to_existing_product"] & components["schemas"]["change_ref_properties"];
      };
    };
    responses: {
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["add_photo_to_existing_product-2"];
        };
      };
    };
  }> | undefined, `${string}/${string}`>>;
  /**
   * Rotates an image for a product
   * @param barcode - The barcode of the product
   * @param id - Identifier of the selected image field (format: {IMAGE_TYPE}_{LANG})
   * @param imgid - Identifier of the image to rotate (should be a number as string)
   * @param angle - Angle of rotation in degrees (90, 180, or 270 clockwise)
   * @returns A promise that resolves to the rotation response
   */
  rotateImage(barcode: string, id: string, imgid: string, angle: string): Promise<_$openapi_fetch0.FetchResponse<{
    parameters: {
      query: {
        code: components["parameters"]["Code"];
        id: components["parameters"]["id"];
        imgid: components["parameters"]["imgid"];
        angle: components["parameters"]["angle"];
      };
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["rotate_a_photo"];
        };
      };
    };
  }, {
    params: {
      query: {
        code: string;
        id: string;
        imgid: string;
        angle: string;
      };
    };
  }, `${string}/${string}`>>;
  /**
   * Returns product data using the V2 API
   * @param barcode - The barcode of the product
   * @returns A promise that resolves to the product data or undefined if not found
   * @example
   * const {data, error} = await getProductV2(barcode);
   */
  getProductV2(code: string): Promise<_$openapi_fetch0.FetchResponse<{
    parameters: {
      query?: {
        product_type?: components["parameters"]["RequestedProductType"];
        cc?: components["parameters"]["Cc"];
        lc?: components["parameters"]["Lc"];
        fields?: components["parameters"]["ProductAvailableFields"];
        knowledge_panel_client?: components["parameters"]["KnowledgePanelClient"];
        activate_knowledge_panels_simplified?: components["parameters"]["ActivateKnowledgePanelsSimplified"];
        activate_knowledge_panel_physical_activities?: components["parameters"]["ActivateKnowledgePanelPhysicalActivities"];
        knowledge_panels_included?: components["parameters"]["KnowledgePanelsIncluded"];
        knowledge_panels_excluded?: components["parameters"]["KnowledgePanelsExcluded"];
        blame?: components["parameters"]["Blame"];
      };
      header?: never;
      path: {
        code: string;
      };
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["get_product_by_barcode"] | (components["schemas"]["get_product_by_barcode_base"] & {
            product?: components["schemas"]["product_knowledge_panels"];
          }) | components["schemas"]["get_product_by_barcode_with_blame"];
        };
      };
      302: {
        headers: {
          Location?: string;
          [name: string]: unknown;
        };
        content?: never;
      };
      404: {
        headers: {
          [name: string]: unknown;
        };
        content?: never;
      };
    };
  }, {
    params: {
      path: {
        code: string;
      };
    };
  }, `${string}/${string}`>>;
  /**
   * Returns an array of image names for the product
   * @param code - The barcode of the product
   * @returns A promise that resolves to an array of image names or null if not found
   */
  getProductImages(code: string): Promise<string[] | null>;
  /**
   * Updates the barcode of a product (moderator-only action)
   * @param currentCode - The current barcode of the product
   * @param newCode - The correct barcode to replace the current one
   * @returns A promise that resolves to true if successful, false otherwise
   * @example
   * const success = await changeBarcode("12345", "54321");
   */
  changeBarcode(currentCode: string, newCode: string, credentials?: {
    username?: string;
    password?: string;
  }): Promise<boolean>;
  /**
   * Delete a product page (moderator-only action)
   * @param code - product barcode
   * @param comment - reason for deletion
   * @returns A promise that resolves to true if successful, false otherwise
   */
  deleteProduct(code: string, comment: string): Promise<boolean>;
  /**
   * Move images from one product to another (moderator-only action)
   * @param code - source product barcode
   * @param imgids - comma-separated list of image IDs (e.g., "1,2,3")
   * @param moveToBarcode - destination product barcode
   * @param copyData - whether to copy product data to destination
   * @returns A promise that resolves with `{ data }` on success or `{ error }` on failure
   * @example
   * const result = await moveImages("12345", "1,2,3", "54321", true);
   * if ("error" in result) {
   *   console.error("Failed to move images:", result.error);
   * } else {
   *   console.log("Images moved successfully:", result.data);
   * }
   */
  moveImages(code: string, imgids: string, moveToBarcode: string, copyData?: boolean): Promise<{
    error: Error;
    response?: Response;
  } | {
    data: unknown;
    response?: Response;
  }>;
  /**
   * Delete product images by moving them to trash (moderator-only action)
   * @param code - product barcode
   * @param imgids - comma-separated list of image IDs (e.g., "1,2,3")
   * @returns A promise that resolves with `{ data }` on success or `{ error }` on failure
   * @example
   * const result = await deleteImages("12345", "1,2,3");
   * if ("error" in result) {
   *   console.error("Failed to delete images:", result.error);
   * } else {
   *   console.log("Images deleted successfully:", result.data);
   * }
   */
  deleteImages(code: string, imgids: string): Promise<{
    error: Error;
    response?: Response;
  } | {
    data: unknown;
    response?: Response;
  }>;
  /**
   * Calls /cgi/product_image_move.pl to move or delete images, depending on the
   * parameters.
   */
  private productImageMove;
}
declare function getProductNameInLang(product: ProductDataType, lang: string): string;
declare function getProductIngredientsInLang(product: ProductDataType, lang: string): string;
//#endregion
export { AttributeGroups, Product, ProductAttribute, ProductAttributeGroup, ProductOpenerApiV2, SearchQuery, SearchResult, getProductIngredientsInLang, getProductNameInLang };
//# sourceMappingURL=off-v2.d.ts.map