Class NutriPatrol

Index

Constructors

constructor

new NutriPatrol(
    fetch: {
        (input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
        (input: string | Request | URL, init?: RequestInit): Promise<Response>;
    },
    options?: { baseUrl: string },
): NutriPatrol
Parameters
- fetch: {
  (input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
  (input: string | Request | URL, init?: RequestInit): Promise<Response>;
  }
  - (input: RequestInfo | URL, init?: RequestInit): Promise<Response>
    MDN Reference
    
    Parameters
    input: RequestInfo | URL
    Optionalinit: RequestInit
    Returns Promise<Response>
    (input: string | Request | URL, init?: RequestInit): Promise<Response>
    MDN Reference
    
    Parameters
    input: string | Request | URL
    Optionalinit: RequestInit
    Returns Promise<Response>
- options: { baseUrl: string } = ...
Returns NutriPatrol
- Defined in src/nutripatrol.ts:12

Properties

`Readonly`client

client: Client<paths>

Methods

createFlag

createFlag(
    flag: {
        barcode?: string;
        comment?: string;
        confidence?: number;
        created_at?: string;
        flavor: "off" | "obf" | "opff" | "opf" | "off-pro";
        image_id?: string;
        reason?: string;
        source: "mobile" | "web" | "robotoff";
        type: "search" | "product" | "image";
        url: string;
        user_id: string;
    },
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path?: never;
                query?: never;
            };
            requestBody: {
                content: {
                    "application/json": {
                        barcode?: string;
                        comment?: string;
                        confidence?: number;
                        created_at?: string;
                        flavor: "off"
                        | "obf"
                        | "opff"
                        | "opf"
                        | "off-pro";
                        image_id?: string;
                        reason?: string;
                        source: "mobile" | "web" | "robotoff";
                        type: "search" | "product" | "image";
                        url: string;
                        user_id: string;
                    };
                };
            };
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            barcode?: string;
                            comment?: string;
                            confidence?: number;
                            created_at?: string;
                            device_id: string;
                            flavor: "off"
                            | "obf"
                            | "opff"
                            | "opf"
                            | "off-pro";
                            id: number;
                            image_id?: string;
                            reason?: string;
                            source: "mobile" | "web" | "robotoff";
                            ticket_id: number;
                            type: "search" | "product" | "image";
                            url: string;
                            user_id: string;
                        };
                    };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            body: {
                barcode?: string;
                comment?: string;
                confidence?: number;
                created_at?: string;
                flavor: "off"
                | "obf"
                | "opff"
                | "opf"
                | "off-pro";
                image_id?: string;
                reason?: string;
                source: "mobile" | "web" | "robotoff";
                type: "search" | "product" | "image";
                url: string;
                user_id: string;
            };
        },
        `${string}/${string}`,
    >,
>
Create a flag in the NutriPatrol API.
Parameters
- flag: {
      barcode?: string;
      comment?: string;
      confidence?: number;
      created_at?: string;
      flavor: "off" | "obf" | "opff" | "opf" | "off-pro";
      image_id?: string;
      reason?: string;
      source: "mobile" | "web" | "robotoff";
      type: "search" | "product" | "image";
      url: string;
      user_id: string;
  }
  Data for the flag to create.
  - Optionalbarcode?: string
    Barcode
    
    Description
    Barcode of the product, if the flag is about a product or a product image. In case of a search issue, this field is null.
  - Optionalcomment?: string
    Comment
    
    Description
    Comment provided by the user during flagging. This is a free text field.
  - Optionalconfidence?: number
    Confidence
    
    Description
    Confidence score of the model that generated the flag, this field should only be provided by Robotoff.
  - Optionalcreated_at?: string
    Created At Format: date-time
    
    Description
    Creation datetime of the flag
  - flavor: "off" | "obf" | "opff" | "opf" | "off-pro"
    Description
    Flavor (project) associated with the ticket
  - Optionalimage_id?: string
    Image Id
    
    Description
    ID of the flagged image
  - Optionalreason?: string
    Reason
    
    Description
    Reason for flagging provided by the user. The field is optional.
  - source: "mobile" | "web" | "robotoff"
    Description
    Source of the flag. It can be a user from the mobile app, the web or a flag generated automatically by robotoff.
  - type: "search" | "product" | "image"
    Description
    Type of the issue
  - url: string
    Url
    
    Description
    URL of the product or of the flagged image
  - user_id: string
    User Id
    
    Description
    Open Food Facts User ID of the flagger
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path?: never;
                query?: never;
            };
            requestBody: {
                content: {
                    "application/json": {
                        barcode?: string;
                        comment?: string;
                        confidence?: number;
                        created_at?: string;
                        flavor: "off"
                        | "obf"
                        | "opff"
                        | "opf"
                        | "off-pro";
                        image_id?: string;
                        reason?: string;
                        source: "mobile" | "web" | "robotoff";
                        type: "search" | "product" | "image";
                        url: string;
                        user_id: string;
                    };
                };
            };
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            barcode?: string;
                            comment?: string;
                            confidence?: number;
                            created_at?: string;
                            device_id: string;
                            flavor: "off"
                            | "obf"
                            | "opff"
                            | "opf"
                            | "off-pro";
                            id: number;
                            image_id?: string;
                            reason?: string;
                            source: "mobile" | "web" | "robotoff";
                            ticket_id: number;
                            type: "search" | "product" | "image";
                            url: string;
                            user_id: string;
                        };
                    };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            body: {
                barcode?: string;
                comment?: string;
                confidence?: number;
                created_at?: string;
                flavor: "off"
                | "obf"
                | "opff"
                | "opf"
                | "off-pro";
                image_id?: string;
                reason?: string;
                source: "mobile" | "web" | "robotoff";
                type: "search" | "product" | "image";
                url: string;
                user_id: string;
            };
        },
        `${string}/${string}`,
    >,
>
- Defined in src/nutripatrol.ts:62

getApiStatus

getApiStatus(): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path?: never;
                query?: never;
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: { "application/json": { status: string } };
                    headers: { [name: string]: unknown };
                };
            };
        },
        FetchOptions<
            {
                parameters: {
                    cookie?: never;
                    header?: never;
                    path?: never;
                    query?: never;
                };
                requestBody?: never;
                responses: {
                    "200": {
                        content: { "application/json": { status: string } };
                        headers: { [name: string]: unknown };
                    };
                };
            },
        >,
        `${string}/${string}`,
    >,
>
Get the status of the NutriPatrol API.

If the returned status.data is undefined, it indicates that the API is down or unreachable.

Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path?: never;
                query?: never;
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: { "application/json": { status: string } };
                    headers: { [name: string]: unknown };
                };
            };
        },
        FetchOptions<
            {
                parameters: {
                    cookie?: never;
                    header?: never;
                    path?: never;
                    query?: never;
                };
                requestBody?: never;
                responses: {
                    "200": {
                        content: { "application/json": { status: string } };
                        headers: { [name: string]: unknown };
                    };
                };
            },
        >,
        `${string}/${string}`,
    >,
>
Example
```
const { data } = await nutripatrol.getApiStatus();
if (!data) throw new Error("API is down or unreachable");
```
- Defined in src/nutripatrol.ts:146

getFlagById

getFlagById(
    flagId: number,
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path: { flag_id: number };
                query?: never;
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            barcode?: string;
                            comment?: string;
                            confidence?: number;
                            created_at?: string;
                            device_id: string;
                            flavor: "off"
                            | "obf"
                            | "opff"
                            | "opf"
                            | "off-pro";
                            id: number;
                            image_id?: string;
                            reason?: string;
                            source: "mobile" | "web" | "robotoff";
                            ticket_id: number;
                            type: "search" | "product" | "image";
                            url: string;
                            user_id: string;
                        };
                    };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { path: { flag_id: number } } },
        `${string}/${string}`,
    >,
>
Retrieves a specific flag by its ID from the NutriPatrol API.
Parameters
- flagId: number
  The ID of the flag to fetch.
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path: { flag_id: number };
                query?: never;
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            barcode?: string;
                            comment?: string;
                            confidence?: number;
                            created_at?: string;
                            device_id: string;
                            flavor: "off"
                            | "obf"
                            | "opff"
                            | "opf"
                            | "off-pro";
                            id: number;
                            image_id?: string;
                            reason?: string;
                            source: "mobile" | "web" | "robotoff";
                            ticket_id: number;
                            type: "search" | "product" | "image";
                            url: string;
                            user_id: string;
                        };
                    };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { path: { flag_id: number } } },
        `${string}/${string}`,
    >,
>
A promise that resolves with the flag data if found or error.
Example
```
const { data, error } = await nutripatrol.getFlagById(123);
```
- Defined in src/nutripatrol.ts:51

getFlags

getFlags(): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path?: never;
                query?: never;
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            flags: {
                                barcode?: string;
                                comment?: string;
                                confidence?: number;
                                created_at?: string;
                                device_id: string;
                                flavor: "off"
                                | "obf"
                                | "opff"
                                | "opf"
                                | "off-pro";
                                id: number;
                                image_id?: string;
                                reason?: string;
                                source: "mobile" | "web" | "robotoff";
                                ticket_id: number;
                                type: "search" | "product" | "image";
                                url: string;
                                user_id: string;
                            }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        FetchOptions<
            {
                parameters: {
                    cookie?: never;
                    header?: never;
                    path?: never;
                    query?: never;
                };
                requestBody?: never;
                responses: {
                    "200": {
                        content: {
                            "application/json": {
                                flags: {
                                    barcode?: string;
                                    comment?: string;
                                    confidence?: number;
                                    created_at?: string;
                                    device_id: string;
                                    flavor: (...)
                                    | (...)
                                    | (...)
                                    | (...)
                                    | (...);
                                    id: number;
                                    image_id?: string;
                                    reason?: string;
                                    source: (...) | (...) | (...);
                                    ticket_id: number;
                                    type: (...) | (...) | (...);
                                    url: string;
                                    user_id: string;
                                }[];
                            };
                        };
                        headers: { [name: string]: unknown };
                    };
                };
            },
        >,
        `${string}/${string}`,
    >,
>
List all flags.

Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path?: never;
                query?: never;
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            flags: {
                                barcode?: string;
                                comment?: string;
                                confidence?: number;
                                created_at?: string;
                                device_id: string;
                                flavor: "off"
                                | "obf"
                                | "opff"
                                | "opf"
                                | "off-pro";
                                id: number;
                                image_id?: string;
                                reason?: string;
                                source: "mobile" | "web" | "robotoff";
                                ticket_id: number;
                                type: "search" | "product" | "image";
                                url: string;
                                user_id: string;
                            }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        FetchOptions<
            {
                parameters: {
                    cookie?: never;
                    header?: never;
                    path?: never;
                    query?: never;
                };
                requestBody?: never;
                responses: {
                    "200": {
                        content: {
                            "application/json": {
                                flags: {
                                    barcode?: string;
                                    comment?: string;
                                    confidence?: number;
                                    created_at?: string;
                                    device_id: string;
                                    flavor: (...)
                                    | (...)
                                    | (...)
                                    | (...)
                                    | (...);
                                    id: number;
                                    image_id?: string;
                                    reason?: string;
                                    source: (...) | (...) | (...);
                                    ticket_id: number;
                                    type: (...) | (...) | (...);
                                    url: string;
                                    user_id: string;
                                }[];
                            };
                        };
                        headers: { [name: string]: unknown };
                    };
                };
            },
        >,
        `${string}/${string}`,
    >,
>
- A promise that resolves with the list of flag data or error.
Example
```
const { data, error } = await nutripatrol.getFlags();
if (error) console.error("Error fetching flags:", error);
else console.log("Flags:", data);
```
- Defined in src/nutripatrol.ts:39

getFlagsByTicketBatch

getFlagsByTicketBatch(
    ticketIds: number[],
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path?: never;
                query?: never;
            };
            requestBody: {
                content: { "application/json": { ticket_ids: number[] } };
            };
            responses: {
                "200": {
                    content: { "application/json": unknown };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { body: { ticket_ids: number[] } },
        `${string}/${string}`,
    >,
>
Get flags by ticket batch.
Parameters
- ticketIds: number[]
  Ids of ticket to get flags from.
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path?: never;
                query?: never;
            };
            requestBody: {
                content: { "application/json": { ticket_ids: number[] } };
            };
            responses: {
                "200": {
                    content: { "application/json": unknown };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { body: { ticket_ids: number[] } },
        `${string}/${string}`,
    >,
>
A promise that resolves with the flags data or error.
Example
```
const { data, error } = await nutripatrol.getFlagsByTicketBatch([123, 456]);
```
- Defined in src/nutripatrol.ts:74

getTicketById

getTicketById(
    ticketId: number,
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path: { ticket_id: number };
                query?: never;
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: { "application/json": unknown };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { path: { ticket_id: number } } },
        `${string}/${string}`,
    >,
>
Retrieves a specific ticket by its ID from the NutriPatrol API.
Parameters
- ticketId: number
  The ID of the ticket to fetch.
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path: { ticket_id: number };
                query?: never;
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: { "application/json": unknown };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        { params: { path: { ticket_id: number } } },
        `${string}/${string}`,
    >,
>
Example
```
const { data, error } = await nutripatrol.getTicketById(123);
if (!data) console.error("Error fetching ticket:", error);
```
- Defined in src/nutripatrol.ts:112

getTickets

getTickets(
    query: {
        page?: number;
        page_size?: number;
        reason?: ("other" | "inappropriate" | "human" | "beauty")[];
        status: "closed" | "open";
        type?: string;
    },
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path?: never;
                query?: {
                    page?: number;
                    page_size?: number;
                    reason?: ("other" | "inappropriate" | "human" | "beauty")[];
                    status?: "closed" | "open";
                    type_?: "search" | "product" | "image";
                };
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            max_page: number;
                            tickets: {
                                barcode?: string;
                                created_at?: string;
                                flavor: "off"
                                | "obf"
                                | "opff"
                                | "opf"
                                | "off-pro";
                                id: number;
                                image_id?: string;
                                status: "closed" | "open";
                                type: "search" | "product" | "image";
                                url: string;
                            }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            params: {
                query: {
                    page?: number;
                    page_size?: number;
                    reason?: ("other" | "inappropriate" | "human" | "beauty")[];
                    status: "closed" | "open";
                    type?: string;
                };
            };
        },
        `${string}/${string}`,
    >,
>
List all tickets.
Parameters
- query: {
      page?: number;
      page_size?: number;
      reason?: ("other" | "inappropriate" | "human" | "beauty")[];
      status: "closed" | "open";
      type?: string;
  }
  Parameters to filter the tickets.
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path?: never;
                query?: {
                    page?: number;
                    page_size?: number;
                    reason?: ("other" | "inappropriate" | "human" | "beauty")[];
                    status?: "closed" | "open";
                    type_?: "search" | "product" | "image";
                };
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            max_page: number;
                            tickets: {
                                barcode?: string;
                                created_at?: string;
                                flavor: "off"
                                | "obf"
                                | "opff"
                                | "opf"
                                | "off-pro";
                                id: number;
                                image_id?: string;
                                status: "closed" | "open";
                                type: "search" | "product" | "image";
                                url: string;
                            }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            params: {
                query: {
                    page?: number;
                    page_size?: number;
                    reason?: ("other" | "inappropriate" | "human" | "beauty")[];
                    status: "closed" | "open";
                    type?: string;
                };
            };
        },
        `${string}/${string}`,
    >,
>
A promise that resolves with the list of tickets or error.
Example
```
const { data, error } = await nutripatrol.getTickets({
  status: "open",
  type: "spam",
  reason: ["inappropriate", "human"],
  page: 1,
  page_size: 20,
});
```
- Defined in src/nutripatrol.ts:94

updateTicketStatus

updateTicketStatus(
    ticketId: number,
    status: "closed" | "open",
): Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path: { ticket_id: number };
                query: { status: "closed" | "open" };
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            barcode?: string;
                            created_at?: string;
                            flavor: "off"
                            | "obf"
                            | "opff"
                            | "opf"
                            | "off-pro";
                            id: number;
                            image_id?: string;
                            status: "closed" | "open";
                            type: "search" | "product" | "image";
                            url: string;
                        };
                    };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            params: {
                path: { ticket_id: number };
                query: { status: "closed" | "open" };
            };
        },
        `${string}/${string}`,
    >,
>
Update a ticket status in the NutriPatrol API.
Parameters
- ticketId: number
  The ID of the ticket to update.
- status: "closed" | "open"
  The new status of the ticket.
Returns Promise<
    FetchResponse<
        {
            parameters: {
                cookie?: never;
                header?: never;
                path: { ticket_id: number };
                query: { status: "closed" | "open" };
            };
            requestBody?: never;
            responses: {
                "200": {
                    content: {
                        "application/json": {
                            barcode?: string;
                            created_at?: string;
                            flavor: "off"
                            | "obf"
                            | "opff"
                            | "opf"
                            | "off-pro";
                            id: number;
                            image_id?: string;
                            status: "closed" | "open";
                            type: "search" | "product" | "image";
                            url: string;
                        };
                    };
                    headers: { [name: string]: unknown };
                };
                "422": {
                    content: {
                        "application/json": {
                            detail?: { loc: ((...) | (...))[]; msg: string; type: string }[];
                        };
                    };
                    headers: { [name: string]: unknown };
                };
            };
        },
        {
            params: {
                path: { ticket_id: number };
                query: { status: "closed" | "open" };
            };
        },
        `${string}/${string}`,
    >,
>
Example
```
const { data, error } = await nutripatrol.updateTicketStatus(123, "closed");
if (!data) console.error("Error updating ticket status:", error);
```
- Defined in src/nutripatrol.ts:127

Class NutriPatrol

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Parameters

Returns Promise<Response>

Parameters

Returns Promise<Response>

Returns NutriPatrol

Properties

Readonlyclient

Methods

createFlag

Parameters

Optionalbarcode?: string

Description

Optionalcomment?: string

Description

Optionalconfidence?: number

Description

Optionalcreated_at?: string

Description

flavor: "off" | "obf" | "opff" | "opf" | "off-pro"

Description

Optionalimage_id?: string

Description

Optionalreason?: string

Description

source: "mobile" | "web" | "robotoff"

Description

type: "search" | "product" | "image"

Description

url: string

Description

user_id: string

Description

getApiStatus

Example

getFlagById

Parameters

Example

getFlags

Example

getFlagsByTicketBatch

Parameters

Example

getTicketById

Parameters

Example

getTickets

Parameters

Example

updateTicketStatus

Parameters

Example

Settings

On This Page

`Readonly`client

`Optional`barcode?: string

`Optional`comment?: string

`Optional`confidence?: number

`Optional`created_at?: string

`Optional`image_id?: string

`Optional`reason?: string