react-native-executorch 0.5.1-rc.0 → 0.5.2

package/lib/modules/computer_vision/VerticalOCRModule.js

@@ -0,0 +1,22 @@
+import { VerticalOCRController } from '../../controllers/VerticalOCRController';
+export class VerticalOCRModule {
+    controller;
+    constructor() {
+        this.controller = new VerticalOCRController();
+    }
+    async load(model, independentCharacters, onDownloadProgressCallback = () => { }) {
+        await this.controller.load({
+            detectorLarge: model.detectorLarge,
+            detectorNarrow: model.detectorNarrow,
+        }, {
+            recognizerLarge: model.recognizerLarge,
+            recognizerSmall: model.recognizerSmall,
+        }, model.language, independentCharacters, onDownloadProgressCallback);
+    }
+    async forward(input) {
+        return await this.controller.forward(input);
+    }
+    delete() {
+        this.controller.delete();
+    }
+}

package/lib/modules/general/ExecutorchModule.d.ts

@@ -0,0 +1,7 @@
+import { TensorPtr } from '../../types/common';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+import { ResourceSource } from '../../types/common';
+export declare class ExecutorchModule extends BaseNonStaticModule {
+    load(modelSource: ResourceSource, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    forward(inputTensor: TensorPtr[]): Promise<TensorPtr[]>;
+}

package/lib/modules/general/ExecutorchModule.js

@@ -0,0 +1,14 @@
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+import { ResourceFetcher } from '../../utils/ResourceFetcher';
+export class ExecutorchModule extends BaseNonStaticModule {
+    async load(modelSource, onDownloadProgressCallback = () => { }) {
+        const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, modelSource);
+        if (paths === null || paths.length < 1) {
+            throw new Error('Download interrupted.');
+        }
+        this.nativeModule = global.loadExecutorchModule(paths[0] || '');
+    }
+    async forward(inputTensor) {
+        return await this.forwardET(inputTensor);
+    }
+}

package/lib/modules/natural_language_processing/LLMModule.d.ts

@@ -0,0 +1,28 @@
+import { ResourceSource } from '../../types/common';
+import { ChatConfig, LLMTool, Message, ToolsConfig } from '../../types/llm';
+export declare class LLMModule {
+    private controller;
+    constructor({ tokenCallback, responseCallback, messageHistoryCallback, }?: {
+        tokenCallback?: (token: string) => void;
+        responseCallback?: (response: string) => void;
+        messageHistoryCallback?: (messageHistory: Message[]) => void;
+    });
+    load(model: {
+        modelSource: ResourceSource;
+        tokenizerSource: ResourceSource;
+        tokenizerConfigSource: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    setTokenCallback({ tokenCallback, }: {
+        tokenCallback: (token: string) => void;
+    }): void;
+    configure({ chatConfig, toolsConfig, }: {
+        chatConfig?: Partial<ChatConfig>;
+        toolsConfig?: ToolsConfig;
+    }): void;
+    forward(input: string): Promise<string>;
+    generate(messages: Message[], tools?: LLMTool[]): Promise<string>;
+    sendMessage(message: string): Promise<Message[]>;
+    deleteMessage(index: number): Message[];
+    interrupt(): void;
+    delete(): void;
+}

package/lib/modules/natural_language_processing/LLMModule.js

@@ -0,0 +1,45 @@
+import { LLMController } from '../../controllers/LLMController';
+export class LLMModule {
+    controller;
+    constructor({ tokenCallback, responseCallback, messageHistoryCallback, } = {}) {
+        this.controller = new LLMController({
+            tokenCallback,
+            responseCallback,
+            messageHistoryCallback,
+        });
+    }
+    async load(model, onDownloadProgressCallback = () => { }) {
+        await this.controller.load({
+            ...model,
+            onDownloadProgressCallback,
+        });
+    }
+    setTokenCallback({ tokenCallback, }) {
+        this.controller.setTokenCallback(tokenCallback);
+    }
+    configure({ chatConfig, toolsConfig, }) {
+        this.controller.configure({ chatConfig, toolsConfig });
+    }
+    async forward(input) {
+        await this.controller.forward(input);
+        return this.controller.response;
+    }
+    async generate(messages, tools) {
+        await this.controller.generate(messages, tools);
+        return this.controller.response;
+    }
+    async sendMessage(message) {
+        await this.controller.sendMessage(message);
+        return this.controller.messageHistory;
+    }
+    deleteMessage(index) {
+        this.controller.deleteMessage(index);
+        return this.controller.messageHistory;
+    }
+    interrupt() {
+        this.controller.interrupt();
+    }
+    delete() {
+        this.controller.delete();
+    }
+}

package/lib/modules/natural_language_processing/SpeechToTextModule.d.ts

@@ -3,12 +3,22 @@ import { SpeechToTextController } from '../../controllers/SpeechToTextController
 import { AvailableModels, SpeechToTextLanguage } from '../../types/stt';
 import { STREAMING_ACTION } from '../../constants/sttDefaults';
 export declare class SpeechToTextModule {
-    static module: SpeechToTextController;
-    static onDownloadProgressCallback: (_downloadProgress: number) => void;
-    static load(modelName: AvailableModels, transcribeCallback: (sequence: string) => void, modelDownloadProgressCallback?: (downloadProgress: number) => void, encoderSource?: ResourceSource, decoderSource?: ResourceSource, tokenizerSource?: ResourceSource, overlapSeconds?: ConstructorParameters<typeof SpeechToTextController>['0']['overlapSeconds'], windowSize?: ConstructorParameters<typeof SpeechToTextController>['0']['windowSize'], streamingConfig?: ConstructorParameters<typeof SpeechToTextController>['0']['streamingConfig']): Promise<void>;
-    static configureStreaming(overlapSeconds: Parameters<SpeechToTextController['configureStreaming']>[0], windowSize: Parameters<SpeechToTextController['configureStreaming']>[1], streamingConfig: Parameters<SpeechToTextController['configureStreaming']>[2]): void;
-    static encode(waveform: Float32Array): Promise<null>;
-    static decode(seq: number[]): Promise<number>;
-    static transcribe(waveform: number[], audioLanguage?: SpeechToTextLanguage): ReturnType<SpeechToTextController['transcribe']>;
-    static streamingTranscribe(streamAction: STREAMING_ACTION, waveform?: number[], audioLanguage?: SpeechToTextLanguage): ReturnType<SpeechToTextController['streamingTranscribe']>;
+    private module;
+    constructor({ transcribeCallback, overlapSeconds, windowSize, streamingConfig, }?: {
+        transcribeCallback?: (sequence: string) => void;
+        overlapSeconds?: ConstructorParameters<typeof SpeechToTextController>['0']['overlapSeconds'];
+        windowSize?: ConstructorParameters<typeof SpeechToTextController>['0']['windowSize'];
+        streamingConfig?: ConstructorParameters<typeof SpeechToTextController>['0']['streamingConfig'];
+    });
+    load(model: {
+        modelName: AvailableModels;
+        encoderSource?: ResourceSource;
+        decoderSource?: ResourceSource;
+        tokenizerSource?: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    configureStreaming(overlapSeconds: Parameters<SpeechToTextController['configureStreaming']>[0], windowSize: Parameters<SpeechToTextController['configureStreaming']>[1], streamingConfig: Parameters<SpeechToTextController['configureStreaming']>[2]): void;
+    encode(waveform: Float32Array): Promise<null>;
+    decode(seq: number[]): Promise<number>;
+    transcribe(waveform: number[], audioLanguage?: SpeechToTextLanguage): ReturnType<SpeechToTextController['transcribe']>;
+    streamingTranscribe(streamAction: STREAMING_ACTION, waveform?: number[], audioLanguage?: SpeechToTextLanguage): ReturnType<SpeechToTextController['streamingTranscribe']>;
 }

package/lib/modules/natural_language_processing/SpeechToTextModule.js

@@ -1,30 +1,36 @@
 import { SpeechToTextController } from '../../controllers/SpeechToTextController';
 export class SpeechToTextModule {
-    static module;
-    static onDownloadProgressCallback = (_downloadProgress) => { };
-    static async load(modelName, transcribeCallback, modelDownloadProgressCallback, encoderSource, decoderSource, tokenizerSource, overlapSeconds, windowSize, streamingConfig) {
+    module;
+    constructor({ transcribeCallback, overlapSeconds, windowSize, streamingConfig, } = {}) {
         this.module = new SpeechToTextController({
-            transcribeCallback: transcribeCallback,
-            modelDownloadProgressCallback: modelDownloadProgressCallback,
-            overlapSeconds: overlapSeconds,
-            windowSize: windowSize,
-            streamingConfig: streamingConfig,
+            transcribeCallback: transcribeCallback || (() => { }),
+            overlapSeconds,
+            windowSize,
+            streamingConfig,
         });
-        await this.module.loadModel((modelName = modelName), (encoderSource = encoderSource), (decoderSource = decoderSource), (tokenizerSource = tokenizerSource));
     }
-    static configureStreaming(overlapSeconds, windowSize, streamingConfig) {
-        this.module?.configureStreaming(overlapSeconds, windowSize, streamingConfig);
+    async load(model, onDownloadProgressCallback = () => { }) {
+        await this.module.load({
+            modelName: model.modelName,
+            encoderSource: model.encoderSource,
+            decoderSource: model.decoderSource,
+            tokenizerSource: model.tokenizerSource,
+            onDownloadProgressCallback,
+        });
+    }
+    configureStreaming(overlapSeconds, windowSize, streamingConfig) {
+        this.module.configureStreaming(overlapSeconds, windowSize, streamingConfig);
     }
-    static async encode(waveform) {
+    async encode(waveform) {
         return await this.module.encode(waveform);
     }
-    static async decode(seq) {
+    async decode(seq) {
         return await this.module.decode(seq);
     }
-    static async transcribe(waveform, audioLanguage) {
+    async transcribe(waveform, audioLanguage) {
         return await this.module.transcribe(waveform, audioLanguage);
     }
-    static async streamingTranscribe(streamAction, waveform, audioLanguage) {
+    async streamingTranscribe(streamAction, waveform, audioLanguage) {
         return await this.module.streamingTranscribe(streamAction, waveform, audioLanguage);
     }
 }

package/lib/modules/natural_language_processing/TextEmbeddingsModule.d.ts

@@ -0,0 +1,9 @@
+import { ResourceSource } from '../../types/common';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export declare class TextEmbeddingsModule extends BaseNonStaticModule {
+    load(model: {
+        modelSource: ResourceSource;
+        tokenizerSource: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    forward(input: string): Promise<Float32Array>;
+}

package/lib/modules/natural_language_processing/TextEmbeddingsModule.js

@@ -0,0 +1,21 @@
+import { ResourceFetcher } from '../../utils/ResourceFetcher';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export class TextEmbeddingsModule extends BaseNonStaticModule {
+    async load(model, onDownloadProgressCallback = () => { }) {
+        const modelPromise = ResourceFetcher.fetch(onDownloadProgressCallback, model.modelSource);
+        const tokenizerPromise = ResourceFetcher.fetch(undefined, model.tokenizerSource);
+        const [modelResult, tokenizerResult] = await Promise.all([
+            modelPromise,
+            tokenizerPromise,
+        ]);
+        const modelPath = modelResult?.[0];
+        const tokenizerPath = tokenizerResult?.[0];
+        if (!modelPath || !tokenizerPath) {
+            throw new Error('Download interrupted.');
+        }
+        this.nativeModule = global.loadTextEmbeddings(modelPath, tokenizerPath);
+    }
+    async forward(input) {
+        return new Float32Array(await this.nativeModule.generate(input));
+    }
+}

package/lib/modules/natural_language_processing/TokenizerModule.d.ts

@@ -0,0 +1,12 @@
+import { ResourceSource } from '../../types/common';
+export declare class TokenizerModule {
+    nativeModule: any;
+    load(tokenizer: {
+        tokenizerSource: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    encode(s: string): Promise<any>;
+    decode(tokens: number[], skipSpecialTokens?: boolean): Promise<any>;
+    getVocabSize(): Promise<number>;
+    idToToken(tokenId: number): Promise<string>;
+    tokenToId(token: string): Promise<number>;
+}

package/lib/modules/natural_language_processing/TokenizerModule.js

@@ -1,12 +1,13 @@
 import { ResourceFetcher } from '../../utils/ResourceFetcher';
 export class TokenizerModule {
     nativeModule;
-    async load(modelSource, onDownloadProgressCallback = () => { }) {
-        const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, modelSource);
-        if (paths === null || paths.length < 1) {
+    async load(tokenizer, onDownloadProgressCallback = () => { }) {
+        const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, tokenizer.tokenizerSource);
+        const path = paths?.[0];
+        if (!path) {
             throw new Error('Download interrupted.');
         }
-        this.nativeModule = global.loadTokenizerModule(paths[0] || '');
+        this.nativeModule = global.loadTokenizerModule(path);
     }
     async encode(s) {
         return await this.nativeModule.encode(s);

package/lib/native/NativeETInstaller.d.ts

@@ -0,0 +1,6 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    install(): boolean;
+}
+declare const _default: Spec | null;
+export default _default;

package/lib/native/NativeETInstaller.js

@@ -0,0 +1,2 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('ETInstaller');

package/lib/native/NativeOCR.d.ts

@@ -0,0 +1,8 @@
+import type { TurboModule } from 'react-native';
+import { OCRDetection } from '../types/ocr';
+export interface Spec extends TurboModule {
+    loadModule(detectorSource: string, recognizerSourceLarge: string, recognizerSourceMedium: string, recognizerSourceSmall: string, symbols: string): Promise<number>;
+    forward(input: string): Promise<OCRDetection[]>;
+}
+declare const _default: Spec | null;
+export default _default;

package/lib/native/NativeOCR.js

@@ -0,0 +1,2 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('OCR');

package/lib/native/NativeVerticalOCR.d.ts

@@ -0,0 +1,8 @@
+import type { TurboModule } from 'react-native';
+import { OCRDetection } from '../types/ocr';
+export interface Spec extends TurboModule {
+    loadModule(detectorLargeSource: string, detectorNarrowSource: string, recognizerSource: string, symbols: string, independentCharacters: boolean): Promise<number>;
+    forward(input: string): Promise<OCRDetection[]>;
+}
+declare const _default: Spec | null;
+export default _default;

package/lib/native/NativeVerticalOCR.js

@@ -0,0 +1,2 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('VerticalOCR');

package/lib/types/common.d.ts

@@ -0,0 +1,31 @@
+export type ResourceSource = string | number | object;
+export declare enum ScalarType {
+    BYTE = 0,
+    CHAR = 1,
+    SHORT = 2,
+    INT = 3,
+    LONG = 4,
+    HALF = 5,
+    FLOAT = 6,
+    DOUBLE = 7,
+    BOOL = 11,
+    QINT8 = 12,
+    QUINT8 = 13,
+    QINT32 = 14,
+    QUINT4X2 = 16,
+    QUINT2X4 = 17,
+    BITS16 = 22,
+    FLOAT8E5M2 = 23,
+    FLOAT8E4M3FN = 24,
+    FLOAT8E5M2FNUZ = 25,
+    FLOAT8E4M3FNUZ = 26,
+    UINT16 = 27,
+    UINT32 = 28,
+    UINT64 = 29
+}
+export type TensorBuffer = ArrayBuffer | Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | BigInt64Array | BigUint64Array;
+export interface TensorPtr {
+    dataPtr: TensorBuffer;
+    sizes: number[];
+    scalarType: ScalarType;
+}

package/lib/types/common.js

@@ -0,0 +1,25 @@
+export var ScalarType;
+(function (ScalarType) {
+    ScalarType[ScalarType["BYTE"] = 0] = "BYTE";
+    ScalarType[ScalarType["CHAR"] = 1] = "CHAR";
+    ScalarType[ScalarType["SHORT"] = 2] = "SHORT";
+    ScalarType[ScalarType["INT"] = 3] = "INT";
+    ScalarType[ScalarType["LONG"] = 4] = "LONG";
+    ScalarType[ScalarType["HALF"] = 5] = "HALF";
+    ScalarType[ScalarType["FLOAT"] = 6] = "FLOAT";
+    ScalarType[ScalarType["DOUBLE"] = 7] = "DOUBLE";
+    ScalarType[ScalarType["BOOL"] = 11] = "BOOL";
+    ScalarType[ScalarType["QINT8"] = 12] = "QINT8";
+    ScalarType[ScalarType["QUINT8"] = 13] = "QUINT8";
+    ScalarType[ScalarType["QINT32"] = 14] = "QINT32";
+    ScalarType[ScalarType["QUINT4X2"] = 16] = "QUINT4X2";
+    ScalarType[ScalarType["QUINT2X4"] = 17] = "QUINT2X4";
+    ScalarType[ScalarType["BITS16"] = 22] = "BITS16";
+    ScalarType[ScalarType["FLOAT8E5M2"] = 23] = "FLOAT8E5M2";
+    ScalarType[ScalarType["FLOAT8E4M3FN"] = 24] = "FLOAT8E4M3FN";
+    ScalarType[ScalarType["FLOAT8E5M2FNUZ"] = 25] = "FLOAT8E5M2FNUZ";
+    ScalarType[ScalarType["FLOAT8E4M3FNUZ"] = 26] = "FLOAT8E4M3FNUZ";
+    ScalarType[ScalarType["UINT16"] = 27] = "UINT16";
+    ScalarType[ScalarType["UINT32"] = 28] = "UINT32";
+    ScalarType[ScalarType["UINT64"] = 29] = "UINT64";
+})(ScalarType || (ScalarType = {}));

package/lib/types/imageSegmentation.d.ts

@@ -0,0 +1,24 @@
+export declare enum DeeplabLabel {
+    BACKGROUND = 0,
+    AEROPLANE = 1,
+    BICYCLE = 2,
+    BIRD = 3,
+    BOAT = 4,
+    BOTTLE = 5,
+    BUS = 6,
+    CAR = 7,
+    CAT = 8,
+    CHAIR = 9,
+    COW = 10,
+    DININGTABLE = 11,
+    DOG = 12,
+    HORSE = 13,
+    MOTORBIKE = 14,
+    PERSON = 15,
+    POTTEDPLANT = 16,
+    SHEEP = 17,
+    SOFA = 18,
+    TRAIN = 19,
+    TVMONITOR = 20,
+    ARGMAX = 21
+}

package/lib/types/imageSegmentation.js

@@ -0,0 +1,26 @@
+/* eslint-disable @cspell/spellchecker */
+export var DeeplabLabel;
+(function (DeeplabLabel) {
+    DeeplabLabel[DeeplabLabel["BACKGROUND"] = 0] = "BACKGROUND";
+    DeeplabLabel[DeeplabLabel["AEROPLANE"] = 1] = "AEROPLANE";
+    DeeplabLabel[DeeplabLabel["BICYCLE"] = 2] = "BICYCLE";
+    DeeplabLabel[DeeplabLabel["BIRD"] = 3] = "BIRD";
+    DeeplabLabel[DeeplabLabel["BOAT"] = 4] = "BOAT";
+    DeeplabLabel[DeeplabLabel["BOTTLE"] = 5] = "BOTTLE";
+    DeeplabLabel[DeeplabLabel["BUS"] = 6] = "BUS";
+    DeeplabLabel[DeeplabLabel["CAR"] = 7] = "CAR";
+    DeeplabLabel[DeeplabLabel["CAT"] = 8] = "CAT";
+    DeeplabLabel[DeeplabLabel["CHAIR"] = 9] = "CHAIR";
+    DeeplabLabel[DeeplabLabel["COW"] = 10] = "COW";
+    DeeplabLabel[DeeplabLabel["DININGTABLE"] = 11] = "DININGTABLE";
+    DeeplabLabel[DeeplabLabel["DOG"] = 12] = "DOG";
+    DeeplabLabel[DeeplabLabel["HORSE"] = 13] = "HORSE";
+    DeeplabLabel[DeeplabLabel["MOTORBIKE"] = 14] = "MOTORBIKE";
+    DeeplabLabel[DeeplabLabel["PERSON"] = 15] = "PERSON";
+    DeeplabLabel[DeeplabLabel["POTTEDPLANT"] = 16] = "POTTEDPLANT";
+    DeeplabLabel[DeeplabLabel["SHEEP"] = 17] = "SHEEP";
+    DeeplabLabel[DeeplabLabel["SOFA"] = 18] = "SOFA";
+    DeeplabLabel[DeeplabLabel["TRAIN"] = 19] = "TRAIN";
+    DeeplabLabel[DeeplabLabel["TVMONITOR"] = 20] = "TVMONITOR";
+    DeeplabLabel[DeeplabLabel["ARGMAX"] = 21] = "ARGMAX";
+})(DeeplabLabel || (DeeplabLabel = {}));

package/lib/types/llm.d.ts

@@ -0,0 +1,46 @@
+export interface LLMType {
+    messageHistory: Message[];
+    response: string;
+    token: string;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    error: string | null;
+    configure: ({ chatConfig, toolsConfig, }: {
+        chatConfig?: Partial<ChatConfig>;
+        toolsConfig?: ToolsConfig;
+    }) => void;
+    generate: (messages: Message[], tools?: LLMTool[]) => Promise<void>;
+    sendMessage: (message: string) => Promise<void>;
+    deleteMessage: (index: number) => void;
+    interrupt: () => void;
+}
+export type MessageRole = 'user' | 'assistant' | 'system';
+export interface Message {
+    role: MessageRole;
+    content: string;
+}
+export interface ToolCall {
+    toolName: string;
+    arguments: Object;
+}
+export type LLMTool = Object;
+export interface ChatConfig {
+    initialMessageHistory: Message[];
+    contextWindowLength: number;
+    systemPrompt: string;
+}
+export interface ToolsConfig {
+    tools: LLMTool[];
+    executeToolCallback: (call: ToolCall) => Promise<string | null>;
+    displayToolCalls?: boolean;
+}
+export declare const SPECIAL_TOKENS: {
+    BOS_TOKEN: string;
+    EOS_TOKEN: string;
+    UNK_TOKEN: string;
+    SEP_TOKEN: string;
+    PAD_TOKEN: string;
+    CLS_TOKEN: string;
+    MASK_TOKEN: string;
+};

package/lib/types/llm.js

@@ -0,0 +1,9 @@
+export const SPECIAL_TOKENS = {
+    BOS_TOKEN: 'bos_token',
+    EOS_TOKEN: 'eos_token',
+    UNK_TOKEN: 'unk_token',
+    SEP_TOKEN: 'sep_token',
+    PAD_TOKEN: 'pad_token',
+    CLS_TOKEN: 'cls_token',
+    MASK_TOKEN: 'mask_token',
+};

package/lib/types/objectDetection.d.ts

@@ -0,0 +1,104 @@
+export interface Bbox {
+    x1: number;
+    x2: number;
+    y1: number;
+    y2: number;
+}
+export interface Detection {
+    bbox: Bbox;
+    label: keyof typeof CocoLabel;
+    score: number;
+}
+declare enum CocoLabel {
+    PERSON = 1,
+    BICYCLE = 2,
+    CAR = 3,
+    MOTORCYCLE = 4,
+    AIRPLANE = 5,
+    BUS = 6,
+    TRAIN = 7,
+    TRUCK = 8,
+    BOAT = 9,
+    TRAFFIC_LIGHT = 10,
+    FIRE_HYDRANT = 11,
+    STREET_SIGN = 12,
+    STOP_SIGN = 13,
+    PARKING = 14,
+    BENCH = 15,
+    BIRD = 16,
+    CAT = 17,
+    DOG = 18,
+    HORSE = 19,
+    SHEEP = 20,
+    COW = 21,
+    ELEPHANT = 22,
+    BEAR = 23,
+    ZEBRA = 24,
+    GIRAFFE = 25,
+    HAT = 26,
+    BACKPACK = 27,
+    UMBRELLA = 28,
+    SHOE = 29,
+    EYE = 30,
+    HANDBAG = 31,
+    TIE = 32,
+    SUITCASE = 33,
+    FRISBEE = 34,
+    SKIS = 35,
+    SNOWBOARD = 36,
+    SPORTS = 37,
+    KITE = 38,
+    BASEBALL = 39,
+    SKATEBOARD = 41,
+    SURFBOARD = 42,
+    TENNIS_RACKET = 43,
+    BOTTLE = 44,
+    PLATE = 45,
+    WINE_GLASS = 46,
+    CUP = 47,
+    FORK = 48,
+    KNIFE = 49,
+    SPOON = 50,
+    BOWL = 51,
+    BANANA = 52,
+    APPLE = 53,
+    SANDWICH = 54,
+    ORANGE = 55,
+    BROCCOLI = 56,
+    CARROT = 57,
+    HOT_DOG = 58,
+    PIZZA = 59,
+    DONUT = 60,
+    CAKE = 61,
+    CHAIR = 62,
+    COUCH = 63,
+    POTTED_PLANT = 64,
+    BED = 65,
+    MIRROR = 66,
+    DINING_TABLE = 67,
+    WINDOW = 68,
+    DESK = 69,
+    TOILET = 70,
+    DOOR = 71,
+    TV = 72,
+    LAPTOP = 73,
+    MOUSE = 74,
+    REMOTE = 75,
+    KEYBOARD = 76,
+    CELL_PHONE = 77,
+    MICROWAVE = 78,
+    OVEN = 79,
+    TOASTER = 80,
+    SINK = 81,
+    REFRIGERATOR = 82,
+    BLENDER = 83,
+    BOOK = 84,
+    CLOCK = 85,
+    VASE = 86,
+    SCISSORS = 87,
+    TEDDY_BEAR = 88,
+    HAIR_DRIER = 89,
+    TOOTHBRUSH = 90,
+    HAIR_BRUSH = 91
+}
+export {};