@huggingface/transformers 4.0.0-next.0 → 4.0.0-next.10

package/types/pipelines/image-to-text.d.ts

@@ -11,12 +11,12 @@ declare const ImageToTextPipeline_base: new (options: TextImagePipelineConstruct
  *
  * @callback ImageToTextPipelineCallbackSingle Assign labels to the image passed as input.
  * @param {ImageInput} texts The image to be captioned.
- * @param {Partial<import('../generation/configuration_utils.js').GenerationConfig>} [options] Additional keyword arguments to pass along to the generate method of the model.
+ * @param {Partial<import('../generation/parameters.js').GenerationFunctionParameters>} [options] Additional keyword arguments to pass along to the generate method of the model.
  * @returns {Promise<ImageToTextOutput>} An object containing the generated text(s).
  *
  * @callback ImageToTextPipelineCallbackBatch Assign labels to the images passed as inputs.
  * @param {ImageInput[]} texts The images to be captioned.
- * @param {Partial<import('../generation/configuration_utils.js').GenerationConfig>} [options] Additional keyword arguments to pass along to the generate method of the model.
+ * @param {Partial<import('../generation/parameters.js').GenerationFunctionParameters>} [options] Additional keyword arguments to pass along to the generate method of the model.
  * @returns {Promise<ImageToTextOutput[]>} An array containing the generated text(s) for each image.
  *
  * @typedef {ImageToTextPipelineCallbackSingle & ImageToTextPipelineCallbackBatch} ImageToTextPipelineCallback
@@ -66,11 +66,11 @@ export type ImageToTextOutput = ImageToTextSingle[];
 /**
  * Assign labels to the image passed as input.
  */
-export type ImageToTextPipelineCallbackSingle = (texts: ImageInput, options?: Partial<import("../generation/configuration_utils.js").GenerationConfig>) => Promise<ImageToTextOutput>;
+export type ImageToTextPipelineCallbackSingle = (texts: ImageInput, options?: Partial<import("../generation/parameters.js").GenerationFunctionParameters>) => Promise<ImageToTextOutput>;
 /**
  * Assign labels to the images passed as inputs.
  */
-export type ImageToTextPipelineCallbackBatch = (texts: ImageInput[], options?: Partial<import("../generation/configuration_utils.js").GenerationConfig>) => Promise<ImageToTextOutput[]>;
+export type ImageToTextPipelineCallbackBatch = (texts: ImageInput[], options?: Partial<import("../generation/parameters.js").GenerationFunctionParameters>) => Promise<ImageToTextOutput[]>;
 export type ImageToTextPipelineCallback = ImageToTextPipelineCallbackSingle & ImageToTextPipelineCallbackBatch;
 export type ImageToTextPipelineType = TextImagePipelineConstructorArgs & ImageToTextPipelineCallback & Disposable;
 export {};

package/types/pipelines/image-to-text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-to-text.d.ts","sourceRoot":"","sources":["../../src/pipelines/image-to-text.js"],"names":[],"mappings":"sDAsDqC,gCAAgC,KAAK,uBAAuB;AAlDjG;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAGI;;;;WAmBC;CACJ;+CAvEY,OAAO,YAAY,EAAE,gCAAgC;yBACrD,OAAO,YAAY,EAAE,UAAU;yBAC/B,OAAO,YAAY,EAAE,UAAU;;;;;oBAK9B,MAAM;;gCACP,iBAAiB,EAAE;;;;wDAGrB,UAAU,YACV,OAAO,CAAC,OAAO,sCAAsC,EAAE,gBAAgB,CAAC,KACtE,OAAO,CAAC,iBAAiB,CAAC;;;;uDAG5B,UAAU,EAAE,YACZ,OAAO,CAAC,OAAO,sCAAsC,EAAE,gBAAgB,CAAC,KACtE,OAAO,CAAC,iBAAiB,EAAE,CAAC;0CAE5B,iCAAiC,GAAG,gCAAgC;sCAEpE,gCAAgC,GAAG,2BAA2B,GAAG,UAAU"}
+{"version":3,"file":"image-to-text.d.ts","sourceRoot":"","sources":["../../src/pipelines/image-to-text.js"],"names":[],"mappings":"sDAsDqC,gCAAgC,KAAK,uBAAuB;AAlDjG;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAGI;;;;WAmBC;CACJ;+CAvEY,OAAO,YAAY,EAAE,gCAAgC;yBACrD,OAAO,YAAY,EAAE,UAAU;yBAC/B,OAAO,YAAY,EAAE,UAAU;;;;;oBAK9B,MAAM;;gCACP,iBAAiB,EAAE;;;;wDAGrB,UAAU,YACV,OAAO,CAAC,OAAO,6BAA6B,EAAE,4BAA4B,CAAC,KACzE,OAAO,CAAC,iBAAiB,CAAC;;;;uDAG5B,UAAU,EAAE,YACZ,OAAO,CAAC,OAAO,6BAA6B,EAAE,4BAA4B,CAAC,KACzE,OAAO,CAAC,iBAAiB,EAAE,CAAC;0CAE5B,iCAAiC,GAAG,gCAAgC;sCAEpE,gCAAgC,GAAG,2BAA2B,GAAG,UAAU"}

package/types/pipelines/index.d.ts

@@ -0,0 +1,265 @@
+export const SUPPORTED_TASKS: Readonly<{
+    'text-classification': {
+        pipeline: typeof TextClassificationPipeline;
+        model: typeof AutoModelForSequenceClassification;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'token-classification': {
+        pipeline: typeof TokenClassificationPipeline;
+        model: typeof AutoModelForTokenClassification;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'question-answering': {
+        pipeline: typeof QuestionAnsweringPipeline;
+        model: typeof AutoModelForQuestionAnswering;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'fill-mask': {
+        pipeline: typeof FillMaskPipeline;
+        model: typeof AutoModelForMaskedLM;
+        default: {
+            model: string;
+            dtype: string;
+        };
+        type: string;
+    };
+    summarization: {
+        pipeline: typeof SummarizationPipeline;
+        model: typeof AutoModelForSeq2SeqLM;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    translation: {
+        pipeline: typeof TranslationPipeline;
+        model: typeof AutoModelForSeq2SeqLM;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'text2text-generation': {
+        pipeline: typeof Text2TextGenerationPipeline;
+        model: typeof AutoModelForSeq2SeqLM;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'text-generation': {
+        pipeline: typeof TextGenerationPipeline;
+        model: typeof AutoModelForCausalLM;
+        default: {
+            model: string;
+            dtype: string;
+        };
+        type: string;
+    };
+    'zero-shot-classification': {
+        pipeline: typeof ZeroShotClassificationPipeline;
+        model: typeof AutoModelForSequenceClassification;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'audio-classification': {
+        pipeline: typeof AudioClassificationPipeline;
+        model: typeof AutoModelForAudioClassification;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'zero-shot-audio-classification': {
+        pipeline: typeof ZeroShotAudioClassificationPipeline;
+        model: typeof AutoModel;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'automatic-speech-recognition': {
+        pipeline: typeof AutomaticSpeechRecognitionPipeline;
+        model: (typeof AutoModelForSpeechSeq2Seq)[];
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'text-to-audio': {
+        pipeline: typeof TextToAudioPipeline;
+        model: (typeof AutoModelForTextToSpectrogram)[];
+        default: {
+            model: string;
+            dtype: string;
+        };
+        type: string;
+    };
+    'image-to-text': {
+        pipeline: typeof ImageToTextPipeline;
+        model: typeof AutoModelForVision2Seq;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'image-classification': {
+        pipeline: typeof ImageClassificationPipeline;
+        model: typeof AutoModelForImageClassification;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'image-segmentation': {
+        pipeline: typeof ImageSegmentationPipeline;
+        model: (typeof AutoModelForImageSegmentation)[];
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'background-removal': {
+        pipeline: typeof BackgroundRemovalPipeline;
+        model: (typeof AutoModelForImageSegmentation)[];
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'zero-shot-image-classification': {
+        pipeline: typeof ZeroShotImageClassificationPipeline;
+        model: typeof AutoModel;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'object-detection': {
+        pipeline: typeof ObjectDetectionPipeline;
+        model: typeof AutoModelForObjectDetection;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'zero-shot-object-detection': {
+        pipeline: typeof ZeroShotObjectDetectionPipeline;
+        model: typeof AutoModelForZeroShotObjectDetection;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'document-question-answering': {
+        pipeline: typeof DocumentQuestionAnsweringPipeline;
+        model: typeof AutoModelForDocumentQuestionAnswering;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'image-to-image': {
+        pipeline: typeof ImageToImagePipeline;
+        model: typeof AutoModelForImageToImage;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'depth-estimation': {
+        pipeline: typeof DepthEstimationPipeline;
+        model: typeof AutoModelForDepthEstimation;
+        default: {
+            model: string;
+        };
+        type: string;
+    };
+    'feature-extraction': {
+        pipeline: typeof FeatureExtractionPipeline;
+        model: typeof AutoModel;
+        default: {
+            model: string;
+            dtype: string;
+        };
+        type: string;
+    };
+    'image-feature-extraction': {
+        pipeline: typeof ImageFeatureExtractionPipeline;
+        model: (typeof AutoModel)[];
+        default: {
+            model: string;
+            dtype: string;
+        };
+        type: string;
+    };
+}>;
+export const TASK_ALIASES: Readonly<{
+    'sentiment-analysis': "text-classification";
+    ner: "token-classification";
+    asr: "automatic-speech-recognition";
+    'text-to-speech': "text-to-audio";
+    embeddings: "feature-extraction";
+}>;
+export type TaskType = keyof typeof SUPPORTED_TASKS;
+export type AliasType = keyof typeof TASK_ALIASES;
+/**
+ * All possible pipeline types.
+ */
+export type PipelineType = TaskType | AliasType;
+import { TextClassificationPipeline } from './text-classification.js';
+import { AutoModelForSequenceClassification } from '../models/auto/modeling_auto.js';
+import { TokenClassificationPipeline } from './token-classification.js';
+import { AutoModelForTokenClassification } from '../models/auto/modeling_auto.js';
+import { QuestionAnsweringPipeline } from './question-answering.js';
+import { AutoModelForQuestionAnswering } from '../models/auto/modeling_auto.js';
+import { FillMaskPipeline } from './fill-mask.js';
+import { AutoModelForMaskedLM } from '../models/auto/modeling_auto.js';
+import { SummarizationPipeline } from './summarization.js';
+import { AutoModelForSeq2SeqLM } from '../models/auto/modeling_auto.js';
+import { TranslationPipeline } from './translation.js';
+import { Text2TextGenerationPipeline } from './text2text-generation.js';
+import { TextGenerationPipeline } from './text-generation.js';
+import { AutoModelForCausalLM } from '../models/auto/modeling_auto.js';
+import { ZeroShotClassificationPipeline } from './zero-shot-classification.js';
+import { AudioClassificationPipeline } from './audio-classification.js';
+import { AutoModelForAudioClassification } from '../models/auto/modeling_auto.js';
+import { ZeroShotAudioClassificationPipeline } from './zero-shot-audio-classification.js';
+import { AutoModel } from '../models/auto/modeling_auto.js';
+import { AutomaticSpeechRecognitionPipeline } from './automatic-speech-recognition.js';
+import { AutoModelForSpeechSeq2Seq } from '../models/auto/modeling_auto.js';
+import { TextToAudioPipeline } from './text-to-audio.js';
+import { AutoModelForTextToSpectrogram } from '../models/auto/modeling_auto.js';
+import { ImageToTextPipeline } from './image-to-text.js';
+import { AutoModelForVision2Seq } from '../models/auto/modeling_auto.js';
+import { ImageClassificationPipeline } from './image-classification.js';
+import { AutoModelForImageClassification } from '../models/auto/modeling_auto.js';
+import { ImageSegmentationPipeline } from './image-segmentation.js';
+import { AutoModelForImageSegmentation } from '../models/auto/modeling_auto.js';
+import { BackgroundRemovalPipeline } from './background-removal.js';
+import { ZeroShotImageClassificationPipeline } from './zero-shot-image-classification.js';
+import { ObjectDetectionPipeline } from './object-detection.js';
+import { AutoModelForObjectDetection } from '../models/auto/modeling_auto.js';
+import { ZeroShotObjectDetectionPipeline } from './zero-shot-object-detection.js';
+import { AutoModelForZeroShotObjectDetection } from '../models/auto/modeling_auto.js';
+import { DocumentQuestionAnsweringPipeline } from './document-question-answering.js';
+import { AutoModelForDocumentQuestionAnswering } from '../models/auto/modeling_auto.js';
+import { ImageToImagePipeline } from './image-to-image.js';
+import { AutoModelForImageToImage } from '../models/auto/modeling_auto.js';
+import { DepthEstimationPipeline } from './depth-estimation.js';
+import { AutoModelForDepthEstimation } from '../models/auto/modeling_auto.js';
+import { FeatureExtractionPipeline } from './feature-extraction.js';
+import { ImageFeatureExtractionPipeline } from './image-feature-extraction.js';
+export { TextClassificationPipeline, TokenClassificationPipeline, QuestionAnsweringPipeline, FillMaskPipeline, SummarizationPipeline, TranslationPipeline, Text2TextGenerationPipeline, TextGenerationPipeline, ZeroShotClassificationPipeline, AudioClassificationPipeline, ZeroShotAudioClassificationPipeline, AutomaticSpeechRecognitionPipeline, TextToAudioPipeline, ImageToTextPipeline, ImageClassificationPipeline, ImageSegmentationPipeline, BackgroundRemovalPipeline, ZeroShotImageClassificationPipeline, ObjectDetectionPipeline, ZeroShotObjectDetectionPipeline, DocumentQuestionAnsweringPipeline, ImageToImagePipeline, DepthEstimationPipeline, FeatureExtractionPipeline, ImageFeatureExtractionPipeline };
+//# sourceMappingURL=index.d.ts.map

package/types/pipelines/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pipelines/index.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8MG;AAIH;;;;;;GASG;uBA+BU,MAAM,OAAO,eAAe;wBAC5B,MAAM,OAAO,YAAY;;;;2BACzB,QAAQ,GAAG,SAAS;2CAtRU,0BAA0B;mDAF9D,iCAAiC;4CAGI,2BAA2B;gDAHhE,iCAAiC;0CAIE,yBAAyB;8CAJ5D,iCAAiC;iCAKP,gBAAgB;qCAL1C,iCAAiC;sCAMF,oBAAoB;sCANnD,iCAAiC;oCAOJ,kBAAkB;4CACV,2BAA2B;uCAChC,sBAAsB;qCATtD,iCAAiC;+CAUO,+BAA+B;4CAClC,2BAA2B;gDAXhE,iCAAiC;oDAYY,qCAAqC;0BAZlF,iCAAiC;mDAaW,mCAAmC;0CAb/E,iCAAiC;oCAcJ,oBAAoB;8CAdjD,iCAAiC;oCAeJ,oBAAoB;uCAfjD,iCAAiC;4CAgBI,2BAA2B;gDAhBhE,iCAAiC;0CAiBE,yBAAyB;8CAjB5D,iCAAiC;0CAkBE,yBAAyB;oDACf,qCAAqC;wCACjD,uBAAuB;4CApBxD,iCAAiC;gDAqBQ,iCAAiC;oDArB1E,iCAAiC;kDAsBU,kCAAkC;sDAtB7E,iCAAiC;qCAuBH,qBAAqB;yCAvBnD,iCAAiC;wCAwBA,uBAAuB;4CAxBxD,iCAAiC;0CAyBE,yBAAyB;+CACpB,+BAA+B"}

package/types/pipelines/summarization.d.ts

@@ -10,7 +10,7 @@ declare const SummarizationPipeline_base: new (options: TextPipelineConstructorA
  *
  * @callback SummarizationPipelineCallback Summarize the text(s) given as inputs.
  * @param {string|string[]} texts One or several articles (or one list of articles) to summarize.
- * @param {import('../generation/configuration_utils.js').GenerationConfig} [options] Additional keyword arguments to pass along to the generate method of the model.
+ * @param {import('../generation/parameters.js').GenerationFunctionParameters} [options] Additional keyword arguments to pass along to the generate method of the model.
  * @returns {Promise<SummarizationOutput>}
  *
  * @typedef {TextPipelineConstructorArgs & SummarizationPipelineCallback & Disposable} SummarizationPipelineType
@@ -53,7 +53,7 @@ export type SummarizationOutput = SummarizationSingle[];
 /**
  * Summarize the text(s) given as inputs.
  */
-export type SummarizationPipelineCallback = (texts: string | string[], options?: import("../generation/configuration_utils.js").GenerationConfig) => Promise<SummarizationOutput>;
+export type SummarizationPipelineCallback = (texts: string | string[], options?: import("../generation/parameters.js").GenerationFunctionParameters) => Promise<SummarizationOutput>;
 export type SummarizationPipelineType = TextPipelineConstructorArgs & SummarizationPipelineCallback & Disposable;
 export {};
 //# sourceMappingURL=summarization.d.ts.map

package/types/pipelines/summarization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"summarization.d.ts","sourceRoot":"","sources":["../../src/pipelines/summarization.js"],"names":[],"mappings":"wDA2CqC,2BAA2B,KAAK,yBAAyB;AAzC9F;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAKI,6BAA6B;IAC7B,MADW,cAAc,CACH;CACzB;0CA9CY,OAAO,YAAY,EAAE,2BAA2B;yBAChD,OAAO,YAAY,EAAE,UAAU;;;;;kBAK9B,MAAM;;kCACP,mBAAmB,EAAE;;;;oDAGvB,MAAM,GAAC,MAAM,EAAE,YACf,OAAO,sCAAsC,EAAE,gBAAgB,KAC7D,OAAO,CAAC,mBAAmB,CAAC;wCAE5B,2BAA2B,GAAG,6BAA6B,GAAG,UAAU"}
+{"version":3,"file":"summarization.d.ts","sourceRoot":"","sources":["../../src/pipelines/summarization.js"],"names":[],"mappings":"wDA2CqC,2BAA2B,KAAK,yBAAyB;AAzC9F;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAKI,6BAA6B;IAC7B,MADW,cAAc,CACH;CACzB;0CA9CY,OAAO,YAAY,EAAE,2BAA2B;yBAChD,OAAO,YAAY,EAAE,UAAU;;;;;kBAK9B,MAAM;;kCACP,mBAAmB,EAAE;;;;oDAGvB,MAAM,GAAC,MAAM,EAAE,YACf,OAAO,6BAA6B,EAAE,4BAA4B,KAChE,OAAO,CAAC,mBAAmB,CAAC;wCAE5B,2BAA2B,GAAG,6BAA6B,GAAG,UAAU"}

package/types/pipelines/text-generation.d.ts

@@ -16,7 +16,7 @@ declare const TextGenerationPipeline_base: new (options: TextPipelineConstructor
  * @property {boolean} [return_full_text=true] If set to `false` only added text is returned, otherwise the full text is returned.
  * @property {Object} [tokenizer_encode_kwargs] Additional keyword arguments to pass along to the encoding step of the tokenizer.
  * If the text input is a chat, it is passed to `apply_chat_template`. Otherwise, it is passed to the tokenizer's call function.
- * @typedef {import('../generation/configuration_utils.js').GenerationConfig & TextGenerationSpecificParams} TextGenerationConfig
+ * @typedef {import('../generation/parameters.js').GenerationFunctionParameters & TextGenerationSpecificParams} TextGenerationConfig
  *
  * @callback TextGenerationPipelineCallbackString
  * @param {string} texts One prompt to complete.
@@ -84,7 +84,11 @@ declare const TextGenerationPipeline_base: new (options: TextPipelineConstructor
  * ```
  */
 export class TextGenerationPipeline extends TextGenerationPipeline_base {
-    _call(texts: any, generate_kwargs?: {}): Promise<TextGenerationOutput | TextGenerationOutput[]>;
+    /**
+     * @param {string | string[] | import('../tokenization_utils.js').Message[] | import('../tokenization_utils.js').Message[][]} texts
+     * @param {Partial<TextGenerationConfig>} generate_kwargs
+     */
+    _call(texts: string | string[] | import("../tokenization_utils.js").Message[] | import("../tokenization_utils.js").Message[][], generate_kwargs?: Partial<TextGenerationConfig>): Promise<TextGenerationOutput | TextGenerationOutput[]>;
 }
 export type TextPipelineConstructorArgs = import("./_base.js").TextPipelineConstructorArgs;
 export type Disposable = import("./_base.js").Disposable;
@@ -123,7 +127,7 @@ export type TextGenerationSpecificParams = {
      */
     tokenizer_encode_kwargs?: any;
 };
-export type TextGenerationConfig = import("../generation/configuration_utils.js").GenerationConfig & TextGenerationSpecificParams;
+export type TextGenerationConfig = import("../generation/parameters.js").GenerationFunctionParameters & TextGenerationSpecificParams;
 export type TextGenerationPipelineCallbackString = (texts: string, options?: Partial<TextGenerationConfig>) => Promise<TextGenerationStringOutput>;
 export type TextGenerationPipelineCallbackChat = (texts: Chat, options?: Partial<TextGenerationConfig>) => Promise<TextGenerationChatOutput>;
 export type TextGenerationPipelineCallbackStringBatched = (texts: string[], options?: Partial<TextGenerationConfig>) => Promise<TextGenerationStringOutput[]>;

package/types/pipelines/text-generation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text-generation.d.ts","sourceRoot":"","sources":["../../src/pipelines/text-generation.js"],"names":[],"mappings":"yDAoGqC,2BAA2B,KAAK,0BAA0B;AAtF/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IAGI,gGA8FC;CACJ;0CAhMY,OAAO,YAAY,EAAE,2BAA2B;yBAChD,OAAO,YAAY,EAAE,UAAU;mBAC/B,OAAO,0BAA0B,EAAE,OAAO,EAAE;;;;;oBAS3C,MAAM;;yCACP,0BAA0B,EAAE;;;;;oBAG3B,IAAI;;uCACL,wBAAwB,EAAE;mCAE1B,0BAA0B,GAAG,wBAAwB;mCACrD,oBAAoB,EAAE;;;;;;;;yBAGrB,OAAO;;;;uBACP,OAAO;;;;;;;mCAGR,OAAO,sCAAsC,EAAE,gBAAgB,GAAG,4BAA4B;2DAGhG,MAAM,YACN,OAAO,CAAC,oBAAoB,CAAC,KAC3B,OAAO,CAAC,0BAA0B,CAAC;yDAGrC,IAAI,YACJ,OAAO,CAAC,oBAAoB,CAAC,KAC3B,OAAO,CAAC,wBAAwB,CAAC;kEAGnC,MAAM,EAAE,YACR,OAAO,CAAC,oBAAoB,CAAC,KAC3B,OAAO,CAAC,0BAA0B,EAAE,CAAC;gEAGvC,IAAI,EAAE,YACN,OAAO,CAAC,oBAAoB,CAAC,KAC3B,OAAO,CAAC,wBAAwB,EAAE,CAAC;6CAEnC,oCAAoC,GAAG,kCAAkC,GAAG,2CAA2C,GAAG,yCAAyC;yCAEnK,2BAA2B,GAAG,8BAA8B,GAAG,UAAU"}
+{"version":3,"file":"text-generation.d.ts","sourceRoot":"","sources":["../../src/pipelines/text-generation.js"],"names":[],"mappings":"yDAoGqC,2BAA2B,KAAK,0BAA0B;AAtF/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IAGI;;;OAGG;IACH,aAHW,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,0BAA0B,EAAE,OAAO,EAAE,GAAG,OAAO,0BAA0B,EAAE,OAAO,EAAE,EAAE,oBACjH,OAAO,CAAC,oBAAoB,CAAC,0DAgGvC;CACJ;0CApMY,OAAO,YAAY,EAAE,2BAA2B;yBAChD,OAAO,YAAY,EAAE,UAAU;mBAC/B,OAAO,0BAA0B,EAAE,OAAO,EAAE;;;;;oBAS3C,MAAM;;yCACP,0BAA0B,EAAE;;;;;oBAG3B,IAAI;;uCACL,wBAAwB,EAAE;mCAE1B,0BAA0B,GAAG,wBAAwB;mCACrD,oBAAoB,EAAE;;;;;;;;yBAGrB,OAAO;;;;uBACP,OAAO;;;;;;;mCAGR,OAAO,6BAA6B,EAAE,4BAA4B,GAAG,4BAA4B;2DAGnG,MAAM,YACN,OAAO,CAAC,oBAAoB,CAAC,KAC3B,OAAO,CAAC,0BAA0B,CAAC;yDAGrC,IAAI,YACJ,OAAO,CAAC,oBAAoB,CAAC,KAC3B,OAAO,CAAC,wBAAwB,CAAC;kEAGnC,MAAM,EAAE,YACR,OAAO,CAAC,oBAAoB,CAAC,KAC3B,OAAO,CAAC,0BAA0B,EAAE,CAAC;gEAGvC,IAAI,EAAE,YACN,OAAO,CAAC,oBAAoB,CAAC,KAC3B,OAAO,CAAC,wBAAwB,EAAE,CAAC;6CAEnC,oCAAoC,GAAG,kCAAkC,GAAG,2CAA2C,GAAG,yCAAyC;yCAEnK,2BAA2B,GAAG,8BAA8B,GAAG,UAAU"}

package/types/pipelines/text-to-audio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text-to-audio.d.ts","sourceRoot":"","sources":["../../src/pipelines/text-to-audio.js"],"names":[],"mappings":"sDA2EqC,kCAAkC,KAAK,uBAAuB;AApEnG;;;GAGG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IAGI,2BAA+C;IAU3C,sDAAsC;IAG1C,oFAyBC;IAED;;;;;;;;OAQG;IACH,8BAYC;IAED,sEASC;IAED;;;;uCAyBC;IAED,yEAaC;IAED;;uCAsBC;CACJ;+CAhNY,OAAO,YAAY,EAAE,gCAAgC;yBACrD,OAAO,YAAY,EAAE,UAAU;;;;;cAK9B,OAAO,6BAA6B,EAAE,eAAe;;iDACtD,gCAAgC,GAAG,cAAc;gCAIjD,QAAQ,EAAE;;;;;;;;yBAGT,MAAM,GAAC,YAAY,GAAC,MAAM,GAAC,GAAG;;;;;0BAC9B,MAAM;;;;YAEN,MAAM;;;;;uDAGT,MAAM,YACN,0BAA0B,KACxB,OAAO,CAAC,QAAQ,CAAC;;;;uDAGnB,MAAM,EAAE,YACR,0BAA0B,KACxB,OAAO,CAAC,iBAAiB,CAAC;0CAE1B,iCAAiC,GAAG,gCAAgC;sCAEpE,kCAAkC,GAAG,2BAA2B,GAAG,UAAU;yBApCjE,mBAAmB;uBADrB,oBAAoB"}
+{"version":3,"file":"text-to-audio.d.ts","sourceRoot":"","sources":["../../src/pipelines/text-to-audio.js"],"names":[],"mappings":"sDA6EqC,kCAAkC,KAAK,uBAAuB;AApEnG;;;GAGG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IAGI,2BAA+C;IAU3C,sDAAsC;IAG1C,oFAyBC;IAED;;;;;;;;OAQG;IACH,8BAYC;IAED,sEASC;IAED;;;;uCAyBC;IAED,yEAaC;IAED;;uCAsBC;CACJ;+CAhNY,OAAO,YAAY,EAAE,gCAAgC;yBACrD,OAAO,YAAY,EAAE,UAAU;;;;;cAK9B,OAAO,6BAA6B,EAAE,eAAe;;iDACtD,gCAAgC,GAAG,cAAc;gCAIjD,QAAQ,EAAE;;;;;;;;yBAGT,MAAM,GAAC,YAAY,GAAC,MAAM,GAAC,GAAG;;;;;0BAC9B,MAAM;;;;YAEN,MAAM;;;;;uDAGT,MAAM,YACN,0BAA0B,KACxB,OAAO,CAAC,QAAQ,CAAC;;;;uDAGnB,MAAM,EAAE,YACR,0BAA0B,KACxB,OAAO,CAAC,iBAAiB,CAAC;0CAE1B,iCAAiC,GAAG,gCAAgC;sCAEpE,kCAAkC,GAAG,2BAA2B,GAAG,UAAU;yBAtCjE,mBAAmB;uBADrB,oBAAoB"}

package/types/pipelines/text2text-generation.d.ts

@@ -10,7 +10,7 @@ declare const Text2TextGenerationPipeline_base: new (options: TextPipelineConstr
  *
  * @callback Text2TextGenerationPipelineCallback Generate the output text(s) using text(s) given as inputs.
  * @param {string|string[]} texts Input text for the encoder.
- * @param {Partial<import('../generation/configuration_utils.js').GenerationConfig>} [options] Additional keyword arguments to pass along to the generate method of the model.
+ * @param {Partial<import('../generation/parameters.js').GenerationFunctionParameters>} [options] Additional keyword arguments to pass along to the generate method of the model.
  * @returns {Promise<Text2TextGenerationOutput>}
  *
  * @typedef {TextPipelineConstructorArgs & Text2TextGenerationPipelineCallback & Disposable} Text2TextGenerationPipelineType
@@ -32,7 +32,7 @@ declare const Text2TextGenerationPipeline_base: new (options: TextPipelineConstr
 export class Text2TextGenerationPipeline extends Text2TextGenerationPipeline_base {
     /** @type {'generated_text'} */
     _key: "generated_text";
-    _call(texts: string | string[], options?: Partial<import("../generation/configuration_utils.js").GenerationConfig>): Promise<Text2TextGenerationOutput>;
+    _call(texts: string | string[], options?: Partial<import("../generation/parameters.js").GenerationFunctionParameters>): Promise<Text2TextGenerationOutput>;
 }
 export type TextPipelineConstructorArgs = import("./_base.js").TextPipelineConstructorArgs;
 export type Disposable = import("./_base.js").Disposable;
@@ -46,7 +46,7 @@ export type Text2TextGenerationOutput = Text2TextGenerationSingle[];
 /**
  * Generate the output text(s) using text(s) given as inputs.
  */
-export type Text2TextGenerationPipelineCallback = (texts: string | string[], options?: Partial<import("../generation/configuration_utils.js").GenerationConfig>) => Promise<Text2TextGenerationOutput>;
+export type Text2TextGenerationPipelineCallback = (texts: string | string[], options?: Partial<import("../generation/parameters.js").GenerationFunctionParameters>) => Promise<Text2TextGenerationOutput>;
 export type Text2TextGenerationPipelineType = TextPipelineConstructorArgs & Text2TextGenerationPipelineCallback & Disposable;
 export {};
 //# sourceMappingURL=text2text-generation.d.ts.map

package/types/pipelines/text2text-generation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text2text-generation.d.ts","sourceRoot":"","sources":["../../src/pipelines/text2text-generation.js"],"names":[],"mappings":"8DAqCqC,2BAA2B,KAAK,+BAA+B;AAjCpG;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;GAaG;AACH;IAGI,+BAA+B;IAC/B,MADW,gBAAgB,CACH;IA1BzB,aACQ,MAAM,GAAC,MAAM,EAAE,YACf,OAAO,CAAC,OAAO,sCAAsC,EAAE,gBAAgB,CAAC,GACtE,OAAO,CAAC,yBAAyB,CAAC,CAE5C;CAsEF;0CApFY,OAAO,YAAY,EAAE,2BAA2B;yBAChD,OAAO,YAAY,EAAE,UAAU;;;;;oBAK9B,MAAM;;wCACP,yBAAyB,EAAE;;;;0DAG7B,MAAM,GAAC,MAAM,EAAE,YACf,OAAO,CAAC,OAAO,sCAAsC,EAAE,gBAAgB,CAAC,KACtE,OAAO,CAAC,yBAAyB,CAAC;8CAElC,2BAA2B,GAAG,mCAAmC,GAAG,UAAU"}
+{"version":3,"file":"text2text-generation.d.ts","sourceRoot":"","sources":["../../src/pipelines/text2text-generation.js"],"names":[],"mappings":"8DAqCqC,2BAA2B,KAAK,+BAA+B;AAjCpG;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;GAaG;AACH;IAGI,+BAA+B;IAC/B,MADW,gBAAgB,CACH;IA1BzB,aACQ,MAAM,GAAC,MAAM,EAAE,YACf,OAAO,CAAC,OAAO,6BAA6B,EAAE,4BAA4B,CAAC,GACzE,OAAO,CAAC,yBAAyB,CAAC,CAE5C;CAsEF;0CApFY,OAAO,YAAY,EAAE,2BAA2B;yBAChD,OAAO,YAAY,EAAE,UAAU;;;;;oBAK9B,MAAM;;wCACP,yBAAyB,EAAE;;;;0DAG7B,MAAM,GAAC,MAAM,EAAE,YACf,OAAO,CAAC,OAAO,6BAA6B,EAAE,4BAA4B,CAAC,KACzE,OAAO,CAAC,yBAAyB,CAAC;8CAElC,2BAA2B,GAAG,mCAAmC,GAAG,UAAU"}

package/types/pipelines/translation.d.ts

@@ -10,7 +10,7 @@ declare const TranslationPipeline_base: new (options: TextPipelineConstructorArg
  *
  * @callback TranslationPipelineCallback Translate the text(s) given as inputs.
  * @param {string|string[]} texts Texts to be translated.
- * @param {import('../generation/configuration_utils.js').GenerationConfig} [options] Additional keyword arguments to pass along to the generate method of the model.
+ * @param {import('../generation/parameters.js').GenerationFunctionParameters} [options] Additional keyword arguments to pass along to the generate method of the model.
  * @returns {Promise<TranslationOutput>}
  *
  * @typedef {TextPipelineConstructorArgs & TranslationPipelineCallback & Disposable} TranslationPipelineType
@@ -82,7 +82,7 @@ export type TranslationOutput = TranslationSingle[];
 /**
  * Translate the text(s) given as inputs.
  */
-export type TranslationPipelineCallback = (texts: string | string[], options?: import("../generation/configuration_utils.js").GenerationConfig) => Promise<TranslationOutput>;
+export type TranslationPipelineCallback = (texts: string | string[], options?: import("../generation/parameters.js").GenerationFunctionParameters) => Promise<TranslationOutput>;
 export type TranslationPipelineType = TextPipelineConstructorArgs & TranslationPipelineCallback & Disposable;
 export {};
 //# sourceMappingURL=translation.d.ts.map

package/types/pipelines/translation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translation.d.ts","sourceRoot":"","sources":["../../src/pipelines/translation.js"],"names":[],"mappings":"sDAwEqC,2BAA2B,KAAK,uBAAuB;AAtE5F;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH;IAKI,iCAAiC;IACjC,MADW,kBAAkB,CACH;CAC7B;0CA3EY,OAAO,YAAY,EAAE,2BAA2B;yBAChD,OAAO,YAAY,EAAE,UAAU;;;;;sBAK9B,MAAM;;gCACP,iBAAiB,EAAE;;;;kDAGrB,MAAM,GAAC,MAAM,EAAE,YACf,OAAO,sCAAsC,EAAE,gBAAgB,KAC7D,OAAO,CAAC,iBAAiB,CAAC;sCAE1B,2BAA2B,GAAG,2BAA2B,GAAG,UAAU"}
+{"version":3,"file":"translation.d.ts","sourceRoot":"","sources":["../../src/pipelines/translation.js"],"names":[],"mappings":"sDAwEqC,2BAA2B,KAAK,uBAAuB;AAtE5F;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH;IAKI,iCAAiC;IACjC,MADW,kBAAkB,CACH;CAC7B;0CA3EY,OAAO,YAAY,EAAE,2BAA2B;yBAChD,OAAO,YAAY,EAAE,UAAU;;;;;sBAK9B,MAAM;;gCACP,iBAAiB,EAAE;;;;kDAGrB,MAAM,GAAC,MAAM,EAAE,YACf,OAAO,6BAA6B,EAAE,4BAA4B,KAChE,OAAO,CAAC,iBAAiB,CAAC;sCAE1B,2BAA2B,GAAG,2BAA2B,GAAG,UAAU"}

package/types/pipelines/zero-shot-classification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zero-shot-classification.d.ts","sourceRoot":"","sources":["../../src/pipelines/zero-shot-classification.js"],"names":[],"mappings":"iEA+EqC,2BAA2B,KAAK,kCAAkC;AA3EvG;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IAWQ;;MAEC;IAED,mBAAgD;IAMhD,sBAAyF;IAO7F;;;+EAqDC;CACJ;0CA3JY,OAAO,YAAY,EAAE,2BAA2B;yBAChD,OAAO,YAAY,EAAE,UAAU;;;;;cAK9B,MAAM;;;;YACN,MAAM,EAAE;;;;YACR,MAAM,EAAE;;;;;;;;;;0BAGR,MAAM;;;;;;;kBAEN,OAAO;;;;;mEAMV,MAAM,oBACN,MAAM,GAAC,MAAM,EAAE,YAEf,qCAAqC,KACnC,OAAO,CAAC,4BAA4B,CAAC;;;;kEAGvC,MAAM,EAAE,oBACR,MAAM,GAAC,MAAM,EAAE,YAEf,qCAAqC,KACnC,OAAO,CAAC,4BAA4B,EAAE,CAAC;qDAEvC,4CAA4C,GAAG,2CAA2C;iDAE1F,2BAA2B,GAAG,sCAAsC,GAAG,UAAU"}
+{"version":3,"file":"zero-shot-classification.d.ts","sourceRoot":"","sources":["../../src/pipelines/zero-shot-classification.js"],"names":[],"mappings":"iEAgFqC,2BAA2B,KAAK,kCAAkC;AA3EvG;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IAWQ;;MAEC;IAED,mBAAgD;IAMhD,sBAAyF;IAO7F;;;+EAqDC;CACJ;0CA3JY,OAAO,YAAY,EAAE,2BAA2B;yBAChD,OAAO,YAAY,EAAE,UAAU;;;;;cAK9B,MAAM;;;;YACN,MAAM,EAAE;;;;YACR,MAAM,EAAE;;;;;;;;;;0BAGR,MAAM;;;;;;;kBAEN,OAAO;;;;;mEAMV,MAAM,oBACN,MAAM,GAAC,MAAM,EAAE,YAEf,qCAAqC,KACnC,OAAO,CAAC,4BAA4B,CAAC;;;;kEAGvC,MAAM,EAAE,oBACR,MAAM,GAAC,MAAM,EAAE,YAEf,qCAAqC,KACnC,OAAO,CAAC,4BAA4B,EAAE,CAAC;qDAEvC,4CAA4C,GAAG,2CAA2C;iDAE1F,2BAA2B,GAAG,sCAAsC,GAAG,UAAU"}