hume 0.8.10 → 0.9.1

package/serialization/resources/expressionMeasurement/resources/batch/types/SourceUrl.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { Url } from "./Url";
-export declare const SourceUrl: core.serialization.ObjectSchema<serializers.expressionMeasurement.SourceUrl.Raw, Hume.expressionMeasurement.SourceUrl>;
+export declare const SourceUrl: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.SourceUrl.Raw, Hume.expressionMeasurement.batch.SourceUrl>;
 export declare namespace SourceUrl {
     interface Raw extends Url.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateEmbeddingGeneration.d.ts

@@ -8,7 +8,7 @@ import { StateEmbeddingGenerationQueued } from "./StateEmbeddingGenerationQueued
 import { StateEmbeddingGenerationInProgress } from "./StateEmbeddingGenerationInProgress";
 import { StateEmbeddingGenerationCompletedEmbeddingGeneration } from "./StateEmbeddingGenerationCompletedEmbeddingGeneration";
 import { StateEmbeddingGenerationFailed } from "./StateEmbeddingGenerationFailed";
-export declare const StateEmbeddingGeneration: core.serialization.Schema<serializers.expressionMeasurement.StateEmbeddingGeneration.Raw, Hume.expressionMeasurement.StateEmbeddingGeneration>;
+export declare const StateEmbeddingGeneration: core.serialization.Schema<serializers.expressionMeasurement.batch.StateEmbeddingGeneration.Raw, Hume.expressionMeasurement.batch.StateEmbeddingGeneration>;
 export declare namespace StateEmbeddingGeneration {
     type Raw = StateEmbeddingGeneration.Queued | StateEmbeddingGeneration.InProgress | StateEmbeddingGeneration.Completed | StateEmbeddingGeneration.Failed;
     interface Queued extends StateEmbeddingGenerationQueued.Raw {

package/serialization/resources/expressionMeasurement/resources/batch/types/StateEmbeddingGenerationCompletedEmbeddingGeneration.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { CompletedEmbeddingGeneration } from "./CompletedEmbeddingGeneration";
-export declare const StateEmbeddingGenerationCompletedEmbeddingGeneration: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateEmbeddingGenerationCompletedEmbeddingGeneration.Raw, Hume.expressionMeasurement.StateEmbeddingGenerationCompletedEmbeddingGeneration>;
+export declare const StateEmbeddingGenerationCompletedEmbeddingGeneration: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateEmbeddingGenerationCompletedEmbeddingGeneration.Raw, Hume.expressionMeasurement.batch.StateEmbeddingGenerationCompletedEmbeddingGeneration>;
 export declare namespace StateEmbeddingGenerationCompletedEmbeddingGeneration {
     interface Raw extends CompletedEmbeddingGeneration.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateEmbeddingGenerationFailed.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { Failed } from "./Failed";
-export declare const StateEmbeddingGenerationFailed: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateEmbeddingGenerationFailed.Raw, Hume.expressionMeasurement.StateEmbeddingGenerationFailed>;
+export declare const StateEmbeddingGenerationFailed: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateEmbeddingGenerationFailed.Raw, Hume.expressionMeasurement.batch.StateEmbeddingGenerationFailed>;
 export declare namespace StateEmbeddingGenerationFailed {
     interface Raw extends Failed.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateEmbeddingGenerationInProgress.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { InProgress } from "./InProgress";
-export declare const StateEmbeddingGenerationInProgress: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateEmbeddingGenerationInProgress.Raw, Hume.expressionMeasurement.StateEmbeddingGenerationInProgress>;
+export declare const StateEmbeddingGenerationInProgress: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateEmbeddingGenerationInProgress.Raw, Hume.expressionMeasurement.batch.StateEmbeddingGenerationInProgress>;
 export declare namespace StateEmbeddingGenerationInProgress {
     interface Raw extends InProgress.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateEmbeddingGenerationQueued.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { Queued } from "./Queued";
-export declare const StateEmbeddingGenerationQueued: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateEmbeddingGenerationQueued.Raw, Hume.expressionMeasurement.StateEmbeddingGenerationQueued>;
+export declare const StateEmbeddingGenerationQueued: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateEmbeddingGenerationQueued.Raw, Hume.expressionMeasurement.batch.StateEmbeddingGenerationQueued>;
 export declare namespace StateEmbeddingGenerationQueued {
     interface Raw extends Queued.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateInference.d.ts

@@ -8,7 +8,7 @@ import { QueuedState } from "./QueuedState";
 import { InProgressState } from "./InProgressState";
 import { CompletedState } from "./CompletedState";
 import { FailedState } from "./FailedState";
-export declare const StateInference: core.serialization.Schema<serializers.expressionMeasurement.StateInference.Raw, Hume.expressionMeasurement.StateInference>;
+export declare const StateInference: core.serialization.Schema<serializers.expressionMeasurement.batch.StateInference.Raw, Hume.expressionMeasurement.batch.StateInference>;
 export declare namespace StateInference {
     type Raw = StateInference.Queued | StateInference.InProgress | StateInference.Completed | StateInference.Failed;
     interface Queued extends QueuedState.Raw {

package/serialization/resources/expressionMeasurement/resources/batch/types/StateTlInference.d.ts

@@ -8,7 +8,7 @@ import { StateTlInferenceQueued } from "./StateTlInferenceQueued";
 import { StateTlInferenceInProgress } from "./StateTlInferenceInProgress";
 import { StateTlInferenceCompletedTlInference } from "./StateTlInferenceCompletedTlInference";
 import { StateTlInferenceFailed } from "./StateTlInferenceFailed";
-export declare const StateTlInference: core.serialization.Schema<serializers.expressionMeasurement.StateTlInference.Raw, Hume.expressionMeasurement.StateTlInference>;
+export declare const StateTlInference: core.serialization.Schema<serializers.expressionMeasurement.batch.StateTlInference.Raw, Hume.expressionMeasurement.batch.StateTlInference>;
 export declare namespace StateTlInference {
     type Raw = StateTlInference.Queued | StateTlInference.InProgress | StateTlInference.Completed | StateTlInference.Failed;
     interface Queued extends StateTlInferenceQueued.Raw {

package/serialization/resources/expressionMeasurement/resources/batch/types/StateTlInferenceCompletedTlInference.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { CompletedTlInference } from "./CompletedTlInference";
-export declare const StateTlInferenceCompletedTlInference: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateTlInferenceCompletedTlInference.Raw, Hume.expressionMeasurement.StateTlInferenceCompletedTlInference>;
+export declare const StateTlInferenceCompletedTlInference: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateTlInferenceCompletedTlInference.Raw, Hume.expressionMeasurement.batch.StateTlInferenceCompletedTlInference>;
 export declare namespace StateTlInferenceCompletedTlInference {
     interface Raw extends CompletedTlInference.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateTlInferenceFailed.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { Failed } from "./Failed";
-export declare const StateTlInferenceFailed: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateTlInferenceFailed.Raw, Hume.expressionMeasurement.StateTlInferenceFailed>;
+export declare const StateTlInferenceFailed: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateTlInferenceFailed.Raw, Hume.expressionMeasurement.batch.StateTlInferenceFailed>;
 export declare namespace StateTlInferenceFailed {
     interface Raw extends Failed.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateTlInferenceInProgress.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { InProgress } from "./InProgress";
-export declare const StateTlInferenceInProgress: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateTlInferenceInProgress.Raw, Hume.expressionMeasurement.StateTlInferenceInProgress>;
+export declare const StateTlInferenceInProgress: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateTlInferenceInProgress.Raw, Hume.expressionMeasurement.batch.StateTlInferenceInProgress>;
 export declare namespace StateTlInferenceInProgress {
     interface Raw extends InProgress.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateTlInferenceQueued.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { Queued } from "./Queued";
-export declare const StateTlInferenceQueued: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateTlInferenceQueued.Raw, Hume.expressionMeasurement.StateTlInferenceQueued>;
+export declare const StateTlInferenceQueued: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateTlInferenceQueued.Raw, Hume.expressionMeasurement.batch.StateTlInferenceQueued>;
 export declare namespace StateTlInferenceQueued {
     interface Raw extends Queued.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateTraining.d.ts

@@ -8,7 +8,7 @@ import { StateTrainingQueued } from "./StateTrainingQueued";
 import { StateTrainingInProgress } from "./StateTrainingInProgress";
 import { StateTrainingCompletedTraining } from "./StateTrainingCompletedTraining";
 import { StateTrainingFailed } from "./StateTrainingFailed";
-export declare const StateTraining: core.serialization.Schema<serializers.expressionMeasurement.StateTraining.Raw, Hume.expressionMeasurement.StateTraining>;
+export declare const StateTraining: core.serialization.Schema<serializers.expressionMeasurement.batch.StateTraining.Raw, Hume.expressionMeasurement.batch.StateTraining>;
 export declare namespace StateTraining {
     type Raw = StateTraining.Queued | StateTraining.InProgress | StateTraining.Completed | StateTraining.Failed;
     interface Queued extends StateTrainingQueued.Raw {

package/serialization/resources/expressionMeasurement/resources/batch/types/StateTrainingCompletedTraining.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { CompletedTraining } from "./CompletedTraining";
-export declare const StateTrainingCompletedTraining: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateTrainingCompletedTraining.Raw, Hume.expressionMeasurement.StateTrainingCompletedTraining>;
+export declare const StateTrainingCompletedTraining: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateTrainingCompletedTraining.Raw, Hume.expressionMeasurement.batch.StateTrainingCompletedTraining>;
 export declare namespace StateTrainingCompletedTraining {
     interface Raw extends CompletedTraining.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateTrainingFailed.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { Failed } from "./Failed";
-export declare const StateTrainingFailed: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateTrainingFailed.Raw, Hume.expressionMeasurement.StateTrainingFailed>;
+export declare const StateTrainingFailed: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateTrainingFailed.Raw, Hume.expressionMeasurement.batch.StateTrainingFailed>;
 export declare namespace StateTrainingFailed {
     interface Raw extends Failed.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateTrainingInProgress.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { InProgress } from "./InProgress";
-export declare const StateTrainingInProgress: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateTrainingInProgress.Raw, Hume.expressionMeasurement.StateTrainingInProgress>;
+export declare const StateTrainingInProgress: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateTrainingInProgress.Raw, Hume.expressionMeasurement.batch.StateTrainingInProgress>;
 export declare namespace StateTrainingInProgress {
     interface Raw extends InProgress.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/StateTrainingQueued.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { Queued } from "./Queued";
-export declare const StateTrainingQueued: core.serialization.ObjectSchema<serializers.expressionMeasurement.StateTrainingQueued.Raw, Hume.expressionMeasurement.StateTrainingQueued>;
+export declare const StateTrainingQueued: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.StateTrainingQueued.Raw, Hume.expressionMeasurement.batch.StateTrainingQueued>;
 export declare namespace StateTrainingQueued {
     interface Raw extends Queued.Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/Status.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const Status: core.serialization.Schema<serializers.expressionMeasurement.Status.Raw, Hume.expressionMeasurement.Status>;
+export declare const Status: core.serialization.Schema<serializers.expressionMeasurement.batch.Status.Raw, Hume.expressionMeasurement.batch.Status>;
 export declare namespace Status {
     type Raw = "QUEUED" | "IN_PROGRESS" | "COMPLETED" | "FAILED";
 }

package/serialization/resources/expressionMeasurement/resources/batch/types/Tag.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const Tag: core.serialization.ObjectSchema<serializers.expressionMeasurement.Tag.Raw, Hume.expressionMeasurement.Tag>;
+export declare const Tag: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.Tag.Raw, Hume.expressionMeasurement.batch.Tag>;
 export declare namespace Tag {
     interface Raw {
         key: string;

package/serialization/resources/expressionMeasurement/resources/batch/types/Target.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const Target: core.serialization.Schema<serializers.expressionMeasurement.Target.Raw, Hume.expressionMeasurement.Target>;
+export declare const Target: core.serialization.Schema<serializers.expressionMeasurement.batch.Target.Raw, Hume.expressionMeasurement.batch.Target>;
 export declare namespace Target {
     type Raw = number | number | string;
 }

package/serialization/resources/expressionMeasurement/resources/batch/types/Task.d.ts

@@ -6,7 +6,7 @@ import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { TaskClassification } from "./TaskClassification";
 import { TaskRegression } from "./TaskRegression";
-export declare const Task: core.serialization.Schema<serializers.expressionMeasurement.Task.Raw, Hume.expressionMeasurement.Task>;
+export declare const Task: core.serialization.Schema<serializers.expressionMeasurement.batch.Task.Raw, Hume.expressionMeasurement.batch.Task>;
 export declare namespace Task {
     type Raw = Task.Classification | Task.Regression;
     interface Classification extends TaskClassification.Raw {

package/serialization/resources/expressionMeasurement/resources/batch/types/TaskClassification.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const TaskClassification: core.serialization.ObjectSchema<serializers.expressionMeasurement.TaskClassification.Raw, Hume.expressionMeasurement.TaskClassification>;
+export declare const TaskClassification: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.TaskClassification.Raw, Hume.expressionMeasurement.batch.TaskClassification>;
 export declare namespace TaskClassification {
     interface Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/TaskRegression.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const TaskRegression: core.serialization.ObjectSchema<serializers.expressionMeasurement.TaskRegression.Raw, Hume.expressionMeasurement.TaskRegression>;
+export declare const TaskRegression: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.TaskRegression.Raw, Hume.expressionMeasurement.batch.TaskRegression>;
 export declare namespace TaskRegression {
     interface Raw {
     }

package/serialization/resources/expressionMeasurement/resources/batch/types/TextSource.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const TextSource: core.serialization.Schema<serializers.expressionMeasurement.TextSource.Raw, Hume.expressionMeasurement.TextSource>;
+export declare const TextSource: core.serialization.Schema<serializers.expressionMeasurement.batch.TextSource.Raw, Hume.expressionMeasurement.batch.TextSource>;
 export declare namespace TextSource {
     type Raw = Record<string, unknown>;
 }

package/serialization/resources/expressionMeasurement/resources/batch/types/TimeInterval.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const TimeInterval: core.serialization.ObjectSchema<serializers.expressionMeasurement.TimeInterval.Raw, Hume.expressionMeasurement.TimeInterval>;
+export declare const TimeInterval: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.TimeInterval.Raw, Hume.expressionMeasurement.batch.TimeInterval>;
 export declare namespace TimeInterval {
     interface Raw {
         begin: number;

package/serialization/resources/expressionMeasurement/resources/batch/types/TlInferenceBaseRequest.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { CustomModel } from "./CustomModel";
-export declare const TlInferenceBaseRequest: core.serialization.ObjectSchema<serializers.expressionMeasurement.TlInferenceBaseRequest.Raw, Hume.expressionMeasurement.TlInferenceBaseRequest>;
+export declare const TlInferenceBaseRequest: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.TlInferenceBaseRequest.Raw, Hume.expressionMeasurement.batch.TlInferenceBaseRequest>;
 export declare namespace TlInferenceBaseRequest {
     interface Raw {
         custom_model: CustomModel.Raw;

package/serialization/resources/expressionMeasurement/resources/batch/types/TlInferencePrediction.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { CustomModelPrediction } from "./CustomModelPrediction";
-export declare const TlInferencePrediction: core.serialization.ObjectSchema<serializers.expressionMeasurement.TlInferencePrediction.Raw, Hume.expressionMeasurement.TlInferencePrediction>;
+export declare const TlInferencePrediction: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.TlInferencePrediction.Raw, Hume.expressionMeasurement.batch.TlInferencePrediction>;
 export declare namespace TlInferencePrediction {
     interface Raw {
         file: string;

package/serialization/resources/expressionMeasurement/resources/batch/types/TlInferenceResults.d.ts

@@ -6,7 +6,7 @@ import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { TlInferencePrediction } from "./TlInferencePrediction";
 import { Error_ } from "./Error_";
-export declare const TlInferenceResults: core.serialization.ObjectSchema<serializers.expressionMeasurement.TlInferenceResults.Raw, Hume.expressionMeasurement.TlInferenceResults>;
+export declare const TlInferenceResults: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.TlInferenceResults.Raw, Hume.expressionMeasurement.batch.TlInferenceResults>;
 export declare namespace TlInferenceResults {
     interface Raw {
         predictions: TlInferencePrediction.Raw[];

package/serialization/resources/expressionMeasurement/resources/batch/types/TlInferenceSourcePredictResult.d.ts

@@ -6,7 +6,7 @@ import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { Source } from "./Source";
 import { TlInferenceResults } from "./TlInferenceResults";
-export declare const TlInferenceSourcePredictResult: core.serialization.ObjectSchema<serializers.expressionMeasurement.TlInferenceSourcePredictResult.Raw, Hume.expressionMeasurement.TlInferenceSourcePredictResult>;
+export declare const TlInferenceSourcePredictResult: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.TlInferenceSourcePredictResult.Raw, Hume.expressionMeasurement.batch.TlInferenceSourcePredictResult>;
 export declare namespace TlInferenceSourcePredictResult {
     interface Raw {
         source: Source.Raw;

package/serialization/resources/expressionMeasurement/resources/batch/types/ToxicityScore.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const ToxicityScore: core.serialization.ObjectSchema<serializers.expressionMeasurement.ToxicityScore.Raw, Hume.expressionMeasurement.ToxicityScore>;
+export declare const ToxicityScore: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.ToxicityScore.Raw, Hume.expressionMeasurement.batch.ToxicityScore>;
 export declare namespace ToxicityScore {
     interface Raw {
         name: string;

package/serialization/resources/expressionMeasurement/resources/batch/types/TrainingBaseRequest.d.ts

@@ -9,7 +9,7 @@ import { Dataset } from "./Dataset";
 import { Task } from "./Task";
 import { EvaluationArgs } from "./EvaluationArgs";
 import { Alternative } from "./Alternative";
-export declare const TrainingBaseRequest: core.serialization.ObjectSchema<serializers.expressionMeasurement.TrainingBaseRequest.Raw, Hume.expressionMeasurement.TrainingBaseRequest>;
+export declare const TrainingBaseRequest: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.TrainingBaseRequest.Raw, Hume.expressionMeasurement.batch.TrainingBaseRequest>;
 export declare namespace TrainingBaseRequest {
     interface Raw {
         custom_model: CustomModelRequest.Raw;

package/serialization/resources/expressionMeasurement/resources/batch/types/TrainingCustomModel.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const TrainingCustomModel: core.serialization.ObjectSchema<serializers.expressionMeasurement.TrainingCustomModel.Raw, Hume.expressionMeasurement.TrainingCustomModel>;
+export declare const TrainingCustomModel: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.TrainingCustomModel.Raw, Hume.expressionMeasurement.batch.TrainingCustomModel>;
 export declare namespace TrainingCustomModel {
     interface Raw {
         id: string;

package/serialization/resources/expressionMeasurement/resources/batch/types/Transcription.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { Bcp47Tag } from "./Bcp47Tag";
-export declare const Transcription: core.serialization.ObjectSchema<serializers.expressionMeasurement.Transcription.Raw, Hume.expressionMeasurement.Transcription>;
+export declare const Transcription: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.Transcription.Raw, Hume.expressionMeasurement.batch.Transcription>;
 export declare namespace Transcription {
     interface Raw {
         language?: Bcp47Tag.Raw | null;

package/serialization/resources/expressionMeasurement/resources/batch/types/TranscriptionMetadata.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { Bcp47Tag } from "./Bcp47Tag";
-export declare const TranscriptionMetadata: core.serialization.ObjectSchema<serializers.expressionMeasurement.TranscriptionMetadata.Raw, Hume.expressionMeasurement.TranscriptionMetadata>;
+export declare const TranscriptionMetadata: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.TranscriptionMetadata.Raw, Hume.expressionMeasurement.batch.TranscriptionMetadata>;
 export declare namespace TranscriptionMetadata {
     interface Raw {
         confidence: number;

package/serialization/resources/expressionMeasurement/resources/batch/types/Type.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const Type: core.serialization.Schema<serializers.expressionMeasurement.Type.Raw, Hume.expressionMeasurement.Type>;
+export declare const Type: core.serialization.Schema<serializers.expressionMeasurement.batch.Type.Raw, Hume.expressionMeasurement.batch.Type>;
 export declare namespace Type {
     type Raw = "EMBEDDING_GENERATION" | "INFERENCE" | "TL_INFERENCE" | "TRAINING";
 }

package/serialization/resources/expressionMeasurement/resources/batch/types/Unconfigurable.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const Unconfigurable: core.serialization.Schema<serializers.expressionMeasurement.Unconfigurable.Raw, Hume.expressionMeasurement.Unconfigurable>;
+export declare const Unconfigurable: core.serialization.Schema<serializers.expressionMeasurement.batch.Unconfigurable.Raw, Hume.expressionMeasurement.batch.Unconfigurable>;
 export declare namespace Unconfigurable {
     type Raw = Record<string, unknown>;
 }

package/serialization/resources/expressionMeasurement/resources/batch/types/UnionJob.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { InferenceJob } from "./InferenceJob";
-export declare const UnionJob: core.serialization.ObjectSchema<serializers.expressionMeasurement.UnionJob.Raw, Hume.expressionMeasurement.UnionJob>;
+export declare const UnionJob: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.UnionJob.Raw, Hume.expressionMeasurement.batch.UnionJob>;
 export declare namespace UnionJob {
     type Raw = InferenceJob.Raw;
 }

package/serialization/resources/expressionMeasurement/resources/batch/types/UnionPredictResult.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { InferenceSourcePredictResult } from "./InferenceSourcePredictResult";
-export declare const UnionPredictResult: core.serialization.ObjectSchema<serializers.expressionMeasurement.UnionPredictResult.Raw, Hume.expressionMeasurement.UnionPredictResult>;
+export declare const UnionPredictResult: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.UnionPredictResult.Raw, Hume.expressionMeasurement.batch.UnionPredictResult>;
 export declare namespace UnionPredictResult {
     type Raw = InferenceSourcePredictResult.Raw;
 }

package/serialization/resources/expressionMeasurement/resources/batch/types/Url.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const Url: core.serialization.ObjectSchema<serializers.expressionMeasurement.Url.Raw, Hume.expressionMeasurement.Url>;
+export declare const Url: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.Url.Raw, Hume.expressionMeasurement.batch.Url>;
 export declare namespace Url {
     interface Raw {
         url: string;

package/serialization/resources/expressionMeasurement/resources/batch/types/ValidationArgs.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { Target } from "./Target";
-export declare const ValidationArgs: core.serialization.ObjectSchema<serializers.expressionMeasurement.ValidationArgs.Raw, Hume.expressionMeasurement.ValidationArgs>;
+export declare const ValidationArgs: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.ValidationArgs.Raw, Hume.expressionMeasurement.batch.ValidationArgs>;
 export declare namespace ValidationArgs {
     interface Raw {
         positive_label?: Target.Raw | null;

package/serialization/resources/expressionMeasurement/resources/batch/types/When.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const When: core.serialization.Schema<serializers.expressionMeasurement.When.Raw, Hume.expressionMeasurement.When>;
+export declare const When: core.serialization.Schema<serializers.expressionMeasurement.batch.When.Raw, Hume.expressionMeasurement.batch.When>;
 export declare namespace When {
     type Raw = "created_before" | "created_after";
 }

package/serialization/resources/expressionMeasurement/resources/batch/types/Window.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const Window: core.serialization.ObjectSchema<serializers.expressionMeasurement.Window.Raw, Hume.expressionMeasurement.Window>;
+export declare const Window: core.serialization.ObjectSchema<serializers.expressionMeasurement.batch.Window.Raw, Hume.expressionMeasurement.batch.Window>;
 export declare namespace Window {
     interface Raw {
         length?: number | null;

package/serialization/resources/expressionMeasurement/resources/index.d.ts

@@ -1,4 +1,2 @@
 export * as batch from "./batch";
-export * from "./batch/types";
 export * as stream from "./stream";
-export * from "./stream/types";

package/serialization/resources/expressionMeasurement/resources/index.js

@@ -22,12 +22,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stream = exports.batch = void 0;
 exports.batch = __importStar(require("./batch"));
-__exportStar(require("./batch/types"), exports);
 exports.stream = __importStar(require("./stream"));
-__exportStar(require("./stream/types"), exports);

package/serialization/resources/expressionMeasurement/resources/stream/types/Config.d.ts

@@ -4,15 +4,15 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-import { StreamModelsEndpointPayloadModelsFace } from "./StreamModelsEndpointPayloadModelsFace";
-import { StreamModelsEndpointPayloadModelsLanguage } from "./StreamModelsEndpointPayloadModelsLanguage";
-export declare const Config: core.serialization.ObjectSchema<serializers.expressionMeasurement.Config.Raw, Hume.expressionMeasurement.Config>;
+import { StreamFace } from "./StreamFace";
+import { StreamLanguage } from "./StreamLanguage";
+export declare const Config: core.serialization.ObjectSchema<serializers.expressionMeasurement.stream.Config.Raw, Hume.expressionMeasurement.stream.Config>;
 export declare namespace Config {
     interface Raw {
         burst?: Record<string, unknown> | null;
-        face?: StreamModelsEndpointPayloadModelsFace.Raw | null;
+        face?: StreamFace.Raw | null;
         facemesh?: Record<string, unknown> | null;
-        language?: StreamModelsEndpointPayloadModelsLanguage.Raw | null;
+        language?: StreamLanguage.Raw | null;
         prosody?: Record<string, unknown> | null;
     }
 }

package/serialization/resources/expressionMeasurement/resources/stream/types/Config.js

@@ -28,12 +28,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = void 0;
 const core = __importStar(require("../../../../../../core"));
-const StreamModelsEndpointPayloadModelsFace_1 = require("./StreamModelsEndpointPayloadModelsFace");
-const StreamModelsEndpointPayloadModelsLanguage_1 = require("./StreamModelsEndpointPayloadModelsLanguage");
+const StreamFace_1 = require("./StreamFace");
+const StreamLanguage_1 = require("./StreamLanguage");
 exports.Config = core.serialization.object({
     burst: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(),
-    face: StreamModelsEndpointPayloadModelsFace_1.StreamModelsEndpointPayloadModelsFace.optional(),
+    face: StreamFace_1.StreamFace.optional(),
     facemesh: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(),
-    language: StreamModelsEndpointPayloadModelsLanguage_1.StreamModelsEndpointPayloadModelsLanguage.optional(),
+    language: StreamLanguage_1.StreamLanguage.optional(),
     prosody: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(),
 });

package/serialization/resources/expressionMeasurement/resources/stream/types/EmotionEmbedding.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { EmotionEmbeddingItem } from "./EmotionEmbeddingItem";
-export declare const EmotionEmbedding: core.serialization.Schema<serializers.expressionMeasurement.EmotionEmbedding.Raw, Hume.expressionMeasurement.EmotionEmbedding>;
+export declare const EmotionEmbedding: core.serialization.Schema<serializers.expressionMeasurement.stream.EmotionEmbedding.Raw, Hume.expressionMeasurement.stream.EmotionEmbedding>;
 export declare namespace EmotionEmbedding {
     type Raw = EmotionEmbeddingItem.Raw[];
 }

package/serialization/resources/expressionMeasurement/resources/stream/types/EmotionEmbeddingItem.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const EmotionEmbeddingItem: core.serialization.ObjectSchema<serializers.expressionMeasurement.EmotionEmbeddingItem.Raw, Hume.expressionMeasurement.EmotionEmbeddingItem>;
+export declare const EmotionEmbeddingItem: core.serialization.ObjectSchema<serializers.expressionMeasurement.stream.EmotionEmbeddingItem.Raw, Hume.expressionMeasurement.stream.EmotionEmbeddingItem>;
 export declare namespace EmotionEmbeddingItem {
     interface Raw {
         name?: string | null;

package/serialization/resources/expressionMeasurement/resources/stream/types/JobDetails.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const JobDetails: core.serialization.ObjectSchema<serializers.expressionMeasurement.JobDetails.Raw, Hume.expressionMeasurement.JobDetails>;
+export declare const JobDetails: core.serialization.ObjectSchema<serializers.expressionMeasurement.stream.JobDetails.Raw, Hume.expressionMeasurement.stream.JobDetails>;
 export declare namespace JobDetails {
     interface Raw {
         job_id?: string | null;

package/serialization/resources/expressionMeasurement/resources/stream/types/Sentiment.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { SentimentItem } from "./SentimentItem";
-export declare const Sentiment: core.serialization.Schema<serializers.expressionMeasurement.Sentiment.Raw, Hume.expressionMeasurement.Sentiment>;
+export declare const Sentiment: core.serialization.Schema<serializers.expressionMeasurement.stream.Sentiment.Raw, Hume.expressionMeasurement.stream.Sentiment>;
 export declare namespace Sentiment {
     type Raw = SentimentItem.Raw[];
 }

package/serialization/resources/expressionMeasurement/resources/stream/types/SentimentItem.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const SentimentItem: core.serialization.ObjectSchema<serializers.expressionMeasurement.SentimentItem.Raw, Hume.expressionMeasurement.SentimentItem>;
+export declare const SentimentItem: core.serialization.ObjectSchema<serializers.expressionMeasurement.stream.SentimentItem.Raw, Hume.expressionMeasurement.stream.SentimentItem>;
 export declare namespace SentimentItem {
     interface Raw {
         name?: string | null;

package/serialization/resources/expressionMeasurement/resources/stream/types/StreamBoundingBox.d.ts

@@ -4,7 +4,7 @@
 import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
-export declare const StreamBoundingBox: core.serialization.ObjectSchema<serializers.expressionMeasurement.StreamBoundingBox.Raw, Hume.expressionMeasurement.StreamBoundingBox>;
+export declare const StreamBoundingBox: core.serialization.ObjectSchema<serializers.expressionMeasurement.stream.StreamBoundingBox.Raw, Hume.expressionMeasurement.stream.StreamBoundingBox>;
 export declare namespace StreamBoundingBox {
     interface Raw {
         x?: number | null;

package/serialization/resources/expressionMeasurement/resources/stream/types/StreamErrorMessage.d.ts

@@ -5,7 +5,7 @@ import * as serializers from "../../../../../index";
 import * as Hume from "../../../../../../api/index";
 import * as core from "../../../../../../core";
 import { JobDetails } from "./JobDetails";
-export declare const StreamErrorMessage: core.serialization.ObjectSchema<serializers.expressionMeasurement.StreamErrorMessage.Raw, Hume.expressionMeasurement.StreamErrorMessage>;
+export declare const StreamErrorMessage: core.serialization.ObjectSchema<serializers.expressionMeasurement.stream.StreamErrorMessage.Raw, Hume.expressionMeasurement.stream.StreamErrorMessage>;
 export declare namespace StreamErrorMessage {
     interface Raw {
         error?: string | null;