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

package/build/model-training/index.js

@@ -21,13 +21,29 @@ class ModelTrainingApi extends BaseApi {
         return await this.post(`${resourceName}/run`, data);
     }
     /**
-     * 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
      */
     async trainClassifier(data) {
-        return await this.post(`${resourceName}/train-classifier`, data);
+        return await this.post(`v1/${resourceName}/train-classifier`, data);
     }
 }
 export { ModelTrainingApi, };

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

@@ -1,3 +1,4 @@
+import type { components } from "../generated/api-types";
 import type { ModelCollaborators } from "../models/types";
 export interface OutputModel {
     name: string;
@@ -34,11 +35,73 @@ export interface ModelTrainingConfig {
     /** Free-form JSON override merged into the generated Axolotl config (Scala `Option[Json]`). */
     custom_axolotl_config_override?: Record<string, unknown>;
 }
-export interface TrainClassifierRequest {
-    config: Record<string, unknown>;
-    data_plane_id: string;
-    tags: string[];
+/**
+ * Free-form settings passed straight through to the training procedure, which
+ * validates them.
+ *
+ * The backend types every one of these as a bare `Json`, which the spec writes
+ * as `type: object` and the generator renders as `Record<string, never>` — a
+ * type no object literal satisfies, so a caller could not fill one in. Widened
+ * here so `{ type: "random_forest", n_estimators: 200 }` compiles.
+ */
+export type ClassifierSettings = Record<string, unknown>;
+/** Fields every feature shares. */
+interface FeatureInputBase {
+    /**
+     * Column the feature is read from: either a plain column name or a path into
+     * a variant column, e.g. `data['merchant']`. Must exist in the dataset's
+     * schema, spelled exactly as it appears there.
+     */
+    field_path: string;
+    /** Unique within the request. Alphanumerics and underscores only. */
+    name: string;
 }
-export interface TrainClassifierResponse {
-    job_id: string;
+export interface CategoricalFeatureInput extends FeatureInputBase {
+    feature_type: "categorical";
+    /** The only variant that reads `field_type` — the others fix it themselves. */
+    field_type: "boolean" | "number" | "string";
+    /** Encoding settings, e.g. `{ max_categories: 100 }`. */
+    categorical?: ClassifierSettings;
+    /** Preprocessing applied before encoding. */
+    preprocess?: ClassifierSettings[];
+}
+export interface EmbeddingFeatureInput extends FeatureInputBase {
+    feature_type: "embedding";
+    /** e.g. `{ model: "e5-base-v2" }`. */
+    embedding?: ClassifierSettings;
 }
+export interface NumericFeatureInput extends FeatureInputBase {
+    feature_type: "numeric";
+    /** e.g. `{ scaler: "standard" }`. */
+    numeric?: ClassifierSettings;
+}
+export interface TextFeatureInput extends FeatureInputBase {
+    feature_type: "text";
+    /** e.g. `{ max_features: 10000 }`. */
+    tfidf?: ClassifierSettings;
+}
+/**
+ * How one column is encoded for training, discriminated on `feature_type`.
+ *
+ * Hand-written rather than aliased. The backend models this as a sealed trait
+ * with four variants, each carrying its own settings key, and only
+ * `categorical` reads `field_type` — the other three fix it (`array`, `number`,
+ * `string`) and ignore whatever is sent. The spec flattens all four into one
+ * object with every key optional, which describes none of them: it would accept
+ * a `text` feature carrying `numeric` settings, and reject nothing that matters.
+ */
+export type FeatureInput = CategoricalFeatureInput | EmbeddingFeatureInput | NumericFeatureInput | TextFeatureInput;
+/**
+ * Body of `POST /v1/model-training/train-classifier`.
+ *
+ * Aliased from the generated schema except for `feature_inputs` and `model`.
+ * The backend takes a `NonEmptyList[FeatureInput]`, so the tuple below turns an
+ * empty array into a compile error rather than a 400.
+ */
+export type TrainClassifierRequest = Omit<components["schemas"]["TrainClassifierRequest"], "feature_inputs" | "model"> & {
+    feature_inputs: [FeatureInput, ...FeatureInput[]];
+    /** Classifier hyperparameters. Defaults to logistic regression. */
+    model?: ClassifierSettings;
+};
+export type TrainClassifierResponse = components["schemas"]["TrainClassifierResponse"];
+export {};

package/build/nql/index.d.ts

@@ -1,6 +1,6 @@
 import { BaseApi } from "../base-api";
 import type { NqlAst } from "./Ast";
-import type { Nql, NqlBooleanExpression, NqlCompileResult, NqlExpression, NqlField, NqlFilterBinaryExpression, NqlFilterExpression, NqlFilterUnaryExpression, NqlQueryInput, NqlResult, NqlWhere } from "./types";
+import type { Nql, NqlBooleanExpression, NqlCompileResult, NqlExecuteRequest, NqlExecuteResponse, NqlExpression, NqlField, NqlFilterBinaryExpression, NqlFilterExpression, NqlFilterUnaryExpression, NqlQueryInput, NqlResult, NqlWhere } from "./types";
 /**
  * A class for accessing the NQL API.
  * @extends BaseApi
@@ -9,10 +9,36 @@ declare class NqlApi extends BaseApi {
     /**
      * Executes an NQL query and returns the result.
      *
+     * @deprecated The API deprecates `POST nql/run` in favour of
+     * {@link NqlApi.executeNqlStatement}, which posts to `v1/nql/execute`. The
+     * two are not drop-in equivalents: the replacement returns a workflow and a
+     * run id rather than a query result, so callers poll the run instead of
+     * reading rows off the response. `nql/run` still works, and the API will
+     * announce its removal separately.
+     *
      * @param {string} nqlQuery - The NQL query to execute.
      * @returns {Promise<NqlResult>} A promise that resolves with the result of the NQL query.
+     * @see https://docs.narrative.io/reference/deprecations/nql-run
+     * @see https://docs.narrative.io/api-reference/nql/run-a-nql-query
      */
     executeNql(payload: NqlQueryInput): Promise<NqlResult>;
+    /**
+     * Runs a mutating NQL statement as a workflow.
+     *
+     * Distinct from {@link NqlApi.executeNql}, which posts to `nql/run` and hands
+     * back a query result. This one accepts `INSERT`, `UPDATE`, `DELETE`,
+     * `EXPLAIN` and `CREATE MATERIALIZED VIEW`, compiles the statement into a
+     * workflow, starts a run, and returns both. Nothing here says the statement
+     * succeeded — poll the run for that.
+     *
+     * @param {NqlExecuteRequest} payload - The statement, and optionally the data
+     * plane, compute pool, and `create_as_view` flag.
+     * @returns {Promise<NqlExecuteResponse>} The created workflow and its run id.
+     * Rejects with 400 if the statement fails to compile or is a kind this
+     * endpoint cannot run.
+     * @see https://docs.narrative.io/api-reference/nql/execute-an-nql-statement
+     */
+    executeNqlStatement(payload: NqlExecuteRequest): Promise<NqlExecuteResponse>;
     /**
      * Compiles an NQL query and returns the result, including any errors.
      *
@@ -46,4 +72,4 @@ declare class NqlApi extends BaseApi {
 export * from "./Ast";
 export * from "./AstParser";
 export * from "./NqlBuilder";
-export { type Nql, NqlApi, type NqlBooleanExpression, type NqlCompileResult, type NqlExpression, type NqlField, type NqlFilterBinaryExpression, type NqlFilterExpression, type NqlFilterUnaryExpression, type NqlQueryInput, type NqlResult, type NqlWhere, };
+export { type Nql, NqlApi, type NqlBooleanExpression, type NqlCompileResult, type NqlExecuteRequest, type NqlExecuteResponse, type NqlExpression, type NqlField, type NqlFilterBinaryExpression, type NqlFilterExpression, type NqlFilterUnaryExpression, type NqlQueryInput, type NqlResult, type NqlWhere, };

package/build/nql/index.js

@@ -15,13 +15,41 @@ class NqlApi extends BaseApi {
     /**
      * Executes an NQL query and returns the result.
      *
+     * @deprecated The API deprecates `POST nql/run` in favour of
+     * {@link NqlApi.executeNqlStatement}, which posts to `v1/nql/execute`. The
+     * two are not drop-in equivalents: the replacement returns a workflow and a
+     * run id rather than a query result, so callers poll the run instead of
+     * reading rows off the response. `nql/run` still works, and the API will
+     * announce its removal separately.
+     *
      * @param {string} nqlQuery - The NQL query to execute.
      * @returns {Promise<NqlResult>} A promise that resolves with the result of the NQL query.
+     * @see https://docs.narrative.io/reference/deprecations/nql-run
+     * @see https://docs.narrative.io/api-reference/nql/run-a-nql-query
      */
     async executeNql(payload) {
         const response = await this.post(`${resourceName}/run`, payload);
         return response;
     }
+    /**
+     * Runs a mutating NQL statement as a workflow.
+     *
+     * Distinct from {@link NqlApi.executeNql}, which posts to `nql/run` and hands
+     * back a query result. This one accepts `INSERT`, `UPDATE`, `DELETE`,
+     * `EXPLAIN` and `CREATE MATERIALIZED VIEW`, compiles the statement into a
+     * workflow, starts a run, and returns both. Nothing here says the statement
+     * succeeded — poll the run for that.
+     *
+     * @param {NqlExecuteRequest} payload - The statement, and optionally the data
+     * plane, compute pool, and `create_as_view` flag.
+     * @returns {Promise<NqlExecuteResponse>} The created workflow and its run id.
+     * Rejects with 400 if the statement fails to compile or is a kind this
+     * endpoint cannot run.
+     * @see https://docs.narrative.io/api-reference/nql/execute-an-nql-statement
+     */
+    async executeNqlStatement(payload) {
+        return await this.post("v1/nql/execute", payload);
+    }
     /**
      * Compiles an NQL query and returns the result, including any errors.
      *

package/build/nql/types.d.ts

@@ -6,6 +6,7 @@
  */
 import { z } from "zod";
 import type { Dataset } from "../datasets/types";
+import type { components } from "../generated/api-types";
 /**
  * Defines the structure for a budget object.
  *
@@ -109,9 +110,9 @@ export declare const NqlFilterBinaryExpressionObj: z.ZodObject<{
         ">=": ">=";
         "<=": "<=";
         "=": "=";
-        "!=": "!=";
         IN: "IN";
         "NOT IN": "NOT IN";
+        "!=": "!=";
         LIKE: "LIKE";
         "NOT LIKE": "NOT LIKE";
     }>;
@@ -149,9 +150,9 @@ export declare const NqlFilterExpressionObj: z.ZodUnion<readonly [z.ZodObject<{
         ">=": ">=";
         "<=": "<=";
         "=": "=";
-        "!=": "!=";
         IN: "IN";
         "NOT IN": "NOT IN";
+        "!=": "!=";
         LIKE: "LIKE";
         "NOT LIKE": "NOT LIKE";
     }>;
@@ -200,9 +201,9 @@ export declare const NqlWhereObj: z.ZodObject<{
             ">=": ">=";
             "<=": "<=";
             "=": "=";
-            "!=": "!=";
             IN: "IN";
             "NOT IN": "NOT IN";
+            "!=": "!=";
             LIKE: "LIKE";
             "NOT LIKE": "NOT LIKE";
         }>;
@@ -263,9 +264,9 @@ export declare const NqlObj: z.ZodObject<{
                 ">=": ">=";
                 "<=": "<=";
                 "=": "=";
-                "!=": "!=";
                 IN: "IN";
                 "NOT IN": "NOT IN";
+                "!=": "!=";
                 LIKE: "LIKE";
                 "NOT LIKE": "NOT LIKE";
             }>;
@@ -405,4 +406,15 @@ export interface AstNodeMetadata {
     node_type: AstNodeType;
     version?: string;
 }
+/**
+ * Body of `POST /v1/nql/execute`. `create_as_view` applies only to
+ * `CREATE MATERIALIZED VIEW` and is ignored for every other statement.
+ */
+export type NqlExecuteRequest = components["schemas"]["ExecuteRequest"];
+/**
+ * What `POST /v1/nql/execute` returns: the workflow the statement was compiled
+ * into, plus the id of the run started for it. Poll the run to find out whether
+ * the statement succeeded — the response only says the work was accepted.
+ */
+export type NqlExecuteResponse = components["schemas"]["CreateWorkflowResponseWithRunId"];
 export {};

package/build/rosetta/types.d.ts

@@ -1,9 +1,9 @@
 import z from "zod";
 declare const ChatCompletionRequestMessageRoleEnum: z.ZodEnum<{
     function: "function";
-    system: "system";
     user: "user";
     assistant: "assistant";
+    system: "system";
 }>;
 type ConversationMessageRole = z.infer<typeof ChatCompletionRequestMessageRoleEnum>;
 declare const isConversationMessageRole: (input: unknown) => input is ConversationMessageRole;

package/build/testing/fixtures/data-planes.d.ts

@@ -1,10 +1,29 @@
-import type { DataPlaneOwnedResponse, JobResponse } from "../types";
+import type { DataPlaneOwnedResponse, DataPlaneSharedResponse, JobResponse } from "../types";
 /**
  * An owned, active data plane. Every field the spec requires is filled in, so a
  * caller only overrides what its assertion is about. The optional fields are
  * present and `null`, which is what the API sends for an absent value — a mock
  * that omitted them would let a consumer assert `undefined` and still pass.
  */
-export declare function createDataPlane(overrides?: Partial<DataPlaneOwnedResponse>): DataPlaneOwnedResponse;
-/** The job a health check enqueues, pending and not yet attempted. */
+export declare function createOwnedDataPlane(overrides?: Partial<DataPlaneOwnedResponse>): DataPlaneOwnedResponse;
+/**
+ * A data plane shared with the calling company, active, on AWS. Shared planes
+ * belong to someone else, so this one carries a different `company_id` and id
+ * than {@link createOwnedDataPlane} — seeding both gives you two records.
+ *
+ * Optional fields are present and `null` for the same reason as on the owned
+ * factory. For the other platform the API serves, override it:
+ *
+ * ```ts
+ * createSharedDataPlane({
+ *   platform: { type: "platform_shared_snowflake", region: null },
+ * });
+ * ```
+ */
+export declare function createSharedDataPlane(overrides?: Partial<DataPlaneSharedResponse>): DataPlaneSharedResponse;
+/**
+ * The job a health check enqueues, still pending. A pending job has no result
+ * and no end timestamp, so both are `null` here — the same thing the API sends
+ * before the job reaches a terminal state.
+ */
 export declare function createHealthCheckJob(overrides?: Partial<JobResponse>): JobResponse;

package/build/testing/fixtures/data-planes.js

@@ -5,7 +5,7 @@ const TIMESTAMP = "2026-01-01T00:00:00Z";
  * present and `null`, which is what the API sends for an absent value — a mock
  * that omitted them would let a consumer assert `undefined` and still pass.
  */
-export function createDataPlane(overrides = {}) {
+export function createOwnedDataPlane(overrides = {}) {
     return {
         type: "owned",
         id: "5f9d1a4e-0000-4000-8000-000000000001",
@@ -32,25 +32,70 @@ export function createDataPlane(overrides = {}) {
         ...overrides,
     };
 }
-/** The job a health check enqueues, pending and not yet attempted. */
+/**
+ * A data plane shared with the calling company, active, on AWS. Shared planes
+ * belong to someone else, so this one carries a different `company_id` and id
+ * than {@link createOwnedDataPlane} — seeding both gives you two records.
+ *
+ * Optional fields are present and `null` for the same reason as on the owned
+ * factory. For the other platform the API serves, override it:
+ *
+ * ```ts
+ * createSharedDataPlane({
+ *   platform: { type: "platform_shared_snowflake", region: null },
+ * });
+ * ```
+ */
+export function createSharedDataPlane(overrides = {}) {
+    return {
+        type: "shared",
+        id: "5f9d1a4e-0000-4000-8000-000000000002",
+        company_id: 2,
+        created_at: TIMESTAMP,
+        display_name: "Test Shared Data Plane",
+        platform: {
+            type: "platform_shared_aws",
+            region: { type: "region_aws", id: "us-east-1" },
+        },
+        status: "active",
+        updated_at: TIMESTAMP,
+        compute_pools: [],
+        description: null,
+        tags: null,
+        last_heartbeat_at: null,
+        default_compute_pool_id: null,
+        ...overrides,
+    };
+}
+/**
+ * The job a health check enqueues, still pending. A pending job has no result
+ * and no end timestamp, so both are `null` here — the same thing the API sends
+ * before the job reaches a terminal state.
+ */
 export function createHealthCheckJob(overrides = {}) {
     return {
         job_id: "5f9d1a4e-0000-4000-8000-00000000000a",
+        company_id: 1,
         data_plane_id: "5f9d1a4e-0000-4000-8000-000000000001",
+        compute_pool_id: null,
         request_source: { type: "api_user", company_id: 1, user_id: 1 },
         state: "pending",
-        type: "data-plane-health-check",
+        type: "health_check",
+        operator_type: "health-check",
+        tags: [],
         input: {},
-        executor: "job-executor-test",
+        executor: null,
         execution_cluster: "dedicated",
-        failures: [],
         idempotency_key: "test-idempotency-key",
-        result: {},
+        result: null,
+        dequeued_at: null,
         created_at: TIMESTAMP,
         updated_at: TIMESTAMP,
         attempted_at: TIMESTAMP,
         attempt_version: 1,
-        ended_at: TIMESTAMP,
+        ended_at: null,
+        workflow_id: null,
+        workflow_run_id: null,
         ...overrides,
     };
 }

package/build/testing/fixtures/derivations.d.ts

@@ -0,0 +1,18 @@
+import type { DerivationResponse } from "../types";
+/**
+ * An active derivation rule hashing a raw email into a hashed one — the
+ * worked example the spec uses. Every field the spec requires is filled in, so
+ * a caller only overrides what its assertion is about.
+ *
+ * `warnings` is empty and `fidelity_note` is `null`, which is what a read
+ * returns: list and get do not compute warnings, and an absent note arrives as
+ * an explicit `null` rather than being omitted. For a create or update
+ * response, override `warnings`:
+ *
+ * ```ts
+ * createDerivation({
+ *   warnings: [{ type: "cyclic_derivation", cycle: [1, 2] }],
+ * });
+ * ```
+ */
+export declare function createDerivation(overrides?: Partial<DerivationResponse>): DerivationResponse;

package/build/testing/fixtures/derivations.js

@@ -0,0 +1,43 @@
+const TIMESTAMP = "2026-01-01T00:00:00Z";
+/**
+ * An active derivation rule hashing a raw email into a hashed one — the
+ * worked example the spec uses. Every field the spec requires is filled in, so
+ * a caller only overrides what its assertion is about.
+ *
+ * `warnings` is empty and `fidelity_note` is `null`, which is what a read
+ * returns: list and get do not compute warnings, and an absent note arrives as
+ * an explicit `null` rather than being omitted. For a create or update
+ * response, override `warnings`:
+ *
+ * ```ts
+ * createDerivation({
+ *   warnings: [{ type: "cyclic_derivation", cycle: [1, 2] }],
+ * });
+ * ```
+ */
+export function createDerivation(overrides = {}) {
+    return {
+        id: 1,
+        name: "raw_email_to_sha256_hashed_email",
+        description: "Hashes a raw email address with SHA-256.",
+        source_attribute_id: 10,
+        target_attribute_id: 11,
+        company_id: 1,
+        collaborators: { use: { type: "none" } },
+        mapping: {
+            type: "value_mapping",
+            expression: "SHA2(NORMALIZE_EMAIL($source.value), 256)",
+        },
+        lossy: true,
+        imprecise: false,
+        fidelity_note: null,
+        cost: 1,
+        active: true,
+        created_at: TIMESTAMP,
+        created_by: 1,
+        updated_at: TIMESTAMP,
+        updated_by: 1,
+        warnings: [],
+        ...overrides,
+    };
+}

package/build/testing/fixtures/index.d.ts

@@ -1 +1,5 @@
-export { createDataPlane, createHealthCheckJob } from "./data-planes";
+export { createHealthCheckJob, createOwnedDataPlane, createSharedDataPlane, } from "./data-planes";
+export { createDerivation } from "./derivations";
+export { createCollectAccessRulesBillingDataJob, createDatasetsCalculateAffectedRowsJob, createDatasetsCalculateColumnStatsJob, createDatasetsCreateTableJob, createDatasetsDeleteTableJob, createDatasetsDeliverDataJob, createDatasetsEnforceRowTtlRetentionPolicyJob, createDatasetsEnforceTableTtlRetentionPolicyJob, createDatasetsExecuteDmlJob, createDatasetsSampleJob, createDatasetsTruncateTableJob, createMaterializeViewJob, createModelInferenceRunJob, createModelsDeliverModelJob, createModelsTrainClassifierJob, createModelTrainingRunJob, createNqlForecastJob, createOtherJob, } from "./jobs";
+export { createTrainClassifierResponse } from "./model-training";
+export { createNqlExecutionResponse } from "./nql";

package/build/testing/fixtures/index.js

@@ -1 +1,5 @@
-export { createDataPlane, createHealthCheckJob } from "./data-planes";
+export { createHealthCheckJob, createOwnedDataPlane, createSharedDataPlane, } from "./data-planes";
+export { createDerivation } from "./derivations";
+export { createCollectAccessRulesBillingDataJob, createDatasetsCalculateAffectedRowsJob, createDatasetsCalculateColumnStatsJob, createDatasetsCreateTableJob, createDatasetsDeleteTableJob, createDatasetsDeliverDataJob, createDatasetsEnforceRowTtlRetentionPolicyJob, createDatasetsEnforceTableTtlRetentionPolicyJob, createDatasetsExecuteDmlJob, createDatasetsSampleJob, createDatasetsTruncateTableJob, createMaterializeViewJob, createModelInferenceRunJob, createModelsDeliverModelJob, createModelsTrainClassifierJob, createModelTrainingRunJob, createNqlForecastJob, createOtherJob, } from "./jobs";
+export { createTrainClassifierResponse } from "./model-training";
+export { createNqlExecutionResponse } from "./nql";

package/build/testing/fixtures/jobs.d.ts

@@ -0,0 +1,75 @@
+import type { CollectAccessRulesBillingDataJobResponse, DatasetsCalculateAffectedRowsJobResponse, DatasetsCalculateColumnStatsJobResponse, DatasetsCreateTableJobResponse, DatasetsDeleteTableJobResponse, DatasetsDeliverDataJobResponse, DatasetsEnforceRowTtlRetentionPolicyJobResponse, DatasetsEnforceTableTtlRetentionPolicyJobResponse, DatasetsExecuteDmlJobResponse, DatasetsSampleJobResponse, DatasetsTruncateTableJobResponse, MaterializeViewJobResponse, ModelInferenceRunJobResponse, ModelsDeliverModelJobResponse, ModelsTrainClassifierJobResponse, ModelTrainingRunJobResponse, NqlForecastJobResponse, OtherJobResponse } from "../types";
+/** Refreshes a materialized view into its target dataset. */
+export declare function createMaterializeViewJob(overrides?: Partial<MaterializeViewJobResponse>): MaterializeViewJobResponse;
+/**
+ * Estimates what a query would return and what it would cost. The result is a
+ * sum type: this one succeeds, and the failure branch is
+ * `{ failure: { msg: "…" } }`.
+ */
+export declare function createNqlForecastJob(overrides?: Partial<NqlForecastJobResponse>): NqlForecastJobResponse;
+/** Reads a sample of rows. The rows are stored separately, so only the count comes back. */
+export declare function createDatasetsSampleJob(overrides?: Partial<DatasetsSampleJobResponse>): DatasetsSampleJobResponse;
+/**
+ * Computes per-column statistics. This one carries the V1 input, which names
+ * the columns and the statistics to collect for each. The V2 input hands the
+ * operator pre-compiled SQL instead: `{ dataset_id, compiled_sql }`.
+ */
+export declare function createDatasetsCalculateColumnStatsJob(overrides?: Partial<DatasetsCalculateColumnStatsJobResponse>): DatasetsCalculateColumnStatsJobResponse;
+/** Bills a materialized-view refresh, per access rule it read from. */
+export declare function createCollectAccessRulesBillingDataJob(overrides?: Partial<CollectAccessRulesBillingDataJobResponse>): CollectAccessRulesBillingDataJobResponse;
+/** Delivers a dataset snapshot to a connected app. One job per connection. */
+export declare function createDatasetsDeliverDataJob(overrides?: Partial<DatasetsDeliverDataJobResponse>): DatasetsDeliverDataJobResponse;
+/**
+ * Runs one inference call against a model on the data plane.
+ *
+ * `structured_output`, `output_format_schema`, and the tool argument fields are
+ * empty here rather than carrying a payload: the spec types them as an object
+ * with no properties, so no value satisfies them.
+ */
+export declare function createModelInferenceRunJob(overrides?: Partial<ModelInferenceRunJobResponse>): ModelInferenceRunJobResponse;
+/** Drops a dataset's underlying table. */
+export declare function createDatasetsDeleteTableJob(overrides?: Partial<DatasetsDeleteTableJobResponse>): DatasetsDeleteTableJobResponse;
+/** Runs an NQL `DELETE` or `UPDATE` against a dataset. */
+export declare function createDatasetsExecuteDmlJob(overrides?: Partial<DatasetsExecuteDmlJobResponse>): DatasetsExecuteDmlJobResponse;
+/** Creates a dataset's underlying table. */
+export declare function createDatasetsCreateTableJob(overrides?: Partial<DatasetsCreateTableJobResponse>): DatasetsCreateTableJobResponse;
+/** Empties a dataset's table, leaving the table itself in place. */
+export declare function createDatasetsTruncateTableJob(overrides?: Partial<DatasetsTruncateTableJobResponse>): DatasetsTruncateTableJobResponse;
+/** Drops a table that has outlived its TTL retention policy. */
+export declare function createDatasetsEnforceTableTtlRetentionPolicyJob(overrides?: Partial<DatasetsEnforceTableTtlRetentionPolicyJobResponse>): DatasetsEnforceTableTtlRetentionPolicyJobResponse;
+/** Deletes rows that have outlived their TTL retention policy. */
+export declare function createDatasetsEnforceRowTtlRetentionPolicyJob(overrides?: Partial<DatasetsEnforceRowTtlRetentionPolicyJobResponse>): DatasetsEnforceRowTtlRetentionPolicyJobResponse;
+/**
+ * Counts how many rows a pending statement would touch. The result carries the
+ * type of the operator that produced it rather than the job's own.
+ *
+ * The API returns the count at `rows[0].values.affected_rows`, which this
+ * fixture cannot express: the spec types `values` as an object with no
+ * properties, so `{}` is the only value that satisfies it. A test asserting on
+ * a count needs to cast the row.
+ */
+export declare function createDatasetsCalculateAffectedRowsJob(overrides?: Partial<DatasetsCalculateAffectedRowsJobResponse>): DatasetsCalculateAffectedRowsJobResponse;
+/**
+ * Fine-tunes a base model and publishes the result. The API stores this job's
+ * result exactly as the training operator posted it, so the spec gives it no
+ * shape and the fixture leaves it null.
+ */
+export declare function createModelTrainingRunJob(overrides?: Partial<ModelTrainingRunJobResponse>): ModelTrainingRunJobResponse;
+/** Delivers a trained model to a connected app. */
+export declare function createModelsDeliverModelJob(overrides?: Partial<ModelsDeliverModelJobResponse>): ModelsDeliverModelJobResponse;
+/**
+ * Trains a classifier. Both `input` and `result` are free-form on the wire, so
+ * the defaults here are illustrative rather than a contract.
+ */
+export declare function createModelsTrainClassifierJob(overrides?: Partial<ModelsTrainClassifierJobResponse>): ModelsTrainClassifierJobResponse;
+/**
+ * A job of a type the spec has no branch for, where `input` and `result` stay
+ * free-form. This is what a job type added after the spec was generated decodes
+ * as. The default is `datasets_execute_select`, a type the backend really runs
+ * and the spec does not describe.
+ *
+ * Undescribed by the spec is not the same as unknown to the SDK: the root entry
+ * point's `isKnownJob` still recognises this default. Override `type` to get a
+ * job neither one knows.
+ */
+export declare function createOtherJob(overrides?: Partial<OtherJobResponse>): OtherJobResponse;