@narrative.io/data-collaboration-sdk-ts 4.4.0 → 4.5.0

package/build/generated/api-types.js

@@ -2,7 +2,7 @@
  * GENERATED FILE — DO NOT EDIT.
  *
  * Source: https://docs-cdn.narrative.io/api-reference/main/openapi.json
- * Spec etag: W/"1b05b0fe6188a5d59c67bbde3678af08"
+ * Spec etag: W/"b4c876661400c5ac03697ec6dde62625"
  *
  * Regenerate with: bun run generate:api-types
  */

package/build/http-client.d.ts

@@ -83,6 +83,7 @@ export declare class HttpClient {
     get<T>(url: string): Promise<T>;
     post<T>(url: string, data?: unknown): Promise<T>;
     put<T>(url: string, data?: unknown): Promise<T>;
+    patch<T>(url: string, data?: unknown): Promise<T>;
     delete<T>(url: string): Promise<T>;
     private request;
     /**

package/build/http-client.js

@@ -66,6 +66,9 @@ export class HttpClient {
     async put(url, data) {
         return this.request("PUT", url, data);
     }
+    async patch(url, data) {
+        return this.request("PATCH", url, data);
+    }
     async delete(url) {
         return this.request("DELETE", url);
     }

package/build/index.d.ts

@@ -19,6 +19,8 @@ export * from "./data-streams";
 export * from "./datasets";
 export * from "./datasets/statistics-types";
 export * from "./datasets/types";
+export * from "./derivations";
+export * from "./derivations/types";
 export * from "./encryption-materials";
 export * from "./encryption-materials/types";
 export * from "./forecast";
@@ -73,6 +75,7 @@ import { ContractsApi } from "./contracts";
 import { DataPlaneApi } from "./data-planes";
 import { DataStreamsApi } from "./data-streams";
 import { DatasetApi } from "./datasets";
+import { DerivationsApi } from "./derivations";
 import { EncryptionMaterialApi } from "./encryption-materials";
 import { ForecastApi } from "./forecast";
 import { HealthCheckApi } from "./health";
@@ -95,6 +98,6 @@ import { WhoAmIApi } from "./whoami";
 import { WorkflowsApi } from "./workflows";
 declare class NarrativeApi extends BaseApi {
 }
-interface NarrativeApi extends BaseApi, HealthCheckApi, AccessTokensApi, DataPlaneApi, DatasetApi, RosettaStoneApi, AttributeApi, AttributeApiV2, PingApi, CompanyInfoApi, InstallationsApi, ConnectionsApi, UploadsApi, ResourceApi, NqlApi, DataStreamsApi, ForecastApi, ContractsApi, AuthenticationApi, MappingsApi, AccessRulesApi, AppsApi, SubscriptionsApi, JobsApi, QueriesApi, ViewsApi, ModelsApi, ModelTrainingApi, ModelInferenceApi, EncryptionMaterialApi, WhoAmIApi, WorkflowsApi, ComputePoolsApi, AgentsApi, CompaniesApi, McpConnectionsApi {
+interface NarrativeApi extends BaseApi, HealthCheckApi, AccessTokensApi, DataPlaneApi, DatasetApi, RosettaStoneApi, AttributeApi, AttributeApiV2, PingApi, CompanyInfoApi, InstallationsApi, ConnectionsApi, UploadsApi, ResourceApi, NqlApi, DataStreamsApi, ForecastApi, ContractsApi, AuthenticationApi, MappingsApi, AccessRulesApi, AppsApi, SubscriptionsApi, JobsApi, QueriesApi, ViewsApi, ModelsApi, ModelTrainingApi, ModelInferenceApi, EncryptionMaterialApi, WhoAmIApi, WorkflowsApi, ComputePoolsApi, AgentsApi, CompaniesApi, McpConnectionsApi, DerivationsApi {
 }
 export { NarrativeApi };

package/build/index.js

@@ -19,6 +19,8 @@ export * from "./data-streams";
 export * from "./datasets";
 export * from "./datasets/statistics-types";
 export * from "./datasets/types";
+export * from "./derivations";
+export * from "./derivations/types";
 export * from "./encryption-materials";
 export * from "./encryption-materials/types";
 export * from "./forecast";
@@ -74,6 +76,7 @@ import { ContractsApi } from "./contracts";
 import { DataPlaneApi } from "./data-planes";
 import { DataStreamsApi } from "./data-streams";
 import { DatasetApi } from "./datasets";
+import { DerivationsApi } from "./derivations";
 import { EncryptionMaterialApi } from "./encryption-materials";
 import { ForecastApi } from "./forecast";
 import { HealthCheckApi } from "./health";
@@ -134,5 +137,6 @@ applyMixins(NarrativeApi, [
     AgentsApi,
     CompaniesApi,
     McpConnectionsApi,
+    DerivationsApi,
 ]);
 export { NarrativeApi };

package/build/jobs/types.d.ts

@@ -1,14 +1,14 @@
-import type { ForecastResult, JobState } from "../forecast";
+import type { ForecastResult } from "../forecast";
 import type { DataStreamPurchaseDetails, ForecastDimensions, MarketplaceForecastDetails } from "../forecast/types";
-import type { NqlBudget } from "../nql/types";
+import type { components } from "../generated/api-types";
 /**
- * Every job type the backend can persist and return from the /jobs API.
- * The backend's `Job.Type` is an open string, so treat this list as the
- * known set rather than a closed enum — see {@link UnknownJob}.
+ * Every job type the backend can persist and return from the /jobs API. The
+ * backend's job type is an open string, so this is the known set rather than a
+ * closed enum. Anything outside it arrives as an {@link UnknownJob}.
  */
 export declare const KNOWN_JOB_TYPES: readonly ["forecast", "forecast-internal", "nql-forecast", "costs", "materialize-view", "materialized_views_collect_access_rules_billing_data", "datasets_calculate_affected_rows", "datasets_calculate_column_stats", "datasets_create_table", "datasets_delete_table", "datasets_deliver_data", "datasets_enforce_row_ttl_retention_policy", "datasets_enforce_table_ttl_retention_policy", "datasets_execute_dml", "datasets_execute_select", "datasets_sample", "datasets_suggest_mappings", "datasets_truncate_table", "health_check", "model_inference_run", "model_training_run", "models_deliver_model", "models_train_classifier"];
 export type JobType = (typeof KNOWN_JOB_TYPES)[number];
-export type JobExecutionCluster = "shared" | "dedicated";
+export type JobExecutionCluster = components["schemas"]["ExecutionClusterType"];
 export interface JobRequestSourceApiUser {
     type: "api_user";
     company_id: number;
@@ -18,371 +18,171 @@ export interface JobRequestSourceProcess {
     type: "process";
     name: string;
 }
+/**
+ * What asked for the job: a user calling the API, or an internal process
+ * running on its own.
+ *
+ * This is the one field the SDK does not take from the spec. The spec describes
+ * `request_source` as three independently optional fields, which covers both
+ * shapes at once, narrows to neither, and has no `name` at all. The backend
+ * models it as a closed sum type, so the union below is what actually arrives.
+ */
 export type JobRequestSource = JobRequestSourceApiUser | JobRequestSourceProcess;
-interface BaseJob {
-    job_id: string;
-    type: JobType;
-    company_id: number;
+/** Swaps the spec's `request_source` for {@link JobRequestSource}. */
+type WithRequestSource<J> = Omit<J, "request_source"> & {
     request_source: JobRequestSource;
-    data_plane_id?: string;
-    compute_pool_id?: string;
-    state: JobState;
-    execution_cluster: JobExecutionCluster;
-    /**
-     * The job type actually executed on the data plane. Multiple business-level
-     * types (e.g. `datasets_calculate_affected_rows`, `datasets_sample`) can map
-     * to a single operator type (`datasets_execute_select`); otherwise it equals
-     * `type`.
-     */
-    operator_type: string;
-    executor?: string;
-    idempotency_key: string;
-    created_at: string;
-    updated_at: string;
-    attempted_at: string;
-    attempt_version: number;
-    ended_at?: string;
-    tags?: string[];
-    dequeued_at?: string;
-}
+};
+/**
+ * Swaps a branch's `result` for a shape the SDK describes and the spec leaves
+ * free-form.
+ */
+type WithResult<J, R> = Omit<J, "result"> & {
+    result: R | null;
+};
+/**
+ * The fields every job carries, whatever its type. Each branch below adds
+ * `type`, `input`, and `result` on top of these.
+ *
+ * `operator_type` is finer-grained than `type`: several job types can share one
+ * operator, so `datasets_calculate_affected_rows` and `datasets_sample` both
+ * run as `datasets_execute_select`. Where no operator of its own exists, it
+ * equals `type`.
+ */
+type BaseJob = WithRequestSource<components["schemas"]["JobBase"]>;
+export type ExplainInput = components["schemas"]["NqlForecastJobInput"];
+/**
+ * The forecast, or the reason it could not be produced. Exactly one of
+ * `success` / `failure` is present; the absent branch is not sent as null.
+ */
+export type ExplainOutput = components["schemas"]["NqlForecastJobResult"];
+export type ExplainJob = WithRequestSource<components["schemas"]["NqlForecastJobResponse"]>;
+export type MaterializedViewInput = components["schemas"]["MaterializeViewJobInput"];
+export type MaterializedViewRowStats = components["schemas"]["MaterializeViewJobRowStats"];
+/** What a data plane reports after refreshing a view. */
+export type RefreshMaterializedViewResult = components["schemas"]["MaterializeViewJobResult"];
+/**
+ * @deprecated The forecast-shaped result the Spark executor produced. The spec
+ * attributes this shape to `nql-forecast` rather than to `materialize-view`, so
+ * read it through {@link ExplainOutput} instead.
+ */
+export type MaterializedViewOutput = components["schemas"]["NqlForecastJobSuccess"];
+export type MaterializedViewJob = WithRequestSource<components["schemas"]["MaterializeViewJobResponse"]>;
+export type CollectAccessRulesBillingDataInput = components["schemas"]["CollectAccessRulesBillingDataJobInput"];
+export type CollectAccessRulesBillingDataResult = components["schemas"]["CollectAccessRulesBillingDataJobResult"];
+export type CollectAccessRulesBillingDataJob = WithRequestSource<components["schemas"]["CollectAccessRulesBillingDataJobResponse"]>;
+export type CalculateAffectedRowsInput = components["schemas"]["DatasetsCalculateAffectedRowsJobInput"];
+export type CalculateAffectedRowsJob = WithRequestSource<components["schemas"]["DatasetsCalculateAffectedRowsJobResponse"]>;
+export type CreateTableInput = components["schemas"]["DatasetsCreateTableJobInput"];
+export type DatasetsCreateTableJob = WithRequestSource<components["schemas"]["DatasetsCreateTableJobResponse"]>;
+export type TruncateTableInput = components["schemas"]["DatasetsTruncateTableJobInput"];
+export type DatasetsTruncateTableJob = WithRequestSource<components["schemas"]["DatasetsTruncateTableJobResponse"]>;
+export type DeleteInput = components["schemas"]["DatasetsDeleteTableJobInput"];
+export type DeleteResult = components["schemas"]["DatasetsDeleteTableJobResult"];
+export type DatasetsDeleteTableJob = WithRequestSource<components["schemas"]["DatasetsDeleteTableJobResponse"]>;
+export type DeliverInput = components["schemas"]["DatasetsDeliverDataJobInput"];
+export type DeliverResult = components["schemas"]["DatasetsDeliverDataJobResult"];
+export type DatasetsDeliverDataJob = WithRequestSource<components["schemas"]["DatasetsDeliverDataJobResponse"]>;
+export type EnforceRowTtlRetentionPolicyInput = components["schemas"]["DatasetsEnforceRowTtlRetentionPolicyJobInput"];
+export type DatasetsEnforceRowTtlRetentionPolicyJob = WithRequestSource<components["schemas"]["DatasetsEnforceRowTtlRetentionPolicyJobResponse"]>;
+export type EnforceTableTtlRetentionPolicyInput = components["schemas"]["DatasetsEnforceTableTtlRetentionPolicyJobInput"];
+export type DatasetsEnforceTableTtlRetentionPolicyJob = WithRequestSource<components["schemas"]["DatasetsEnforceTableTtlRetentionPolicyJobResponse"]>;
+export type ExecuteDmlInput = components["schemas"]["DatasetsExecuteDmlJobInput"];
+export type ExecuteDmlResult = components["schemas"]["DatasetsExecuteDmlJobResult"];
+export type DatasetsExecuteDmlJob = WithRequestSource<components["schemas"]["DatasetsExecuteDmlJobResponse"]>;
+export type SampleInput = components["schemas"]["DatasetsSampleJobInput"];
+export type SampleResult = components["schemas"]["DatasetsSampleJobResult"];
+export type DatasetsSampleJob = WithRequestSource<components["schemas"]["DatasetsSampleJobResponse"]>;
+/**
+ * The column types the statistics job reports. The spec types `data_type` as a
+ * plain string so an unrecognised type still decodes, which is why
+ * {@link ColumnDetails} does not use this union.
+ */
+export type ColumnStatDataType = "boolean" | "double" | "long" | "string" | "timestamp_tz" | "array" | "object";
+export type EnabledColumnStatFlags = components["schemas"]["DatasetsCalculateColumnStatsFlags"];
+export type ColumnDetails = components["schemas"]["DatasetsCalculateColumnStatsColumnDetails"];
+export type StatsInput = components["schemas"]["DatasetsCalculateColumnStatsJobInputV1"];
+export type StatsInputV2 = components["schemas"]["DatasetsCalculateColumnStatsJobInputV2"];
+export type StatsResult = components["schemas"]["DatasetsCalculateColumnStatsJobResult"];
+export type DatasetsCalculateColumnStatsJob = WithRequestSource<components["schemas"]["DatasetsCalculateColumnStatsJobResponse"]>;
+export type HealthCheckJob = WithRequestSource<components["schemas"]["HealthCheckJobResponse"]>;
+export type ModelInferenceRunInput = components["schemas"]["ModelInferenceRunJobInput"];
+export type ModelInferenceRunJobResult = components["schemas"]["ModelInferenceRunJobResult"];
+export type ModelInferenceRunJob = WithRequestSource<components["schemas"]["ModelInferenceRunJobResponse"]>;
+export type ModelTrainingRunInput = components["schemas"]["ModelTrainingRunJobInput"];
+/** Whatever the training operator posted on completion. The API stores it as
+ * sent rather than reshaping it, so it has no fixed shape. */
+export type ModelTrainingRunResult = components["schemas"]["JobResult"];
+export type ModelTrainingRunJob = WithRequestSource<components["schemas"]["ModelTrainingRunJobResponse"]>;
+export type ModelsDeliverModelInput = components["schemas"]["ModelsDeliverModelJobInput"];
+/** Whatever the delivery operator posted on completion. */
+export type ModelsDeliverModelResult = components["schemas"]["JobResult"];
+export type ModelsDeliverModelJob = WithRequestSource<components["schemas"]["ModelsDeliverModelJobResponse"]>;
+/**
+ * The spec leaves this job's `result` free-form because it never passes through
+ * a typed class in the marketplace. {@link ModelsTrainClassifierResults} is the
+ * SDK's own description of what the training operator actually posts, so the
+ * result keeps that shape rather than widening to `unknown`.
+ */
+export type ModelsTrainClassifierJob = WithResult<WithRequestSource<components["schemas"]["ModelsTrainClassifierJobResponse"]>, ModelsTrainClassifierResults>;
 export interface ForecastInput {
     as_of?: string;
     dimensions: ForecastDimensions;
     fingerprint?: string;
     details: MarketplaceForecastDetails | DataStreamPurchaseDetails;
 }
-export interface ForecastJob extends BaseJob {
+export type ForecastJob = BaseJob & {
     type: "forecast";
     input: ForecastInput;
-    result?: ForecastResult;
-}
-export interface ForecastInternalJob extends BaseJob {
+    result: ForecastResult | null;
+};
+export type ForecastInternalJob = BaseJob & {
     type: "forecast-internal";
     input: ForecastInput;
-    result?: ForecastResult;
-}
-export interface ExplainInput {
-    nql: string;
-    compiled_nql: string;
-    dataset_id: number;
-}
-export interface ExplainOutput {
-    dataset_id: number;
-}
-export interface ExplainJob extends BaseJob {
-    type: "nql-forecast";
-    input: ExplainInput;
-    result?: ExplainOutput;
-}
+    result: ForecastResult | null;
+};
 export interface CostsInput {
     as_of?: string;
     /** Subscription purchase details; shape mirrors the marketplace subscription model. */
     details: unknown;
 }
-export interface CostsJob extends BaseJob {
+export type CostsJob = BaseJob & {
     type: "costs";
     input: CostsInput;
-    result?: unknown;
-}
-export interface MaterializedViewInput {
-    nql: string;
-    compiled_nql: string;
-    budget: NqlBudget;
-    dataset_id: number;
-    stats_enabled: boolean;
-    chunk_metadata?: {
-        batch_id: string;
-        chunk_sequence: {
-            number: number;
-            of: number;
-        };
-    };
-}
-export interface MaterializedViewRowStats {
-    affected_rows: number;
-    inserted_rows: number;
-    updated_rows: number;
-    deleted_rows: number;
-}
-/** Result shape reported by data planes completing a refresh. */
-export interface RefreshMaterializedViewResult {
-    type: "refresh_materialized_view";
-    snapshot_id: string;
-    row_stats?: MaterializedViewRowStats;
-}
-/** Legacy result shape produced by the Spark executor. */
-export interface MaterializedViewOutput {
-    success: {
-        result: {
-            Forecast: {
-                cost: number;
-                rows: number;
-            };
-        };
-    };
-}
-export interface MaterializedViewJob extends BaseJob {
-    type: "materialize-view";
-    input: MaterializedViewInput;
-    result?: MaterializedViewOutput | RefreshMaterializedViewResult;
-}
-export interface CollectAccessRulesBillingDataInput {
-    dataset_id?: number;
-    nio_last_modified_at: string;
-    compiled_query: string;
-    refresh_job_id: string;
-}
-export interface CollectAccessRulesBillingDataResult {
-    sources: Array<{
-        access_rule_id: number;
-        rows: number;
-        price_per_row: unknown;
-    }>;
-}
-export interface CollectAccessRulesBillingDataJob extends BaseJob {
-    type: "materialized_views_collect_access_rules_billing_data";
-    input: CollectAccessRulesBillingDataInput;
-    result?: CollectAccessRulesBillingDataResult;
-}
-export interface CalculateAffectedRowsInput {
-    dataset_id: number;
-    compiled_sql: string;
-}
-export interface CalculateAffectedRowsJob extends BaseJob {
-    type: "datasets_calculate_affected_rows";
-    input: CalculateAffectedRowsInput;
-    /** Runs on the `datasets_execute_select` operator, so the stored result is select-shaped. */
-    result?: ExecuteSelectResult;
-}
-export interface CreateTableInput {
-    dataset_id: number;
-    compiled_sql: string;
-}
-export interface DatasetsCreateTableJob extends BaseJob {
-    type: "datasets_create_table";
-    input: CreateTableInput;
-    result?: unknown;
-}
-export interface TruncateTableInput {
-    dataset_id: number;
-}
-export interface DatasetsTruncateTableJob extends BaseJob {
-    type: "datasets_truncate_table";
-    input: TruncateTableInput;
-    result?: unknown;
-}
-export interface DeleteInput {
-    external_id: string;
-    is_narrative_managed?: boolean;
-}
-export type DeleteResult = unknown;
-export interface DatasetsDeleteTableJob extends BaseJob {
-    type: "datasets_delete_table";
-    input: DeleteInput;
-    result?: DeleteResult;
-}
-export interface DeliverInput {
-    app_id?: string;
-    connection_id?: string;
-    dataset_id: number;
-    external_id: string;
-    snapshot_id?: string;
-    maintenance_window_predicate?: string;
-}
-export type DeliverResult = unknown;
-export interface DatasetsDeliverDataJob extends BaseJob {
-    type: "datasets_deliver_data";
-    input: DeliverInput;
-    result?: DeliverResult;
-}
-export interface EnforceRowTtlRetentionPolicyInput {
-    dataset_id: number;
-    sql: string[];
-}
-export interface DatasetsEnforceRowTtlRetentionPolicyJob extends BaseJob {
-    type: "datasets_enforce_row_ttl_retention_policy";
-    input: EnforceRowTtlRetentionPolicyInput;
-    result?: unknown;
-}
-export interface EnforceTableTtlRetentionPolicyInput {
-    dataset_id: number;
-    dataset_external_id?: string;
-}
-export interface DatasetsEnforceTableTtlRetentionPolicyJob extends BaseJob {
-    type: "datasets_enforce_table_ttl_retention_policy";
-    input: EnforceTableTtlRetentionPolicyInput;
-    result?: unknown;
-}
-export interface ExecuteDmlInput {
-    dataset_id: number;
-    nql: string;
-    compiled_sql: string;
-    nio_last_modified_at?: string;
-}
-export interface ExecuteDmlResult {
-    affected_rows: number;
-    inserted_rows: number;
-    updated_rows: number;
-    deleted_rows: number;
-}
-export interface DatasetsExecuteDmlJob extends BaseJob {
-    type: "datasets_execute_dml";
-    input: ExecuteDmlInput;
-    result?: ExecuteDmlResult;
-}
+    result: unknown;
+};
 export interface ExecuteSelectInput {
     compiled_sql: string;
 }
-export interface ExecuteSelectResult {
-    rows: Array<{
-        values: Record<string, unknown>;
-    }>;
-}
-export interface DatasetsExecuteSelectJob extends BaseJob {
+/**
+ * The operator's raw SELECT output. Jobs that read a single value out of a
+ * query carry this rather than a field of their own, so
+ * {@link CalculateAffectedRowsJob} finds its count at
+ * `rows[0].values.affected_rows`.
+ */
+export type ExecuteSelectResult = components["schemas"]["DatasetsCalculateAffectedRowsJobResult"];
+export type DatasetsExecuteSelectJob = BaseJob & {
     type: "datasets_execute_select";
     input: ExecuteSelectInput;
-    result?: ExecuteSelectResult;
-}
-export interface SampleInput {
-    dataset_id: number;
-}
-export type SampleResult = unknown;
-export interface DatasetsSampleJob extends BaseJob {
-    type: "datasets_sample";
-    input: SampleInput;
-    result?: SampleResult;
-}
+    result: ExecuteSelectResult | null;
+};
 export interface SuggestMappingsInput {
     dataset_id: number;
 }
 export interface SuggestMappingsResult {
     result: string;
 }
-export interface DatasetsSuggestMappingsJob extends BaseJob {
+export type DatasetsSuggestMappingsJob = BaseJob & {
     type: "datasets_suggest_mappings";
     input: SuggestMappingsInput;
-    result?: SuggestMappingsResult;
-}
-export type ColumnStatDataType = "boolean" | "double" | "long" | "string" | "timestamp_tz" | "array" | "object";
-export interface EnabledColumnStatFlags {
-    nan_value_count: boolean;
-    null_value_count: boolean;
-    value_count: boolean;
-    lower_bound: boolean;
-    upper_bound: boolean;
-    column_stored_bytes: boolean;
-    approx_count_distinct: boolean;
-    count_distinct: boolean;
-    histogram: boolean;
-    mean: boolean;
-    standard_deviation: boolean;
-    completeness: boolean;
-    observed_types: boolean;
-}
-export interface ColumnDetails {
-    data_type: ColumnStatDataType;
-    enabled_column_stats: EnabledColumnStatFlags;
-}
-export interface StatsInput {
-    dataset_id: number;
-    enabled_column_stats?: Record<string, ColumnDetails>;
-}
-/** V2 input ships pre-compiled SQL instead of a column configuration. */
-export interface StatsInputV2 {
-    dataset_id: number;
-    compiled_sql: string;
-}
-export type StatsResult = unknown;
-export interface DatasetsCalculateColumnStatsJob extends BaseJob {
-    type: "datasets_calculate_column_stats";
-    input: StatsInput | StatsInputV2;
-    result?: StatsResult;
-}
-export interface HealthCheckJob extends BaseJob {
-    type: "health_check";
-    input: unknown;
-    /** Compute pool health check report. */
-    result?: unknown;
-}
-export interface ModelTrainingRunInput {
-    company_id: number;
-    connections?: unknown[];
-    custom_axolotl_config_override?: unknown;
-    dataset_id: number;
-    instance_type: string;
-    base_model_id: string;
-    base_model_repository: string;
-    base_model_repo_id: string;
-    trained_model_narrative_repository_model_id: string;
-    trained_model_narrative_repo_id: string;
-    trained_model_version: string;
-    trained_model: unknown;
-}
-export type ModelTrainingRunResult = unknown;
-export interface ModelTrainingRunJob extends BaseJob {
-    type: "model_training_run";
-    input: ModelTrainingRunInput;
-    result?: ModelTrainingRunResult;
-}
-export interface ModelsDeliverModelInput {
-    company_id: number;
-    app_id: string;
-    connection_id: string;
-    profile_id: string;
-    model_id: string;
-    model_name: string;
-    model_version: string;
-    quick_settings?: unknown;
-}
-export type ModelsDeliverModelResult = unknown;
-export interface ModelsDeliverModelJob extends BaseJob {
-    type: "models_deliver_model";
-    input: ModelsDeliverModelInput;
-    result?: ModelsDeliverModelResult;
-}
-export interface ModelsTrainClassifierJob extends BaseJob {
-    type: "models_train_classifier";
-    input: unknown;
-    result?: ModelsTrainClassifierResults;
-}
-export interface ModelInferenceRunInput {
-    model: string;
-    messages: Array<{
-        role: string;
-        text: string;
-    }>;
-    inference_config: {
-        output_format_schema: Record<string, unknown>;
-        max_tokens?: number | null;
-        temperature?: number | null;
-        top_p?: number | null;
-        stop_sequences?: string[] | null;
-    };
-}
-export interface ModelInferenceRunJobResult {
-    usage: {
-        total_tokens: number;
-        prompt_tokens: number;
-        completion_tokens: number;
-    };
-    structured_output?: unknown;
-    tool_calls?: unknown[];
-    stop_reason?: string;
-}
-export interface ModelInferenceRunJob extends BaseJob {
-    type: "model_inference_run";
-    input: ModelInferenceRunInput;
-    result?: ModelInferenceRunJobResult;
-}
+    result: SuggestMappingsResult | null;
+};
 /**
- * Fallback for job types the SDK does not know about yet — the backend's
- * job type is an open string, so new types can appear without an SDK release.
+ * A job whose type the SDK does not know about. The backend's job type is an
+ * open string and it stores `input` and `result` as arbitrary JSON, so a type
+ * added after an SDK release lands here rather than failing to parse. Read
+ * `type` to find out what arrived.
  */
-export interface UnknownJob extends Omit<BaseJob, "type"> {
-    type: string;
-    input: unknown;
-    result?: unknown;
-}
+export type UnknownJob = WithRequestSource<components["schemas"]["OtherJobResponse"]>;
 /** Discriminated union over every job type the SDK knows about. */
 export type KnownJob = ForecastJob | ForecastInternalJob | ExplainJob | CostsJob | MaterializedViewJob | CollectAccessRulesBillingDataJob | CalculateAffectedRowsJob | DatasetsCalculateColumnStatsJob | DatasetsCreateTableJob | DatasetsDeleteTableJob | DatasetsDeliverDataJob | DatasetsEnforceRowTtlRetentionPolicyJob | DatasetsEnforceTableTtlRetentionPolicyJob | DatasetsExecuteDmlJob | DatasetsExecuteSelectJob | DatasetsSampleJob | DatasetsSuggestMappingsJob | DatasetsTruncateTableJob | HealthCheckJob | ModelInferenceRunJob | ModelTrainingRunJob | ModelsDeliverModelJob | ModelsTrainClassifierJob;
 export type Job = KnownJob | UnknownJob;

package/build/jobs/types.js

@@ -1,7 +1,7 @@
 /**
- * Every job type the backend can persist and return from the /jobs API.
- * The backend's `Job.Type` is an open string, so treat this list as the
- * known set rather than a closed enum — see {@link UnknownJob}.
+ * Every job type the backend can persist and return from the /jobs API. The
+ * backend's job type is an open string, so this is the known set rather than a
+ * closed enum. Anything outside it arrives as an {@link UnknownJob}.
  */
 export const KNOWN_JOB_TYPES = [
     "forecast",

package/build/model-training/index.d.ts

@@ -1,5 +1,5 @@
 import { BaseApi } from "../base-api";
-import type { ModelTrainingConfig, OutputModel, TrainClassifierRequest, TrainClassifierResponse, TrainModelRequest, TrainModelResponse } from "./types";
+import type { CategoricalFeatureInput, ClassifierSettings, EmbeddingFeatureInput, FeatureInput, ModelTrainingConfig, NewModelConnection, NumericFeatureInput, OutputModel, TextFeatureInput, TrainClassifierRequest, TrainClassifierResponse, TrainModelRequest, TrainModelResponse } from "./types";
 /**
  * A class for accessing the Model Training API.
  * @extends BaseApi
@@ -13,11 +13,27 @@ declare class ModelTrainingApi extends BaseApi {
      */
     trainModel(data: TrainModelRequest): Promise<TrainModelResponse>;
     /**
-     * Trains a classifier model.
+     * Trains a text classifier on a dataset. Only datasets on Snowflake data
+     * planes are supported.
      *
-     * @param {TrainClassifierRequest} data - The data for the classifier training.
-     * @returns {Promise<TrainClassifierResponse>} A promise that resolves with the classifier training response.
+     * The training data is named by `dataset_id` and the backing table resolved
+     * server-side, so the caller never handles it. Every column reference —
+     * `label_column`, `id_column`, and each feature's `field_path` — is checked
+     * against the dataset's schema before the job is created.
+     *
+     * This posts to `v1/model-training/train-classifier`. The unversioned
+     * endpoint still exists but is deprecated: it took the training table as an
+     * opaque `config` blob and validated none of it.
+     *
+     * @param {TrainClassifierRequest} data - The dataset, features and classifier
+     * settings to train with.
+     * @returns {Promise<TrainClassifierResponse>} The id of the created job. Poll
+     * the jobs API for status and results. Rejects with 400 if a name is not a
+     * valid identifier, a column reference is not in the dataset's schema, or the
+     * dataset is not materialized on a Snowflake data plane; 403 if the dataset
+     * is reachable but owned by another company.
+     * @see https://docs.narrative.io/api-reference/model-training/train-a-classifier
      */
     trainClassifier(data: TrainClassifierRequest): Promise<TrainClassifierResponse>;
 }
-export { ModelTrainingApi, type ModelTrainingConfig, type OutputModel, type TrainClassifierRequest, type TrainClassifierResponse, type TrainModelRequest, type TrainModelResponse, };
+export { type CategoricalFeatureInput, type ClassifierSettings, type EmbeddingFeatureInput, type FeatureInput, ModelTrainingApi, type ModelTrainingConfig, type NewModelConnection, type NumericFeatureInput, type OutputModel, type TextFeatureInput, type TrainClassifierRequest, type TrainClassifierResponse, type TrainModelRequest, type TrainModelResponse, };