@flurin17/rapidata-typescript-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,789 @@
+import { I as ISelection, a as IUserFilterModel, b as IAudienceFilter, F as FeatureFlag, c as FeatureFlagModel, d as IOrderWorkflowModel, e as IRapidPayload, f as IRefereeModel, g as IAssetInput, h as IValidationTruthModel } from './index-DH4HyFFk.js';
+export { i as types } from './index-DH4HyFFk.js';
+
+type DataType = "text" | "media";
+type JsonObject = Record<string, unknown>;
+declare enum AgeGroup {
+    Age0To17 = "0-17",
+    Age18To29 = "18-29",
+    Age30To39 = "30-39",
+    Age40To49 = "40-49",
+    Age50To64 = "50-64",
+    Age65Plus = "65+"
+}
+declare enum Gender {
+    Male = "Male",
+    Female = "Female",
+    Other = "Other"
+}
+declare enum DeviceType {
+    Unknown = "Unknown",
+    Phone = "Phone",
+    Tablet = "Tablet"
+}
+declare enum TranslationBehaviourOptions {
+    BOTH = "both",
+    ONLY_ORIGINAL = "only original",
+    ONLY_TRANSLATED = "only translated"
+}
+declare enum RapidataRetrievalMode {
+    Shuffled = "Shuffled",
+    Sequential = "Sequential",
+    Random = "Random"
+}
+declare class Datapoint {
+    readonly asset: string | string[];
+    readonly dataType: DataType;
+    readonly context?: string;
+    readonly mediaContext?: string;
+    readonly sentence?: string;
+    readonly privateMetadata?: Record<string, string>;
+    readonly group?: string;
+    constructor(options: {
+        asset: string | string[];
+        dataType: DataType;
+        context?: string;
+        mediaContext?: string;
+        sentence?: string;
+        privateMetadata?: Record<string, string>;
+        group?: string;
+    });
+    getAssetType(): "None" | "Image" | "Video" | "Audio" | "Text";
+    getPromptTypes(): string[];
+}
+declare class Box {
+    readonly xMin: number;
+    readonly yMin: number;
+    readonly xMax: number;
+    readonly yMax: number;
+    constructor(xMin: number, yMin: number, xMax: number, yMax: number);
+    toModel(): {
+        xMin: number;
+        yMin: number;
+        xMax: number;
+        yMax: number;
+    };
+}
+declare class RapidataResults {
+    readonly data: Record<string, unknown>;
+    constructor(data: Record<string, unknown>);
+    toPandas(splitDetails?: boolean): Array<Record<string, unknown>>;
+    toJson(filePath?: string): Promise<void>;
+    private flatten;
+}
+declare abstract class RapidataSetting {
+    readonly key: string;
+    readonly value: unknown;
+    constructor(key: string, value: unknown);
+    toFeatureFlag(): FeatureFlag;
+    toFeatureFlagModel(): FeatureFlagModel;
+}
+declare class AlertOnFastResponseSetting extends RapidataSetting {
+    constructor(threshold: number);
+}
+declare class AlertOnFastResponse extends AlertOnFastResponseSetting {
+}
+declare class TranslationBehaviourSetting extends RapidataSetting {
+    constructor(value: TranslationBehaviourOptions);
+}
+declare class TranslationBehaviour extends TranslationBehaviourSetting {
+}
+declare class FreeTextMinimumCharactersSetting extends RapidataSetting {
+    constructor(value: number);
+}
+declare class FreeTextMinimumCharacters extends FreeTextMinimumCharactersSetting {
+}
+declare class NoShuffleSetting extends RapidataSetting {
+    constructor(value?: boolean);
+}
+declare class NoShuffle extends NoShuffleSetting {
+}
+declare class PlayVideoUntilTheEndSetting extends RapidataSetting {
+    constructor(additionalTime?: number);
+}
+declare class PlayVideoUntilTheEnd extends PlayVideoUntilTheEndSetting {
+}
+declare class MuteVideoSetting extends RapidataSetting {
+    constructor(value?: boolean);
+}
+declare class MuteVideo extends MuteVideoSetting {
+}
+declare class MarkdownSetting extends RapidataSetting {
+    constructor(value?: boolean);
+}
+declare class Markdown extends MarkdownSetting {
+}
+declare class AllowNeitherBothSetting extends RapidataSetting {
+    constructor(value?: boolean);
+}
+declare class AllowNeitherBoth extends AllowNeitherBothSetting {
+}
+declare class SwapContextInstructionSetting extends RapidataSetting {
+    constructor(value?: boolean);
+}
+declare class SwapContextInstruction extends SwapContextInstructionSetting {
+}
+declare class CustomSetting extends RapidataSetting {
+    constructor(key: string, value: string);
+}
+declare class RapidataSettings {
+    static readonly AlertOnFastResponse: typeof AlertOnFastResponseSetting;
+    static readonly TranslationBehaviour: typeof TranslationBehaviourSetting;
+    static readonly FreeTextMinimumCharacters: typeof FreeTextMinimumCharactersSetting;
+    static readonly NoShuffle: typeof NoShuffleSetting;
+    static readonly PlayVideoUntilTheEnd: typeof PlayVideoUntilTheEndSetting;
+    static readonly AllowNeitherBoth: typeof AllowNeitherBothSetting;
+    static readonly SwapContextInstruction: typeof SwapContextInstructionSetting;
+    static readonly MuteVideo: typeof MuteVideoSetting;
+    static readonly Markdown: typeof MarkdownSetting;
+}
+declare abstract class RapidataFilter {
+    abstract toModel(): IUserFilterModel;
+    toAudienceModel(): IAudienceFilter;
+    and(other: RapidataFilter): AndFilter;
+    or(other: RapidataFilter): OrFilter;
+    not(): NotFilter;
+}
+declare class CountryFilter extends RapidataFilter {
+    readonly countryCodes: string[];
+    constructor(countryCodes: string[]);
+    toModel(): IUserFilterModel;
+    toAudienceModel(): IAudienceFilter;
+}
+declare class LanguageFilter extends RapidataFilter {
+    readonly languageCodes: string[];
+    constructor(languageCodes: string[]);
+    toModel(): IUserFilterModel;
+    toAudienceModel(): IAudienceFilter;
+}
+declare class AgeFilter extends RapidataFilter {
+    readonly ageGroups: AgeGroup[];
+    constructor(ageGroups: AgeGroup[]);
+    toModel(): IUserFilterModel;
+}
+declare class GenderFilter extends RapidataFilter {
+    readonly genders: Gender[];
+    constructor(genders: Gender[]);
+    toModel(): IUserFilterModel;
+}
+declare class DeviceFilter extends RapidataFilter {
+    readonly deviceTypes: DeviceType[];
+    constructor(deviceTypes: DeviceType[]);
+    toModel(): IUserFilterModel;
+}
+declare class UserScoreFilter extends RapidataFilter {
+    readonly lowerBound: number;
+    readonly upperBound: number;
+    readonly dimension?: string | undefined;
+    constructor(lowerBound?: number, upperBound?: number, dimension?: string | undefined);
+    toModel(): IUserFilterModel;
+}
+declare class CampaignFilter extends RapidataFilter {
+    readonly campaignIds: string[];
+    constructor(campaignIds: string[]);
+    toModel(): IUserFilterModel;
+}
+declare class CustomFilter extends RapidataFilter {
+    readonly identifier: string;
+    readonly values: string[];
+    constructor(identifier: string, values: string[]);
+    toModel(): IUserFilterModel;
+}
+declare class NotFilter extends RapidataFilter {
+    readonly filter: RapidataFilter;
+    constructor(filter: RapidataFilter);
+    toModel(): IUserFilterModel;
+    toAudienceModel(): IAudienceFilter;
+}
+declare class AndFilter extends RapidataFilter {
+    readonly filters: RapidataFilter[];
+    constructor(filters: RapidataFilter[]);
+    toModel(): IUserFilterModel;
+    toAudienceModel(): IAudienceFilter;
+}
+declare class OrFilter extends RapidataFilter {
+    readonly filters: RapidataFilter[];
+    constructor(filters: RapidataFilter[]);
+    toModel(): IUserFilterModel;
+    toAudienceModel(): IAudienceFilter;
+}
+declare class RapidataFilters {
+    static readonly Country: typeof CountryFilter;
+    static readonly Language: typeof LanguageFilter;
+    static readonly UserScore: typeof UserScoreFilter;
+    static readonly Campaign: typeof CampaignFilter;
+    static readonly Age: typeof AgeFilter;
+    static readonly Gender: typeof GenderFilter;
+    static readonly Custom: typeof CustomFilter;
+    static readonly Device: typeof DeviceFilter;
+    static readonly Not: typeof NotFilter;
+    static readonly Or: typeof OrFilter;
+    static readonly And: typeof AndFilter;
+}
+declare abstract class RapidataSelection {
+    abstract toModel(): ISelection;
+}
+declare class LabelingSelection extends RapidataSelection {
+    readonly amount: number;
+    readonly retrievalMode: RapidataRetrievalMode;
+    readonly maxIterations?: number | undefined;
+    constructor(amount: number, retrievalMode?: RapidataRetrievalMode, maxIterations?: number | undefined);
+    toModel(): ISelection;
+}
+declare class ValidationSelection extends RapidataSelection {
+    readonly validationSetId: string;
+    readonly amount: number;
+    constructor(validationSetId: string, amount?: number);
+    toModel(): ISelection;
+}
+declare class ConditionalValidationSelection extends RapidataSelection {
+    readonly validationSetId: string;
+    readonly thresholds: number[];
+    readonly chances: number[];
+    readonly rapidCounts: number[];
+    readonly dimensions?: string[] | undefined;
+    constructor(validationSetId: string, thresholds: number[], chances: number[], rapidCounts: number[], dimensions?: string[] | undefined);
+    toModel(): ISelection;
+}
+declare class DemographicSelection extends RapidataSelection {
+    readonly keys: string[];
+    readonly maxRapids: number;
+    constructor(keys: string[], maxRapids: number);
+    toModel(): ISelection;
+}
+declare class CappedSelection extends RapidataSelection {
+    readonly selections: RapidataSelection[];
+    readonly maxRapids: number;
+    constructor(selections: RapidataSelection[], maxRapids: number);
+    toModel(): ISelection;
+}
+declare class ShufflingSelection extends RapidataSelection {
+    readonly selections: RapidataSelection[];
+    constructor(selections: RapidataSelection[]);
+    toModel(): ISelection;
+}
+declare class EffortSelection extends RapidataSelection {
+    readonly effortBudget: number;
+    readonly retrievalMode: RapidataRetrievalMode;
+    readonly maxIterations?: number | undefined;
+    constructor(effortBudget: number, retrievalMode?: RapidataRetrievalMode, maxIterations?: number | undefined);
+    toModel(): ISelection;
+}
+declare class StaticSelection extends RapidataSelection {
+    readonly rapidIds: string[];
+    constructor(rapidIds: string[]);
+    toModel(): ISelection;
+}
+declare class AbTestSelection extends RapidataSelection {
+    readonly aSelections: RapidataSelection[];
+    readonly bSelections: RapidataSelection[];
+    constructor(aSelections: RapidataSelection[], bSelections: RapidataSelection[]);
+    toModel(): ISelection;
+}
+declare class RapidataSelections {
+    static readonly Labeling: typeof LabelingSelection;
+    static readonly Validation: typeof ValidationSelection;
+    static readonly ConditionalValidation: typeof ConditionalValidationSelection;
+    static readonly Demographic: typeof DemographicSelection;
+    static readonly Capped: typeof CappedSelection;
+    static readonly Shuffling: typeof ShufflingSelection;
+}
+declare abstract class Referee {
+    abstract toModel(): IRefereeModel;
+}
+declare class NaiveReferee extends Referee {
+    readonly responses: number;
+    constructor(responses?: number);
+    toModel(): IRefereeModel;
+}
+declare class EarlyStoppingReferee extends Referee {
+    readonly threshold: number;
+    readonly maxResponses: number;
+    constructor(threshold?: number, maxResponses?: number);
+    toModel(): IRefereeModel;
+}
+declare class QuorumReferee extends Referee {
+    readonly threshold: number;
+    readonly maxVotes: number;
+    constructor(threshold?: number, maxVotes?: number);
+    toModel(): IRefereeModel;
+}
+declare abstract class Workflow {
+    readonly type: string;
+    constructor(type: string);
+    abstract toModel(): IOrderWorkflowModel;
+    abstract toPayload(datapoint: Datapoint): IRapidPayload;
+    abstract getInstruction(): string;
+}
+declare class ClassifyWorkflow extends Workflow {
+    readonly instruction: string;
+    readonly answerOptions: string[];
+    constructor(instruction: string, answerOptions: string[]);
+    toModel(): IOrderWorkflowModel;
+    toPayload(): IRapidPayload;
+    getInstruction(): string;
+}
+declare class CompareWorkflow extends Workflow {
+    readonly instruction: string;
+    readonly abNames?: string[] | undefined;
+    constructor(instruction: string, abNames?: string[] | undefined);
+    toModel(): IOrderWorkflowModel;
+    toPayload(): IRapidPayload;
+    getInstruction(): string;
+}
+declare class FreeTextWorkflow extends Workflow {
+    readonly instruction: string;
+    readonly validationSystemPrompt?: string | undefined;
+    constructor(instruction: string, validationSystemPrompt?: string | undefined);
+    toModel(): IOrderWorkflowModel;
+    toPayload(): IRapidPayload;
+    getInstruction(): string;
+}
+declare class SelectWordsWorkflow extends Workflow {
+    readonly instruction: string;
+    constructor(instruction: string);
+    toModel(): IOrderWorkflowModel;
+    toPayload(datapoint: Datapoint): IRapidPayload;
+    getInstruction(): string;
+}
+declare class LocateWorkflow extends Workflow {
+    readonly instruction: string;
+    constructor(instruction: string);
+    toModel(): IOrderWorkflowModel;
+    toPayload(): IRapidPayload;
+    getInstruction(): string;
+}
+declare class DrawWorkflow extends Workflow {
+    readonly instruction: string;
+    constructor(instruction: string);
+    toModel(): IOrderWorkflowModel;
+    toPayload(): IRapidPayload;
+    getInstruction(): string;
+}
+declare class TimestampWorkflow extends Workflow {
+    readonly instruction: string;
+    constructor(instruction: string);
+    toModel(): IOrderWorkflowModel;
+    toPayload(): IRapidPayload;
+    getInstruction(): string;
+}
+declare class MultiRankingWorkflow extends Workflow {
+    readonly instruction: string;
+    readonly comparisonBudgetPerRanking: number;
+    readonly randomComparisonsRatio: number;
+    readonly eloStart: number;
+    readonly eloKFactor: number;
+    readonly eloScalingFactor: number;
+    readonly contexts?: Record<string, string> | undefined;
+    readonly mediaContexts?: Record<string, IAssetInput> | undefined;
+    constructor(instruction: string, comparisonBudgetPerRanking: number, randomComparisonsRatio: number, eloStart?: number, eloKFactor?: number, eloScalingFactor?: number, contexts?: Record<string, string> | undefined, mediaContexts?: Record<string, IAssetInput> | undefined);
+    toModel(): IOrderWorkflowModel;
+    toPayload(): IRapidPayload;
+    getInstruction(): string;
+}
+interface ValidationRapid {
+    asset: string | string[];
+    payload: IRapidPayload;
+    dataType: DataType;
+    truth?: IValidationTruthModel;
+    context?: string;
+    mediaContext?: string;
+    sentence?: string;
+    randomCorrectProbability?: number;
+    explanation?: string;
+    settings?: RapidataSetting[];
+}
+declare class RapidsManager {
+    classificationRapid(options: {
+        instruction: string;
+        answerOptions: string[];
+        datapoint: string;
+        truths: string[];
+        dataType?: DataType;
+        context?: string;
+        mediaContext?: string;
+        explanation?: string;
+    }): ValidationRapid;
+    compareRapid(options: {
+        instruction: string;
+        truth: string;
+        datapoint: string[];
+        dataType?: DataType;
+        context?: string;
+        mediaContext?: string;
+        explanation?: string;
+    }): ValidationRapid;
+    selectWordsRapid(options: {
+        instruction: string;
+        truths: number[];
+        datapoint: string;
+        sentence: string;
+        requiredPrecision?: number;
+        requiredCompleteness?: number;
+        explanation?: string;
+    }): ValidationRapid;
+    locateRapid(options: {
+        instruction: string;
+        truths: Box[];
+        datapoint: string;
+        context?: string;
+        mediaContext?: string;
+        explanation?: string;
+    }): ValidationRapid;
+    drawRapid(options: {
+        instruction: string;
+        truths: Box[];
+        datapoint: string;
+        context?: string;
+        mediaContext?: string;
+        explanation?: string;
+    }): ValidationRapid;
+    timestampRapid(options: {
+        instruction: string;
+        truths: Array<[number, number]>;
+        datapoint: string;
+        context?: string;
+        mediaContext?: string;
+        explanation?: string;
+    }): ValidationRapid;
+}
+declare function mapDatapoints(options: {
+    datapoints: Array<string | string[]>;
+    contexts?: string[];
+    mediaContexts?: string[];
+    sentences?: string[];
+    privateMetadata?: Array<Record<string, string>>;
+    groups?: string[];
+    dataType?: DataType;
+    multiAsset?: boolean;
+}): Datapoint[];
+declare function createTextInput(assets: string | string[]): IAssetInput;
+declare function createExistingAssetInput(uploadedNames: string | string[]): IAssetInput;
+
+interface RapidataToken {
+    accessToken?: string;
+    access_token?: string;
+    tokenType?: string;
+    token_type?: string;
+    refreshToken?: string | null;
+    refresh_token?: string | null;
+    expiresIn?: number;
+    expires_in?: number;
+    expiresAt?: number;
+    expires_at?: number;
+    scope?: string | null;
+    obtainedAt?: number;
+}
+interface RapidataApiClientOptions {
+    clientId?: string;
+    clientSecret?: string;
+    environment?: string;
+    oauthScope?: string;
+    certPath?: string;
+    token?: RapidataToken;
+    leeway?: number;
+}
+interface RapidataClientOptions extends RapidataApiClientOptions {
+}
+declare class AssetUploader {
+    private readonly api;
+    private readonly cache;
+    constructor(api: RapidataApiClient);
+    clearCache(): void;
+    createAssetInput(asset: string | string[], dataType: DataType): Promise<IAssetInput>;
+    uploadAsset(asset: string): Promise<string>;
+}
+declare class RapidataApiClient {
+    readonly environment: string;
+    readonly apiBaseUrl: string;
+    readonly authBaseUrl: string;
+    readonly appBaseUrl: string;
+    readonly certPath?: string;
+    private readonly tokenProvider;
+    private readonly services;
+    private readonly credentialManager;
+    private readonly xClientHeader;
+    constructor(options?: RapidataApiClientOptions);
+    get asset(): any;
+    get audience(): any;
+    get benchmark(): any;
+    get campaign(): any;
+    get dataset(): any;
+    get examples(): any;
+    get flow(): any;
+    get identity(): any;
+    get job(): any;
+    get leaderboard(): any;
+    get order(): any;
+    get pipeline(): any;
+    get rapid(): any;
+    get rankingFlow(): any;
+    get rankingFlowItem(): any;
+    get flowItem(): any;
+    get validation(): any;
+    get workflow(): any;
+    getAccessToken(): Promise<string>;
+    getUserInfo(): Promise<Record<string, unknown>>;
+    resetCredentials(): Promise<void>;
+    fetch(url: string, init?: RequestInit): Promise<Response>;
+    private getService;
+    private withGeneratedConfiguration;
+    private getHeaders;
+    private readUnknownBody;
+    private dispatcherPromise?;
+    private getDispatcher;
+}
+type ClientContext = {
+    api: RapidataApiClient;
+    uploader: AssetUploader;
+    ready: Promise<void>;
+    appBaseUrl: string;
+    apiBaseUrl: string;
+};
+declare abstract class BaseEntity {
+    protected readonly context: ClientContext;
+    constructor(context: ClientContext);
+    protected openUrl(url: string): Promise<void>;
+}
+declare class RapidataOrder extends BaseEntity {
+    readonly id: string;
+    readonly name: string;
+    readonly orderDetailsPage: string;
+    createdAt?: Date;
+    pipelineId?: string;
+    campaignId?: string;
+    constructor(id: string, name: string, context: ClientContext, options?: {
+        createdAt?: Date;
+        pipelineId?: string;
+        campaignId?: string;
+    });
+    run(after?: RapidataOrder | string | null): Promise<this>;
+    pause(): Promise<void>;
+    unpause(): Promise<void>;
+    delete(): Promise<void>;
+    getStatus(): Promise<any>;
+    displayProgressBar(refreshRate?: number): Promise<void>;
+    getResults(preliminaryResults?: boolean): Promise<RapidataResults>;
+    view(): Promise<void>;
+    preview(): Promise<this>;
+    private getPreliminaryResults;
+    private getWorkflowProgress;
+    private loadPipelineArtifactIds;
+}
+declare class RapidataJobDefinition extends BaseEntity {
+    readonly id: string;
+    readonly name: string;
+    private readonly jobDetailsPage;
+    constructor(id: string, name: string, context: ClientContext);
+    preview(): Promise<this>;
+    updateDataset(datapoints: string[] | string[][], dataType?: DataType, contexts?: string[], mediaContexts?: string[], sentences?: string[], privateMetadata?: Array<Record<string, string>>): Promise<this>;
+}
+declare class RapidataJob extends BaseEntity {
+    readonly id: string;
+    readonly name: string;
+    readonly audienceId: string;
+    readonly jobDetailsPage: string;
+    completedAt?: Date;
+    pipelineId?: string;
+    constructor(id: string, name: string, audienceId: string, context: ClientContext, options?: {
+        completedAt?: Date;
+        pipelineId?: string;
+    });
+    getStatus(): Promise<any>;
+    getResults(): Promise<RapidataResults>;
+    displayProgressBar(refreshRate?: number): Promise<void>;
+    view(): Promise<void>;
+    private getWorkflowProgress;
+}
+declare class RapidataAudience extends BaseEntity {
+    readonly id: string;
+    private _name;
+    private _filters;
+    constructor(id: string, name: string, filters: IAudienceFilter[], context: ClientContext);
+    get name(): string;
+    get filters(): IAudienceFilter[];
+    updateFilters(filters: RapidataFilter[]): Promise<this>;
+    updateName(name: string): Promise<this>;
+    assignJob(jobDefinition: RapidataJobDefinition | string, options?: {
+        name?: string;
+        priority?: number;
+        revisionNumber?: number;
+    }): Promise<RapidataJob>;
+    addClassificationExample(instruction: string, answerOptions: string[], datapoint: string, truth: string, dataType?: DataType, context?: string, mediaContext?: string, explanation?: string): Promise<this>;
+    addCompareExample(instruction: string, truth: string, datapoint: string[], dataType?: DataType, context?: string, mediaContext?: string, explanation?: string): Promise<this>;
+    findJobs(name?: string, amount?: number): Promise<any>;
+}
+declare class RapidataValidationSet extends BaseEntity {
+    readonly id: string;
+    readonly name: string;
+    readonly dimensions: string[];
+    readonly validationSetDetailsPage: string;
+    constructor(id: string, name: string, dimensions: string[], context: ClientContext);
+    addRapid(rapid: ValidationRapid): Promise<this>;
+    updateDimensions(dimensions: string[]): Promise<this>;
+    updateShouldAlert(shouldAlert: boolean): Promise<this>;
+    updateCanBeFlagged(canBeFlagged: boolean): Promise<this>;
+    view(): Promise<void>;
+    delete(): Promise<void>;
+}
+declare class RapidataFlowItem extends BaseEntity {
+    readonly id: string;
+    readonly flowId: string;
+    constructor(id: string, flowId: string, context: ClientContext);
+    getResults(): Promise<any>;
+    stop(): Promise<void>;
+}
+declare class RapidataFlow extends BaseEntity {
+    readonly id: string;
+    readonly name: string;
+    constructor(id: string, name: string, context: ClientContext);
+    createNewFlowBatch(datapoints: string[] | string[][], contextText?: string, dataType?: DataType, privateMetadata?: Array<Record<string, string>>, acceptFailedUploads?: boolean, timeToLive?: number): Promise<RapidataFlowItem>;
+    getFlowItems(): Promise<any>;
+    updateConfig(instruction?: string, startingElo?: number, kFactor?: number, scalingFactor?: number): Promise<this>;
+    delete(): Promise<void>;
+}
+declare class RapidataOrderManager {
+    private readonly context;
+    constructor(context: ClientContext);
+    createClassificationOrder(name: string, instruction: string, answerOptions: string[], datapoints: string[], dataType?: DataType, responsesPerDatapoint?: number, contexts?: string[], mediaContexts?: string[], validationSetId?: string, confidenceThreshold?: number, quorumThreshold?: number, filters?: RapidataFilter[], settings?: RapidataSetting[], selections?: RapidataSelection[], privateMetadata?: Array<Record<string, string>>): Promise<RapidataOrder>;
+    createCompareOrder(name: string, instruction: string, datapoints: string[][], dataType?: DataType, responsesPerDatapoint?: number, contexts?: string[], mediaContexts?: string[], abNames?: string[], validationSetId?: string, confidenceThreshold?: number, quorumThreshold?: number, filters?: RapidataFilter[], settings?: RapidataSetting[], selections?: RapidataSelection[], privateMetadata?: Array<Record<string, string>>): Promise<RapidataOrder>;
+    createRankingOrder(name: string, instruction: string, datapoints: string[][], comparisonBudgetPerRanking: number, responsesPerComparison?: number, dataType?: DataType, randomComparisonsRatio?: number, contexts?: string[], mediaContexts?: string[], validationSetId?: string, filters?: RapidataFilter[], settings?: RapidataSetting[], selections?: RapidataSelection[]): Promise<RapidataOrder>;
+    createFreeTextOrder(name: string, instruction: string, datapoints: string[], dataType?: DataType, responsesPerDatapoint?: number, contexts?: string[], mediaContexts?: string[], filters?: RapidataFilter[], settings?: RapidataSetting[], selections?: RapidataSelection[], privateMetadata?: Array<Record<string, string>>): Promise<RapidataOrder>;
+    createSelectWordsOrder(name: string, instruction: string, datapoints: string[], sentences: string[], responsesPerDatapoint?: number, mediaContexts?: string[], validationSetId?: string, filters?: RapidataFilter[], settings?: RapidataSetting[], selections?: RapidataSelection[], privateMetadata?: Array<Record<string, string>>): Promise<RapidataOrder>;
+    createLocateOrder(name: string, instruction: string, datapoints: string[], responsesPerDatapoint?: number, contexts?: string[], mediaContexts?: string[], validationSetId?: string, filters?: RapidataFilter[], settings?: RapidataSetting[], selections?: RapidataSelection[], privateMetadata?: Array<Record<string, string>>): Promise<RapidataOrder>;
+    createDrawOrder(name: string, instruction: string, datapoints: string[], responsesPerDatapoint?: number, contexts?: string[], mediaContexts?: string[], validationSetId?: string, filters?: RapidataFilter[], settings?: RapidataSetting[], selections?: RapidataSelection[], privateMetadata?: Array<Record<string, string>>): Promise<RapidataOrder>;
+    createTimestampOrder(name: string, instruction: string, datapoints: string[], responsesPerDatapoint?: number, contexts?: string[], mediaContexts?: string[], validationSetId?: string, filters?: RapidataFilter[], settings?: RapidataSetting[], selections?: RapidataSelection[], privateMetadata?: Array<Record<string, string>>): Promise<RapidataOrder>;
+    getOrderById(orderId: string): Promise<RapidataOrder>;
+    findOrders(name?: string, amount?: number): Promise<any>;
+}
+declare class RapidataAudienceManager {
+    private readonly context;
+    constructor(context: ClientContext);
+    createAudience(name: string, filters?: RapidataFilter[]): Promise<RapidataAudience>;
+    getAudienceById(audienceId: string): Promise<RapidataAudience>;
+    findAudiences(name?: string, amount?: number): Promise<any>;
+}
+declare class RapidataJobManager {
+    private readonly context;
+    constructor(context: ClientContext);
+    createClassificationJobDefinition(name: string, instruction: string, answerOptions: string[], datapoints: string[], dataType?: DataType, responsesPerDatapoint?: number, contexts?: string[], mediaContexts?: string[], confidenceThreshold?: number, quorumThreshold?: number, settings?: RapidataSetting[], privateMetadata?: Array<Record<string, string>>): Promise<RapidataJobDefinition>;
+    createCompareJobDefinition(name: string, instruction: string, datapoints: string[][], dataType?: DataType, responsesPerDatapoint?: number, contexts?: string[], mediaContexts?: string[], abNames?: string[], confidenceThreshold?: number, quorumThreshold?: number, settings?: RapidataSetting[], privateMetadata?: Array<Record<string, string>>): Promise<RapidataJobDefinition>;
+    getJobDefinitionById(jobDefinitionId: string): Promise<RapidataJobDefinition>;
+    findJobDefinitions(name?: string, amount?: number): Promise<any>;
+    getJobById(jobId: string): Promise<RapidataJob>;
+    findJobs(name?: string, amount?: number): Promise<any>;
+}
+declare class ValidationSetManager {
+    private readonly context;
+    readonly rapids: RapidsManager;
+    constructor(context: ClientContext);
+    createClassificationSet(name: string, instruction: string, answerOptions: string[], datapoints: string[], truths: string[][], dataType?: DataType, contexts?: string[], mediaContexts?: string[], explanations?: string[], dimensions?: string[]): Promise<RapidataValidationSet>;
+    createCompareSet(name: string, instruction: string, datapoints: string[][], truths: string[], dataType?: DataType, contexts?: string[], mediaContexts?: string[], explanation?: string, dimensions?: string[]): Promise<RapidataValidationSet>;
+    createSelectWordsSet(name: string, instruction: string, truths: number[][], datapoints: string[], sentences: string[], requiredPrecision?: number, requiredCompleteness?: number, explanation?: string, dimensions?: string[]): Promise<RapidataValidationSet>;
+    createLocateSet(name: string, instruction: string, truths: Box[][], datapoints: string[], contexts?: string[], mediaContexts?: string[], explanation?: string, dimensions?: string[]): Promise<RapidataValidationSet>;
+    createDrawSet(name: string, instruction: string, truths: Box[][], datapoints: string[], contexts?: string[], mediaContexts?: string[], explanation?: string, dimensions?: string[]): Promise<RapidataValidationSet>;
+    createTimestampSet(name: string, instruction: string, truths: Array<Array<[number, number]>>, datapoints: string[], contexts?: string[], mediaContexts?: string[], explanation?: string, dimensions?: string[]): Promise<RapidataValidationSet>;
+    createMixedSet(name: string, rapids: ValidationRapid[], dimensions?: string[]): Promise<RapidataValidationSet>;
+    getValidationSetById(validationSetId: string): Promise<RapidataValidationSet>;
+    findValidationSets(name?: string, amount?: number): Promise<any>;
+}
+declare class RapidataFlowManager {
+    private readonly context;
+    constructor(context: ClientContext);
+    createRankingFlow(name: string, instruction: string, maxResponseThreshold?: number, minResponseThreshold?: number, validationSetId?: string, settings?: RapidataSetting[]): Promise<RapidataFlow>;
+    getFlowById(flowId: string): Promise<RapidataFlow>;
+    findFlows(amount?: number): Promise<any>;
+}
+declare class RapidataBenchmarkManager {
+    readonly api: Pick<RapidataApiClient, "benchmark" | "leaderboard">;
+    constructor(api: Pick<RapidataApiClient, "benchmark" | "leaderboard">);
+}
+declare class RapidataClient {
+    readonly api: RapidataApiClient;
+    readonly order: RapidataOrderManager;
+    readonly validation: ValidationSetManager;
+    readonly flow: RapidataFlowManager;
+    readonly job: RapidataJobManager;
+    readonly mri: RapidataBenchmarkManager;
+    readonly audience: RapidataAudienceManager;
+    private readonly uploader;
+    private readonly context;
+    readonly ready: Promise<void>;
+    constructor(options?: RapidataClientOptions);
+    resetCredentials(): Promise<void>;
+    clearAllCaches(): void;
+    private initialize;
+    private checkBetaFeatures;
+    private checkVersion;
+}
+
+type LogLevel = "debug" | "info" | "warn" | "error";
+interface RapidataRuntimeConfig {
+    enableBetaFeatures: boolean;
+    logging: {
+        level: LogLevel;
+        silentMode: boolean;
+        enableOtlp: boolean;
+    };
+    upload: {
+        cacheToDisk: boolean;
+        cacheLocation: string;
+        maxWorkers: number;
+        batchSize: number;
+        batchPollInterval: number;
+    };
+}
+declare const rapidataConfig: RapidataRuntimeConfig;
+declare const logger: {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+};
+declare function managedPrint(...args: unknown[]): void;
+declare class RapidataTracer {
+    private readonly tracer;
+    private sessionId?;
+    private userInfo?;
+    setSessionId(sessionId: string): void;
+    setUserInfo(userInfo: {
+        clientId?: string;
+        email?: string;
+    }): void;
+    startActiveSpan<T>(name: string, fn: () => Promise<T>): Promise<T>;
+}
+declare const tracer: RapidataTracer;
+
+declare class RapidataError extends Error {
+    readonly statusCode?: number;
+    readonly details?: unknown;
+    readonly originalError?: unknown;
+    constructor(message: string, options?: {
+        statusCode?: number;
+        details?: unknown;
+        originalError?: unknown;
+    });
+}
+declare class FailedUpload<T> {
+    readonly item: T;
+    readonly errorType: string;
+    readonly errorMessage: string;
+    constructor(item: T, errorType: string, errorMessage: string);
+    static fromException<T>(item: T, error: unknown): FailedUpload<T>;
+}
+declare class FailedUploadException<T> extends Error {
+    readonly failedUploads: Array<FailedUpload<T>>;
+    readonly datasetId?: string;
+    readonly orderId?: string;
+    readonly jobDefinitionId?: string;
+    constructor(message: string, options: {
+        failedUploads: Array<FailedUpload<T>>;
+        datasetId?: string;
+        orderId?: string;
+        jobDefinitionId?: string;
+    });
+}
+
+declare const SDK_VERSION = "0.1.0";
+
+export { AbTestSelection, AgeFilter, AgeGroup, AlertOnFastResponse, AlertOnFastResponseSetting, AllowNeitherBoth, AllowNeitherBothSetting, AndFilter, Box, CampaignFilter, CappedSelection, ClassifyWorkflow, CompareWorkflow, ConditionalValidationSelection, CountryFilter, CustomFilter, CustomSetting, type DataType, Datapoint, DemographicSelection, DeviceFilter, DeviceType, DrawWorkflow, EarlyStoppingReferee, EffortSelection, FailedUpload, FailedUploadException, FreeTextMinimumCharacters, FreeTextMinimumCharactersSetting, FreeTextWorkflow, Gender, GenderFilter, type JsonObject, LabelingSelection, LanguageFilter, LocateWorkflow, type LogLevel, Markdown, MarkdownSetting, MultiRankingWorkflow, MuteVideo, MuteVideoSetting, NaiveReferee, NoShuffle, NoShuffleSetting, NotFilter, OrFilter, PlayVideoUntilTheEnd, PlayVideoUntilTheEndSetting, QuorumReferee, RapidataApiClient, RapidataAudience, RapidataAudienceManager, RapidataBenchmarkManager, RapidataClient, RapidataError, RapidataFilters, RapidataFlow, RapidataFlowItem, RapidataFlowManager, RapidataJob, RapidataJobDefinition, RapidataJobManager, RapidataOrder, RapidataOrderManager, RapidataResults, RapidataRetrievalMode, type RapidataRuntimeConfig, RapidataSelection, RapidataSelections, RapidataSetting, RapidataSettings, RapidataValidationSet, RapidsManager, SDK_VERSION, SelectWordsWorkflow, ShufflingSelection, StaticSelection, SwapContextInstruction, SwapContextInstructionSetting, TimestampWorkflow, TranslationBehaviour, TranslationBehaviourOptions, TranslationBehaviourSetting, UserScoreFilter, type ValidationRapid, ValidationSelection, ValidationSetManager, Workflow, createExistingAssetInput, createTextInput, logger, managedPrint, mapDatapoints, rapidataConfig, tracer };