Class Robotoff

Index

Constructors

Methods

annotate annotateLogos fetchLogos getCroppedImageUrl getLogoAnnotations getQuestionsUnanswered getUserStatistics insightDetail insights loadLogo questions questionsByProductCode resetLogo searchLogos updateLogo

Constructors

constructor

new Robotoff(
    fetch: (
        input: string | Request | URL,
        init?: RequestInit,
    ) => Promise<Response>,
    options?: { baseUrl: string },
): Robotoff
Parameters
- fetch: (input: string | Request | URL, init?: RequestInit) => Promise<Response>
- options: { baseUrl: string } = ...
Returns Robotoff
- Defined in robotoff.ts:48

Methods

annotate

annotate(
    body: {
        annotation: -1 | 0 | 1 | 2;
        data?: Record<string, unknown> | null;
        device_id?: string;
        insight_id: string;
        update?: 0 | 1;
    },
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: undefined;
            };
            requestBody: {
                content: {
                    "application/x-www-form-urlencoded": {
                        annotation: -1
                        | 0
                        | 1
                        | 2;
                        data?: Record<string, unknown> | null;
                        device_id?: string;
                        insight_id: string;
                        update?: 0 | 1;
                    };
                };
            };
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            description?: string;
                            status?: string;
                            status_code?: number;
                        };
                    };
                    headers: { [name: string]: unknown };
                };
                "400": { content?: undefined; headers: { [name: string]: unknown } };
                "404": { content?: undefined; headers: { [name: string]: unknown } };
            };
        },
        {
            body: {
                annotation: -1
                | 0
                | 1
                | 2;
                data?: Record<string, unknown> | null;
                device_id?: string;
                insight_id: string;
                update?: 0 | 1;
            };
            bodySerializer: (params: Record<string, FormBodyValue>) => string;
            headers: { "Content-Type": "application/x-www-form-urlencoded" };
        },
        `${string}/${string}`,
    >,
>
Parameters
- body: {
      annotation: -1 | 0 | 1 | 2;
      data?: Record<string, unknown> | null;
      device_id?: string;
      insight_id: string;
      update?: 0 | 1;
  }
  - annotation: -1 | 0 | 1 | 2
    Description
    Annotation of the prediction: 1 to accept the prediction, 0 to refuse it, and -1 for skip, 2 to accept and add data
  - Optionaldata?: Record<string, unknown> | null
    Description
    Additional data provided by the user as key-value pairs (required when annotation=2)
  - Optionaldevice_id?: string
    Description
    Device identifier for tracking anonymous votes
  - insight_id: string
    Format: uuid
    
    Description
    ID of the insight
    
    Example
    3cd5aecd-edcc-4237-87d0-6595fc4e53c9
  - Optionalupdate?: 0 | 1
    Description
    Send the update to Openfoodfacts if update=1, don't send the update otherwise. This parameter is useful if the update is performed client-side
    
    Default
    1 @enum {integer}
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: undefined;
            };
            requestBody: {
                content: {
                    "application/x-www-form-urlencoded": {
                        annotation: -1
                        | 0
                        | 1
                        | 2;
                        data?: Record<string, unknown> | null;
                        device_id?: string;
                        insight_id: string;
                        update?: 0 | 1;
                    };
                };
            };
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            description?: string;
                            status?: string;
                            status_code?: number;
                        };
                    };
                    headers: { [name: string]: unknown };
                };
                "400": { content?: undefined; headers: { [name: string]: unknown } };
                "404": { content?: undefined; headers: { [name: string]: unknown } };
            };
        },
        {
            body: {
                annotation: -1
                | 0
                | 1
                | 2;
                data?: Record<string, unknown> | null;
                device_id?: string;
                insight_id: string;
                update?: 0 | 1;
            };
            bodySerializer: (params: Record<string, FormBodyValue>) => string;
            headers: { "Content-Type": "application/x-www-form-urlencoded" };
        },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:63

annotateLogos

annotateLogos(
    annotations: {
        logo_id: number;
        type:
            | "label"
            | "brand"
            | "category"
            | "no_logo"
            | "nutritional_label"
            | "packager_code"
            | "packaging"
            | "qr_code"
            | "store";
        value: string
        | null;
    }[],
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: undefined;
            };
            requestBody: {
                content: {
                    "application/json": {
                        annotations: {
                            logo_id: number;
                            type: | "label"
                            | "brand"
                            | "category"
                            | "no_logo"
                            | "nutritional_label"
                            | "packager_code"
                            | "packaging"
                            | "qr_code"
                            | "store";
                            value: string
                            | null;
                        }[];
                        server_type?: "off"
                        | "obf"
                        | "opff"
                        | "opf"
                        | "off_pro";
                    };
                };
            };
            responses: {
                "200": {
                    content: { "application/json": { annotated?: number } };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            body: {
                annotations: {
                    logo_id: number;
                    type: | "label"
                    | "brand"
                    | "category"
                    | "no_logo"
                    | "nutritional_label"
                    | "packager_code"
                    | "packaging"
                    | "qr_code"
                    | "store";
                    value: string
                    | null;
                }[];
            };
        },
        `${string}/${string}`,
    >,
>
Parameters
- annotations: {
      logo_id: number;
      type:
          | "label"
          | "brand"
          | "category"
          | "no_logo"
          | "nutritional_label"
          | "packager_code"
          | "packaging"
          | "qr_code"
          | "store";
      value: string
      | null;
  }[]
  - logo_id: number
    Description
    ID of the logo to annotate
  - type:
        | "label"
        | "brand"
        | "category"
        | "no_logo"
        | "nutritional_label"
        | "packager_code"
        | "packaging"
        | "qr_code"
        | "store"
    Description
    Type of the logo
  - value: string | null
    Description
    Value/name of the logo
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: undefined;
            };
            requestBody: {
                content: {
                    "application/json": {
                        annotations: {
                            logo_id: number;
                            type: | "label"
                            | "brand"
                            | "category"
                            | "no_logo"
                            | "nutritional_label"
                            | "packager_code"
                            | "packaging"
                            | "qr_code"
                            | "store";
                            value: string
                            | null;
                        }[];
                        server_type?: "off"
                        | "obf"
                        | "opff"
                        | "opf"
                        | "off_pro";
                    };
                };
            };
            responses: {
                "200": {
                    content: { "application/json": { annotated?: number } };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            body: {
                annotations: {
                    logo_id: number;
                    type: | "label"
                    | "brand"
                    | "category"
                    | "no_logo"
                    | "nutritional_label"
                    | "packager_code"
                    | "packaging"
                    | "qr_code"
                    | "store";
                    value: string
                    | null;
                }[];
            };
        },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:113

fetchLogos

fetchLogos(
    logoIds: string[],
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: { logo_ids?: string };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count: number;
                            logos: {
                                annotation_type?: string;
                                annotation_value?: string;
                                annotation_value_tag?: string;
                                barcode: string;
                                bounding_box?: (...)[];
                                completed_at?: string;
                                id: number;
                                image?: Record<(...), (...)>;
                                nearest_neighbors?: { distances?: ...; logo_ids?: ... };
                                score?: number;
                                server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                                source_image?: string;
                                taxonomy_value?: string;
                                text?: string;
                                username?: string;
                            }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { query: { logo_ids: string } } },
        `${string}/${string}`,
    >,
>
Get a batch of logo from their ids.
Parameters
- logoIds: string[]
  The array of logos to fetch.
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: { logo_ids?: string };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count: number;
                            logos: {
                                annotation_type?: string;
                                annotation_value?: string;
                                annotation_value_tag?: string;
                                barcode: string;
                                bounding_box?: (...)[];
                                completed_at?: string;
                                id: number;
                                image?: Record<(...), (...)>;
                                nearest_neighbors?: { distances?: ...; logo_ids?: ... };
                                score?: number;
                                server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                                source_image?: string;
                                taxonomy_value?: string;
                                text?: string;
                                username?: string;
                            }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { query: { logo_ids: string } } },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:215

getCroppedImageUrl

getCroppedImageUrl(
imageUrl: string,
boundingBox: [number, number, number, number],
): string
Parameters
- imageUrl: string
- boundingBox: [number, number, number, number]
  The bounding box of the crop, in the format [y_min, x_min, y_max, x_max]
Returns string
- Defined in robotoff.ts:193

getLogoAnnotations

getLogoAnnotations(
    logoId?: number,
    index?: number,
    count?: number,
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: {
                    count?: number;
                    server_type?: "off"
                    | "obf"
                    | "opff"
                    | "opf"
                    | "off_pro";
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count: number;
                            query_logo_id: number;
                            results: { distance: number; logo_id: number }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { query: { count: number; index: number } } },
        `${string}/${string}`,
    >,
>
Parameters
- OptionallogoId: number
- index: number = 0
- count: number = 25
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: {
                    count?: number;
                    server_type?: "off"
                    | "obf"
                    | "opff"
                    | "opf"
                    | "off_pro";
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count: number;
                            query_logo_id: number;
                            results: { distance: number; logo_id: number }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { query: { count: number; index: number } } },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:125

getQuestionsUnanswered

getQuestionsUnanswered(
    query?: Omit<
        | {
            campaigns?: string;
            count?: number;
            countries?: string;
            page?: number;
            predictor?: string;
            reserved_barcode?: boolean;
            server_type?: "off"
            | "obf"
            | "opff"
            | "opf"
            | "off_pro";
            type?: string;
        }
        | undefined,
        "count"
        | "page",
    >,
    page?: number,
    count?: number,
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: {
                    campaigns?: string;
                    count?: number;
                    countries?: string;
                    page?: number;
                    predictor?: string;
                    reserved_barcode?: boolean;
                    server_type?: "off"
                    | "obf"
                    | "opff"
                    | "opf"
                    | "off_pro";
                    type?: string;
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count: number;
                            questions: (string | number)[];
                            status: "no_questions" | "found";
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { query: { count: number; page: number } } },
        `${string}/${string}`,
    >,
>
Returns the number of unanswered questions per values. Especially useful for campaigns like the eco-score one
Parameters
- Optionalquery: Omit<
      | {
          campaigns?: string;
          count?: number;
          countries?: string;
          page?: number;
          predictor?: string;
          reserved_barcode?: boolean;
          server_type?: "off"
          | "obf"
          | "opff"
          | "opf"
          | "off_pro";
          type?: string;
      }
      | undefined,
      "count"
      | "page",
  >
- page: number = 0
  The page number
  Default
  0
- count: number = 25
  The page size
  Default
  25
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: {
                    campaigns?: string;
                    count?: number;
                    countries?: string;
                    page?: number;
                    predictor?: string;
                    reserved_barcode?: boolean;
                    server_type?: "off"
                    | "obf"
                    | "opff"
                    | "opf"
                    | "off_pro";
                    type?: string;
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count: number;
                            questions: (string | number)[];
                            status: "no_questions" | "found";
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { query: { count: number; page: number } } },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:162

getUserStatistics

getUserStatistics(
    username: string,
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path: { username: string };
                query?: undefined;
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": { count?: { annotations?: number } };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { path: { username: string } } },
        `${string}/${string}`,
    >,
>
Parameters
- username: string
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path: { username: string };
                query?: undefined;
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": { count?: { annotations?: number } };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { path: { username: string } } },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:187

insightDetail

insightDetail(
    id: string,
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path: { insight_id: string };
                query?: undefined;
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            barcode: number;
                            countries: string[];
                            data?: { bounding_box?: (...)[]; logo_id?: number };
                            id: string;
                            source_image?: string;
                            type: string;
                            with_image?: boolean;
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { path: { insight_id: string } } },
        `${string}/${string}`,
    >,
>
Parameters
- id: string
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path: { insight_id: string };
                query?: undefined;
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            barcode: number;
                            countries: string[];
                            data?: { bounding_box?: (...)[]; logo_id?: number };
                            id: string;
                            source_image?: string;
                            type: string;
                            with_image?: boolean;
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { path: { insight_id: string } } },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:80

insights

insights(
    query:
        | {
            annotated?: boolean;
            annotation?: number;
            barcode?: number;
            brands?: string;
            campaigns?: string;
            count?: number;
            countries?: string;
            insight_types?: string;
            lc?: string;
            order_by?: "random"
            | "popularity";
            page?: number;
            predictor?: string;
            server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
            value_tag?: string;
        }
        | undefined,
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: {
                    annotated?: boolean;
                    annotation?: number;
                    barcode?: number;
                    brands?: string;
                    campaigns?: string;
                    count?: number;
                    countries?: string;
                    insight_types?: string;
                    lc?: string;
                    order_by?: "random"
                    | "popularity";
                    page?: number;
                    predictor?: string;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                    value_tag?: string;
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count?: number;
                            insights?: {
                                barcode: number;
                                countries: (...)[];
                                data?: (...) | (...);
                                id: string;
                                source_image?: (...) | (...);
                                type: string;
                                with_image?: (...) | (...) | (...);
                            }[];
                            status?: "found"
                            | "no_insights";
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            params: {
                query: | {
                    annotated?: boolean;
                    annotation?: number;
                    barcode?: number;
                    brands?: string;
                    campaigns?: string;
                    count?: number;
                    countries?: string;
                    insight_types?: string;
                    lc?: string;
                    order_by?: "random"
                    | "popularity";
                    page?: number;
                    predictor?: string;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                    value_tag?: string;
                }
                | undefined;
            };
        },
        `${string}/${string}`,
    >,
>
Fetches insights based on the provided query.
Parameters
- query:
      | {
          annotated?: boolean;
          annotation?: number;
          barcode?: number;
          brands?: string;
          campaigns?: string;
          count?: number;
          countries?: string;
          insight_types?: string;
          lc?: string;
          order_by?: "random"
          | "popularity";
          page?: number;
          predictor?: string;
          server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
          value_tag?: string;
      }
      | undefined
  The query object containing parameters for fetching insights.
  - {
        annotated?: boolean;
        annotation?: number;
        barcode?: number;
        brands?: string;
        campaigns?: string;
        count?: number;
        countries?: string;
        insight_types?: string;
        lc?: string;
        order_by?: "random" | "popularity";
        page?: number;
        predictor?: string;
        server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
        value_tag?: string;
    }
    Optionalannotated?: boolean
    Description
    Filter by annotation status of the insight. A true value (1, true) means we only return annotated insights, a false value (0, false) only non-annotated insights. If the parameter is not provided, both annotated and non-annotated insights are returned.
    
    Optionalannotation?: number
    Description
    Filter by annotation value of the insight. If not provided, all insights are returned. This works in conjunction with the annotated parameter.
    
    Optionalbarcode?: number
    Description
    Filter by barcode value
    
    Optionalbrands?: string
    Description
    Comma-separated list, filter by brands
    
    Optionalcampaigns?: string
    Description
    Filter by annotation campaigns (the insight must have all the campaigns) An annotation campaign allows to only retrieve questions or insights based on arbitrary criteria defined during insight import.
    
    Optionalcount?: number
    Description
    The number of items to return
    
    Optionalcountries?: string
    Description
    Comma separated list, filter by country value (2-letter code)
    
    Example
    uk
    
    Optionalinsight_types?: string
    Description
    Comma-separated list, filter by insight types
    
    Optionallc?: string
    Description
    Comma-separated list of language codes to filter insights by language
    
    Optionalorder_by?: "random" | "popularity"
    Description
    How to order by insight results. By default, results are not ordered. Possible values are: - random: insights are ordered randomly - popularity: insights are returned by decreasing popularity, using the number of scans as proxy
    
    Optionalpage?: number
    Description
    Page index to return (starting at 1)
    
    Optionalpredictor?: string
    Description
    Filter by predictor value A predictor refers to the model/method that was used to generate the prediction.
    
    Optionalserver_type?: "off" | "obf" | "opff" | "opf" | "off_pro"
    Description
    The server type (=project) to use, such as 'off' (Open Food Facts), 'obf' (Open Beauty Facts),...
    
    Optionalvalue_tag?: string
    Description
    Filter by value tag, i.e the value that is going to be sent to Product Opener
    
    Example
    en:organic
  - undefined
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: {
                    annotated?: boolean;
                    annotation?: number;
                    barcode?: number;
                    brands?: string;
                    campaigns?: string;
                    count?: number;
                    countries?: string;
                    insight_types?: string;
                    lc?: string;
                    order_by?: "random"
                    | "popularity";
                    page?: number;
                    predictor?: string;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                    value_tag?: string;
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count?: number;
                            insights?: {
                                barcode: number;
                                countries: (...)[];
                                data?: (...) | (...);
                                id: string;
                                source_image?: (...) | (...);
                                type: string;
                                with_image?: (...) | (...) | (...);
                            }[];
                            status?: "found"
                            | "no_insights";
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            params: {
                query: | {
                    annotated?: boolean;
                    annotation?: number;
                    barcode?: number;
                    brands?: string;
                    campaigns?: string;
                    count?: number;
                    countries?: string;
                    insight_types?: string;
                    lc?: string;
                    order_by?: "random"
                    | "popularity";
                    page?: number;
                    predictor?: string;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                    value_tag?: string;
                }
                | undefined;
            };
        },
        `${string}/${string}`,
    >,
>
A promise that resolves to the data from the insights endpoint
- Defined in robotoff.ts:93

loadLogo

loadLogo(logoId: string): Promise<any>
Parameters
- logoId: string
Returns Promise<any>
- Defined in robotoff.ts:99

questions

questions(
    query?: Omit<
        | {
            brands?: string;
            campaigns?: string;
            count?: number;
            countries?: string;
            insight_types?: string;
            lang?: string;
            order_by?: "random"
            | "popularity"
            | "confidence";
            page?: number;
            predictor?: string;
            reserved_barcode?: boolean;
            server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
            value_tag?: string;
        }
        | undefined,
        "count"
        | "page",
    >,
    page?: number,
    count?: number,
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: {
                    brands?: string;
                    campaigns?: string;
                    count?: number;
                    countries?: string;
                    insight_types?: string;
                    lang?: string;
                    order_by?: "random"
                    | "popularity"
                    | "confidence";
                    page?: number;
                    predictor?: string;
                    reserved_barcode?: boolean;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                    value_tag?: string;
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count?: number;
                            questions?: {
                                barcode: string;
                                insight_id: string;
                                insight_type: string;
                                question: string;
                                ref_image_url?: (...)
                                | (...);
                                server_type?: (...) | (...) | (...) | (...) | (...) | (...);
                                source_image_url?: (...) | (...);
                                type?: (...) | (...);
                                value: string;
                                value_tag?: (...) | (...);
                            }[];
                            status?: "no_questions"
                            | "found";
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { query: { count: number; page: number } } },
        `${string}/${string}`,
    >,
>
Parameters
- Optionalquery: Omit<
      | {
          brands?: string;
          campaigns?: string;
          count?: number;
          countries?: string;
          insight_types?: string;
          lang?: string;
          order_by?: "random"
          | "popularity"
          | "confidence";
          page?: number;
          predictor?: string;
          reserved_barcode?: boolean;
          server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
          value_tag?: string;
      }
      | undefined,
      "count"
      | "page",
  >
- page: number = 0
  The page number
  Default
  0
- count: number = 25
  The page size
  Default
  25
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: {
                    brands?: string;
                    campaigns?: string;
                    count?: number;
                    countries?: string;
                    insight_types?: string;
                    lang?: string;
                    order_by?: "random"
                    | "popularity"
                    | "confidence";
                    page?: number;
                    predictor?: string;
                    reserved_barcode?: boolean;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                    value_tag?: string;
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count?: number;
                            questions?: {
                                barcode: string;
                                insight_id: string;
                                insight_type: string;
                                question: string;
                                ref_image_url?: (...)
                                | (...);
                                server_type?: (...) | (...) | (...) | (...) | (...) | (...);
                                source_image_url?: (...) | (...);
                                type?: (...) | (...);
                                value: string;
                                value_tag?: (...) | (...);
                            }[];
                            status?: "no_questions"
                            | "found";
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { query: { count: number; page: number } } },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:140

questionsByProductCode

questionsByProductCode(
    code: number,
    query?: {
        count?: number;
        insight_types?: string;
        lang?: string;
        server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
    },
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path: { barcode: number };
                query?: {
                    count?: number;
                    insight_types?: string;
                    lang?: string;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            questions?: {
                                barcode: string;
                                insight_id: string;
                                insight_type: string;
                                question: string;
                                ref_image_url?: (...)
                                | (...);
                                server_type?: (...) | (...) | (...) | (...) | (...) | (...);
                                source_image_url?: (...) | (...);
                                type?: (...) | (...);
                                value: string;
                                value_tag?: (...) | (...);
                            }[];
                            status?: "no_questions"
                            | "found";
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            params: {
                path: { barcode: number };
                query:
                    | {
                        count?: number;
                        insight_types?: string;
                        lang?: string;
                        server_type?: "off"
                        | "obf"
                        | "opff"
                        | "opf"
                        | "off_pro";
                    }
                    | undefined;
            };
        },
        `${string}/${string}`,
    >,
>
Parameters
- code: number
- Optionalquery: {
      count?: number;
      insight_types?: string;
      lang?: string;
      server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
  }
  - Optionalcount?: number
    Description
    The number of questions to return
  - Optionalinsight_types?: string
    Description
    Comma-separated list, filter by insight types
  - Optionallang?: string
    Description
    The language of the question/value
  - Optionalserver_type?: "off" | "obf" | "opff" | "opf" | "off_pro"
    Description
    The server type (=project) to use, such as 'off' (Open Food Facts), 'obf' (Open Beauty Facts),...
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path: { barcode: number };
                query?: {
                    count?: number;
                    insight_types?: string;
                    lang?: string;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            questions?: {
                                barcode: string;
                                insight_id: string;
                                insight_type: string;
                                question: string;
                                ref_image_url?: (...)
                                | (...);
                                server_type?: (...) | (...) | (...) | (...) | (...) | (...);
                                source_image_url?: (...) | (...);
                                type?: (...) | (...);
                                value: string;
                                value_tag?: (...) | (...);
                            }[];
                            status?: "no_questions"
                            | "found";
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            params: {
                path: { barcode: number };
                query:
                    | {
                        count?: number;
                        insight_types?: string;
                        lang?: string;
                        server_type?: "off"
                        | "obf"
                        | "opff"
                        | "opf"
                        | "off_pro";
                    }
                    | undefined;
            };
        },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:71

resetLogo

resetLogo(
    logoId: number,
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path: { logo_id: number };
                query?: undefined;
            };
            requestBody?: undefined;
            responses: {
                "204": { content?: undefined; headers: { [name: string]: unknown } };
                "404": { content?: undefined; headers: { [name: string]: unknown } };
            };
        },
        { params: { path: { logo_id: number } } },
        `${string}/${string}`,
    >,
>
Parameters
- logoId: number
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path: { logo_id: number };
                query?: undefined;
            };
            requestBody?: undefined;
            responses: {
                "204": { content?: undefined; headers: { [name: string]: unknown } };
                "404": { content?: undefined; headers: { [name: string]: unknown } };
            };
        },
        { params: { path: { logo_id: number } } },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:119

searchLogos

searchLogos(
    params:
        | {
            annotated?: boolean
            | null;
            barcode?: string;
            count?: number;
            min_confidence?: number;
            random?: boolean;
            server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
            taxonomy_value?: string;
            type?: string;
            value?: string;
        }
        | undefined,
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: {
                    annotated?: boolean
                    | null;
                    barcode?: string;
                    count?: number;
                    min_confidence?: number;
                    random?: boolean;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                    taxonomy_value?: string;
                    type?: string;
                    value?: string;
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count: number;
                            logos: {
                                annotation_type?: string;
                                annotation_value?: string;
                                annotation_value_tag?: string;
                                barcode: string;
                                bounding_box?: (...)[];
                                completed_at?: string;
                                id: number;
                                image?: Record<(...), (...)>;
                                nearest_neighbors?: { distances?: ...; logo_ids?: ... };
                                score?: number;
                                server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                                source_image?: string;
                                taxonomy_value?: string;
                                text?: string;
                                username?: string;
                            }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            params: {
                query: | {
                    annotated?: boolean
                    | null;
                    barcode?: string;
                    count?: number;
                    min_confidence?: number;
                    random?: boolean;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                    taxonomy_value?: string;
                    type?: string;
                    value?: string;
                }
                | undefined;
            };
        },
        `${string}/${string}`,
    >,
>
Parameters
- params:
      | {
          annotated?: boolean
          | null;
          barcode?: string;
          count?: number;
          min_confidence?: number;
          random?: boolean;
          server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
          taxonomy_value?: string;
          type?: string;
          value?: string;
      }
      | undefined
  - {
        annotated?: boolean | null;
        barcode?: string;
        count?: number;
        min_confidence?: number;
        random?: boolean;
        server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
        taxonomy_value?: string;
        type?: string;
        value?: string;
    }
    Optionalannotated?: boolean | null
    Description
    The annotation status of the logo. If not provided, both annotated and non-annotated logos are returned
    
    Optionalbarcode?: string
    Description
    Filter by barcode value
    
    Optionalcount?: number
    Description
    Number of results to return
    
    Optionalmin_confidence?: number
    Description
    Filter logos that have a confidence score above a threshold
    
    Optionalrandom?: boolean
    Description
    If true, randomized result order
    
    Optionalserver_type?: "off" | "obf" | "opff" | "opf" | "off_pro"
    Description
    The server type (=project) to use, such as 'off' (Open Food Facts), 'obf' (Open Beauty Facts),...
    
    Optionaltaxonomy_value?: string
    Description
    Filter by taxonomy value, i.e. the canonical value present is the associated taxonomy. This parameter is mutually exclusive with value, and should be used for label type.
    
    Example
    en:organic
    
    Optionaltype?: string
    Description
    Filter by logo type
    
    Example
    packager_code
    
    Optionalvalue?: string
    Description
    Filter by annotated value
    
    Example
    lidl
  - undefined
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path?: undefined;
                query?: {
                    annotated?: boolean
                    | null;
                    barcode?: string;
                    count?: number;
                    min_confidence?: number;
                    random?: boolean;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                    taxonomy_value?: string;
                    type?: string;
                    value?: string;
                };
            };
            requestBody?: undefined;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            count: number;
                            logos: {
                                annotation_type?: string;
                                annotation_value?: string;
                                annotation_value_tag?: string;
                                barcode: string;
                                bounding_box?: (...)[];
                                completed_at?: string;
                                id: number;
                                image?: Record<(...), (...)>;
                                nearest_neighbors?: { distances?: ...; logo_ids?: ... };
                                score?: number;
                                server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                                source_image?: string;
                                taxonomy_value?: string;
                                text?: string;
                                username?: string;
                            }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            params: {
                query: | {
                    annotated?: boolean
                    | null;
                    barcode?: string;
                    count?: number;
                    min_confidence?: number;
                    random?: boolean;
                    server_type?: "off" | "obf" | "opff" | "opf" | "off_pro";
                    taxonomy_value?: string;
                    type?: string;
                    value?: string;
                }
                | undefined;
            };
        },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:107

updateLogo

updateLogo(
    logoId: number,
    body: { type: string; value?: string | null },
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path: { logo_id: number };
                query?: undefined;
            };
            requestBody: {
                content: {
                    "application/json": { type: string; value?: string
                    | null };
                };
            };
            responses: {
                "204": { content?: undefined; headers: { [name: string]: unknown } };
                "403": { content?: undefined; headers: { [name: string]: unknown } };
                "404": { content?: undefined; headers: { [name: string]: unknown } };
            };
        },
        {
            body: { type: string; value?: string
            | null };
            params: { path: { logo_id: number } };
        },
        `${string}/${string}`,
    >,
>
Parameters
- logoId: number
- body: { type: string; value?: string | null }
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: undefined;
                header?: undefined;
                path: { logo_id: number };
                query?: undefined;
            };
            requestBody: {
                content: {
                    "application/json": { type: string; value?: string
                    | null };
                };
            };
            responses: {
                "204": { content?: undefined; headers: { [name: string]: unknown } };
                "403": { content?: undefined; headers: { [name: string]: unknown } };
                "404": { content?: undefined; headers: { [name: string]: unknown } };
            };
        },
        {
            body: { type: string; value?: string
            | null };
            params: { path: { logo_id: number } };
        },
        `${string}/${string}`,
    >,
>
- Defined in robotoff.ts:180

Class Robotoff

Index

Constructors

Methods

Constructors

constructor

Parameters

Returns Robotoff

Methods

annotate

Parameters

annotation: -1 | 0 | 1 | 2

Description

Optionaldata?: Record<string, unknown> | null

Description

Optionaldevice_id?: string

Description

insight_id: string

Description

Example

Optionalupdate?: 0 | 1

Description

Default

annotateLogos

Parameters

logo_id: number

Description

type: | "label" | "brand" | "category" | "no_logo" | "nutritional_label" | "packager_code" | "packaging" | "qr_code" | "store"

Description

value: string | null

Description

fetchLogos

Parameters

getCroppedImageUrl

Parameters

Returns string

getLogoAnnotations

Parameters

getQuestionsUnanswered

Parameters

Default

Default

getUserStatistics

Parameters

insightDetail

Parameters

insights

Parameters

Optionalannotated?: boolean

Description

Optionalannotation?: number

Description

Optionalbarcode?: number

Description

Optionalbrands?: string

Description

Optionalcampaigns?: string

Description

Optionalcount?: number

Description

Optionalcountries?: string

Description

Example

Optionalinsight_types?: string

Description

Optionallc?: string

Description

Optionalorder_by?: "random" | "popularity"

Description

Optionalpage?: number

Description

Optionalpredictor?: string

Description

Optionalserver_type?: "off" | "obf" | "opff" | "opf" | "off_pro"

Description

Optionalvalue_tag?: string

Description

Example

loadLogo

Parameters

`Optional`data?: Record<string, unknown> | null

`Optional`device_id?: string

`Optional`update?: 0 | 1

type:
| "label"
| "brand"
| "category"
| "no_logo"
| "nutritional_label"
| "packager_code"
| "packaging"
| "qr_code"
| "store"

`Optional`annotated?: boolean

`Optional`annotation?: number

`Optional`barcode?: number

`Optional`brands?: string

`Optional`campaigns?: string

`Optional`count?: number

`Optional`countries?: string

`Optional`insight_types?: string

`Optional`lc?: string

`Optional`order_by?: "random" | "popularity"

`Optional`page?: number

`Optional`predictor?: string

`Optional`server_type?: "off" | "obf" | "opff" | "opf" | "off_pro"

`Optional`value_tag?: string

`Optional`count?: number

`Optional`insight_types?: string

`Optional`lang?: string

`Optional`server_type?: "off" | "obf" | "opff" | "opf" | "off_pro"

`Optional`annotated?: boolean | null

`Optional`barcode?: string

`Optional`count?: number

`Optional`min_confidence?: number

`Optional`random?: boolean

`Optional`server_type?: "off" | "obf" | "opff" | "opf" | "off_pro"

`Optional`taxonomy_value?: string

`Optional`type?: string

`Optional`value?: string