@narrative.io/data-collaboration-sdk-ts 2.95.0-beta.0 → 2.95.0

package/build/collaboration-policy/types/collaboration-policy.js

@@ -0,0 +1,274 @@
+import * as z from "zod/v4";
+/** Branded types */
+const CollaborationPolicyIdentifier = z
+    .string()
+    .regex(/^[a-zA-Z0-9_-]+$/)
+    .brand("CollaborationPolicyId")
+    .meta({
+    id: "collaboration_policy_identifier",
+});
+/**
+ * Refresh Schedule Schema
+ *
+ * Specifies how often the destination should be refreshed to ensure data doesn't expire.
+ * This is the maximum time interval allowed between destination updates. Waiting longer
+ * than this duration may result in the destination expiring data that should be retained.
+ *
+ * Uses ISO 8601 duration format (e.g., "PT1H" for 1 hour, "P1D" for 1 day).
+ * Supported values:
+ * - PT1H: Hourly (1 hour)
+ * - P1D: Daily (1 day)
+ * - P7D: Weekly (7 days)
+ * - P1M: Monthly (1 month)
+ * - P0D: Once (no recurring refresh)
+ * - Custom ISO 8601 duration strings (e.g., "PT30M" for 30 minutes, "P2W" for 2 weeks)
+ */
+const RefreshScheduleSchema = z
+    .object({
+    max: z
+        .string()
+        .regex(/^P(?!$)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?$/, "Invalid ISO 8601 duration format. Expected format like 'PT1H' (1 hour), 'P1D' (1 day), 'P7D' (7 days), 'P1M' (1 month), or 'P0D' (once)"),
+})
+    .strict()
+    .meta({
+    id: "refresh_schedule",
+});
+const CollaborationPolicyDefinitionMetadataSchema = z
+    .object({
+    tags: z.array(z.string().regex(/^[a-zA-Z0-9_-]+$/)).optional(),
+    refresh_schedule: RefreshScheduleSchema.optional(),
+})
+    .meta({ id: "metadata" });
+const JsonPointerSchema = z
+    .string()
+    .regex(/^(#\/|\/).+/, 'JSON Pointer must start with "/" or "#/".')
+    .meta({ id: "json-pointer" });
+/** Path can be dot-style or JSON Pointer */
+const PathSchema = z
+    .union([
+    z
+        .object({
+        dot: z.string().min(1, "Dot path cannot be empty"),
+    })
+        .strict(),
+    z
+        .object({
+        pointer: JsonPointerSchema,
+    })
+        .strict(),
+])
+    .meta({ id: "path" });
+/** ---------------------------
+ *  Base + contextual variants
+ *  --------------------------*/
+/**
+ * BaseAttributeRef:
+ * - supports either `attribute_name` (by name) OR `attribute` (by pointer), not both
+ * - includes both `additional_required_properties` and `path` (context will prune)
+ */
+const BaseAttributeRef = z
+    .object({
+    type: z.literal("attribute").meta({ id: "field_type" }),
+    // Choose ONE of these identifiers:
+    attribute_name: z.string().meta({ id: "attribute_name" }),
+    // Context-specific fields (trim in the derived schemas):
+    additional_required_properties: z
+        .array(PathSchema)
+        .optional()
+        .meta({ id: "additional_required_properties" }),
+    path: PathSchema.optional(),
+})
+    .strict()
+    .meta({ id: "attribute_reference" });
+/**
+ * StructureAttributeRef:
+ * - used in your “structure” (the logical tree)
+ * - allows: attribute_name + additional_required_properties
+ * - forbids: path, attribute (pointer)
+ * Example target:
+ * field: {
+ *   type: "attribute",
+ *   attribute_name: "sha256_hashed_email",
+ *   additional_required_properties: [{ dot: "type" }],
+ * }
+ */
+const StructureAttributeRef = BaseAttributeRef.omit({
+    path: true,
+}).meta({ id: "structure_attribute_reference" });
+/**
+ * FilterAttributeRef:
+ * - used inside filters
+ * - allows: attribute (pointer) + optional path
+ * - forbids: additional_required_properties, attribute_name
+ * Example target:
+ * left: {
+ *   type: "attribute",
+ *   attribute: "https://api.narrative.io/attributes/iso_3166_1_country",
+ *   path: { dot: "value" },
+ * }
+ */
+const FilterAttributeRef = BaseAttributeRef.omit({
+    additional_required_properties: true,
+}).meta({ id: "filter_attribute_reference" });
+// Now Expression can reference Filter without a lazy;
+// the recursive bits inside Filter are handled by getters.
+const Expression = z
+    .union([
+    z
+        .string()
+        .refine((s) => !s.startsWith("https://api.narrative.io/attributes/"), "String expression cannot be a JSON pointer; use { type:'attribute', attribute: ... }"),
+    z.number(),
+    z.boolean(),
+    FilterAttributeRef,
+])
+    .meta({ id: "expression" });
+const FilterAndOr = z
+    .object({
+    op: z.enum(["and", "or"]),
+    stage: z.literal("generation").default("generation"),
+    name: z.string().optional(),
+    required: z.boolean().default(true),
+    get args() {
+        return z.array(Expression).min(2);
+    },
+})
+    .strict();
+const FilterNot = z
+    .object({
+    op: z.literal("not"),
+    stage: z.literal("generation").default("generation"),
+    name: z.string().optional(),
+    required: z.boolean().default(true),
+    get args() {
+        return z.array(Expression).length(1);
+    },
+})
+    .strict();
+const FilterIsNull = z
+    .object({
+    op: z.enum(["is_null", "is_not_null"]),
+    stage: z.literal("generation").default("generation"),
+    name: z.string().optional(),
+    required: z.boolean().default(true),
+    get left() {
+        return Expression;
+    },
+})
+    .strict();
+const FilterIn = z
+    .object({
+    op: z.enum(["in", "not in"]),
+    stage: z.literal("generation").default("generation"),
+    name: z.string().optional(),
+    required: z.boolean().default(true),
+    get left() {
+        return Expression;
+    },
+    get right() {
+        return z.array(Expression).min(1);
+    },
+})
+    .strict();
+const FilterCompare = z
+    .object({
+    op: z.enum(["=", "<>", ">", ">=", "<", "<=", "like", "not like"]),
+    stage: z.literal("generation").default("generation"),
+    name: z.string().optional(),
+    required: z.boolean().default(true),
+    get left() {
+        return Expression;
+    },
+    get right() {
+        return Expression;
+    },
+})
+    .strict();
+const FilterBetween = z
+    .object({
+    op: z.literal("between"),
+    stage: z.literal("generation").default("generation"),
+    name: z.string().optional(),
+    required: z.boolean().default(true),
+    get operand() {
+        return Expression;
+    },
+    get lower() {
+        return Expression;
+    },
+    get upper() {
+        return Expression;
+    },
+})
+    .strict();
+const Filter = z
+    .union([
+    FilterAndOr,
+    FilterNot,
+    FilterIsNull,
+    FilterIn,
+    FilterCompare,
+    FilterBetween,
+])
+    .meta({ id: "filter" });
+const logicalTree = (leaf) => {
+    const NodeSchema = z.lazy(() => z
+        .union([
+        z
+            .object({
+            anyOf: z
+                .array(z.union([leaf, NodeSchema]))
+                .min(1)
+                .meta({ id: "any_of" }),
+        })
+            .strict()
+            .meta({ id: "any_of_object" }),
+        z
+            .object({
+            allOf: z
+                .array(z.union([leaf, NodeSchema]))
+                .min(1)
+                .meta({ id: "all_of" }),
+        })
+            .strict()
+            .meta({ id: "all_of_object" }),
+    ])
+        .meta({ id: "logical_node" }));
+    // Top-level can be a leaf T or a logical node.
+    return z.union([leaf, NodeSchema]).meta({ id: "logical_tree" });
+};
+const ExtendedAttribute = z
+    .object({
+    field: StructureAttributeRef,
+    filters: z.array(Filter).optional(),
+})
+    .meta({ id: "extended_attribute" });
+const CollaborationPolicyDefinitionShape = z
+    .object({
+    id: CollaborationPolicyIdentifier,
+    structure: logicalTree(ExtendedAttribute).meta({ id: "structure" }),
+    filters: z.array(Filter).optional(),
+})
+    .meta({ id: "shape" });
+const CollaborationPolicyDefinition = z
+    .object({
+    metadata: CollaborationPolicyDefinitionMetadataSchema,
+    definition: CollaborationPolicyDefinitionShape,
+})
+    .meta({ id: "policy_definition" });
+const CollaborationPolicy = z
+    .object({
+    name: CollaborationPolicyIdentifier,
+    description: z.string().max(2000).optional(),
+    display_name: z.string().max(255),
+    policy: CollaborationPolicyDefinition,
+})
+    .meta({ id: "policy" });
+// Export the schema for validation
+export { CollaborationPolicy };
+export function buildCollaborationPolicyJsonSchema(options = {}) {
+    const override = (options ?? {});
+    return z.toJSONSchema(CollaborationPolicy, {
+        reused: "ref",
+        ...override,
+    });
+}

package/build/collaboration-policy/types/index.d.ts

@@ -0,0 +1,2 @@
+export type { CollaborationPolicyInput, CollaborationPolicyType, } from "./collaboration-policy";
+export { buildCollaborationPolicyJsonSchema, CollaborationPolicy, } from "./collaboration-policy";

package/build/collaboration-policy/types/index.js

@@ -0,0 +1 @@
+export { buildCollaborationPolicyJsonSchema, CollaborationPolicy, } from "./collaboration-policy";

package/build/collaboration-policy/useCollaborationPolicy.d.ts

@@ -1,17 +1,8 @@
 import type { Attribute } from "../attributes/types";
 import type { Dataset } from "../datasets/types";
-import type { JsonSchemaConnectorPolicy } from "./core/jsonschema/json-schema-types";
-import type { PolicyMatchResult, PolicySqlFragments } from "./core/types";
-/**
- * Hook-style wrapper that exposes collaboration policy helpers.
- *
- * Public API surface:
- * - categorizePolicies
- * - buildPolicySql
- * - buildPolicySqlWithValidation
- */
+import type { PolicySqlFragments } from "./core/types";
+import type { CollaborationPolicyType } from "./types";
 export default function useCollaborationPolicy(): {
-    getEligibleConnectorsPolicies: (dataset: Dataset, policies: JsonSchemaConnectorPolicy[], attributes: Attribute[]) => JsonSchemaConnectorPolicy[];
-    buildPolicySqlFragments: (dataset: Dataset, policies: JsonSchemaConnectorPolicy[], attributes: Attribute[]) => PolicySqlFragments;
-    buildPolicySqlWithValidationJsonSchema: (dataset: Dataset, policies: JsonSchemaConnectorPolicy[], attributes: Attribute[]) => PolicyMatchResult;
+    getEligibleConnectorsPolicies: (dataset: Dataset, policies: CollaborationPolicyType[], attributes: Attribute[]) => CollaborationPolicyType[];
+    buildPolicySqlFragments: (dataset: Dataset, policies: CollaborationPolicyType[], attributes: Attribute[]) => PolicySqlFragments;
 };

package/build/collaboration-policy/useCollaborationPolicy.js

@@ -1,36 +1,14 @@
-import { buildPolicySql, buildPolicySqlWithValidation, categorizePolicies, } from "./core/jsonschema/sql-builder";
-/**
- * Hook-style wrapper that exposes collaboration policy helpers.
- *
- * Public API surface:
- * - categorizePolicies
- * - buildPolicySql
- * - buildPolicySqlWithValidation
- */
+import { buildPolicySql, categorizePolicies } from "./core/sql-builder";
 export default function useCollaborationPolicy() {
-    /**
-     * Get policies that are compatible with a dataset using the JSON-Schema policy system.
-     */
     const getEligibleConnectorsPolicies = (dataset, policies, attributes) => {
         const { matching } = categorizePolicies(policies, dataset, attributes);
         return matching;
     };
-    /**
-     * Build SQL fragments using JSON-Schema policies, without per-policy validation.
-     */
     const buildPolicySqlFragments = (dataset, policies, attributes) => {
         return buildPolicySql(dataset, policies, attributes);
     };
-    /**
-     * Validate each JSON-Schema policy against the dataset and build SQL
-     * plus metadata (appliedPolicies, skippedPolicies, etc.).
-     */
-    const buildPolicySqlWithValidationJsonSchema = (dataset, policies, attributes) => {
-        return buildPolicySqlWithValidation(dataset, policies, attributes);
-    };
     return {
         getEligibleConnectorsPolicies,
         buildPolicySqlFragments,
-        buildPolicySqlWithValidationJsonSchema,
     };
 }

package/build/collaboration-policy/utils/path-helpers.d.ts

@@ -1,8 +1,4 @@
-import type { PathValue } from "../core/types";
-/**
- * Normalizes a PathValue (dot notation or JSON pointer) into a simple dot-notation string.
- *
- * @param path - A PathValue with either `{ dot: "..." }` or `{ pointer: "..." }` format.
- * @returns Normalized dot-notation string, or empty string for undefined/null.
- */
+import type { Attribute } from "../../attributes/types";
+import type { AttributePathIndex, PathValue } from "../core/types";
+export declare function markAttributePath(index: AttributePathIndex, attribute: Attribute, path: string): void;
 export declare function normalizePathValue(path?: PathValue): string;

package/build/collaboration-policy/utils/path-helpers.js

@@ -1,9 +1,25 @@
-/**
- * Normalizes a PathValue (dot notation or JSON pointer) into a simple dot-notation string.
- *
- * @param path - A PathValue with either `{ dot: "..." }` or `{ pointer: "..." }` format.
- * @returns Normalized dot-notation string, or empty string for undefined/null.
- */
+export function markAttributePath(index, attribute, path) {
+    const attributePaths = index.get(attribute.name) ?? new Set();
+    // Use the provided path, even if it's an empty string (which represents the root attribute)
+    const normalized = path !== undefined && path !== null
+        ? path
+        : determineDefaultPath(attribute);
+    attributePaths.add(normalized);
+    index.set(attribute.name, attributePaths);
+}
+function determineDefaultPath(attribute) {
+    if (attribute.type === "object" && "properties" in attribute) {
+        const properties = attribute.properties ?? {};
+        if ("value" in properties) {
+            return "value";
+        }
+        const [firstKey] = Object.keys(properties);
+        if (firstKey) {
+            return firstKey;
+        }
+    }
+    return "";
+}
 export function normalizePathValue(path) {
     if (!path) {
         return "";

package/build/data-planes/types.d.ts

@@ -15,7 +15,7 @@ export interface DataPlanePlatform {
     region: DataPlanePlatformRegion;
 }
 export interface DataPlaneCollaborators {
-    use: Participants;
+    participants: Participants;
 }
 export interface DataPlane {
     type: DataPlaneType;

package/build/datasets/index.d.ts

@@ -1,8 +1,10 @@
 import type { UnknownJob } from "src/jobs/types";
 import { BaseApi } from "../base-api";
 import type { ApiRecords } from "../types";
-import type { AdvancedStatistics, AdvancedStatisticsMetadata, BasicStatistics, ColumnStatistics, ColumnSummary, Columns, Configuration, CreateDatasetRefreshScheduleRequest, CreateDatasetRequest, Dataset, DatasetInterfaceValidation, DatasetStatus, DatasetTableSummary, DatasetTableSummaryAPIResponse, DatasetWriteMode, FilePerSnapshotResponse, Histogram, IngestDatasetFileRequest, RecalculationInfo, RetentionPolicy, Schema, SchemaArrayItems, SchemaArrayItemsArray, SchemaArrayItemsObject, SchemaArrayItemsPrimitive, SchemaArrayProperty, SchemaFileConfig, SchemaFileConfigType, SchemaObjectProperty, SchemaPrimitiveProperty, SchemaProperties, SchemaPropertiesType, SchemaProperty, SnapshotRange, UpdateDatasetRefreshScheduleRequest, UpdateDatasetRequest, Value } from "./types";
-export type { FilePerSnapshotResponse, Dataset, RetentionPolicy, DatasetTableSummaryAPIResponse, ColumnStatistics, UpdateDatasetRequest, SchemaFileConfigType, SchemaPropertiesType, DatasetStatus, DatasetWriteMode, SchemaFileConfig, SchemaProperties, SchemaProperty, SchemaPrimitiveProperty, SchemaObjectProperty, SchemaArrayProperty, SchemaArrayItems, SchemaArrayItemsPrimitive, SchemaArrayItemsObject, SchemaArrayItemsArray, Schema, AdvancedStatisticsMetadata, SnapshotRange, Configuration, Columns, ColumnSummary, BasicStatistics, AdvancedStatistics, Histogram, Value, CreateDatasetRequest, UpdateDatasetRefreshScheduleRequest, CreateDatasetRefreshScheduleRequest, DatasetInterfaceValidation, };
+import type { DatasetStatisticsConfiguration, StatisticsConfigurationResponse } from "./statistics-types";
+import type { AdvancedStatistics, AdvancedStatisticsMetadata, BasicStatistics, ColumnStatistics, ColumnSummary, Columns, Configuration, CreateDatasetRefreshScheduleRequest, CreateDatasetRequest, Dataset, DatasetStatus, DatasetTableSummary, DatasetTableSummaryAPIResponse, DatasetWriteMode, FilePerSnapshotResponse, Histogram, IngestDatasetFileRequest, RecalculationInfo, RetentionPolicy, RetentionScheduleConfig, RowClock, RowTTLPolicy, Schema, SchemaArrayItems, SchemaArrayItemsArray, SchemaArrayItemsObject, SchemaArrayItemsPrimitive, SchemaArrayProperty, SchemaFileConfig, SchemaFileConfigType, SchemaObjectProperty, SchemaPrimitiveProperty, SchemaProperties, SchemaPropertiesType, SchemaProperty, SnapshotAgeExpression, SnapshotRange, SnapshotTTLPolicy, TableClock, TableClockKind, TableTTLPolicy, TTLPolicy, TTLPolicyKind, UpdateDatasetRefreshScheduleRequest, UpdateDatasetRequest, UpsertRetentionPoliciesRequest, Value } from "./types";
+export type { FilePerSnapshotResponse, Dataset, RetentionPolicy, RetentionScheduleConfig, RowClock, RowTTLPolicy, SnapshotAgeExpression, SnapshotTTLPolicy, TTLPolicy, TTLPolicyKind, TableClock, TableClockKind, TableTTLPolicy, UpsertRetentionPoliciesRequest, DatasetTableSummaryAPIResponse, ColumnStatistics, UpdateDatasetRequest, SchemaFileConfigType, SchemaPropertiesType, DatasetStatus, DatasetWriteMode, SchemaFileConfig, SchemaProperties, SchemaProperty, SchemaPrimitiveProperty, SchemaObjectProperty, SchemaArrayProperty, SchemaArrayItems, SchemaArrayItemsPrimitive, SchemaArrayItemsObject, SchemaArrayItemsArray, Schema, AdvancedStatisticsMetadata, SnapshotRange, Configuration, Columns, ColumnSummary, BasicStatistics, AdvancedStatistics, Histogram, Value, CreateDatasetRequest, UpdateDatasetRefreshScheduleRequest, CreateDatasetRefreshScheduleRequest, };
+export type { CronRefresh, DatasetFieldConfig, DatasetFieldNamespace, DatasetStatisticsConfiguration, HistogramOptions, HistogramOverflow, ManualRefresh, NestedNodeConfig, NestedPropertyConfig, NonPrimitiveNodeConfig, OnUpdateRefresh, PrimitiveNodeConfig, RefreshTrigger, RosettaStoneFieldConfig, RosettaStoneFieldNamespace, StatConfig, StatisticsConfigurationResponse, StatName, StatOptions, } from "./statistics-types";
 /**
  * @module DatasetApi
  * @description This module provides methods for fetching datasets.
@@ -166,6 +168,8 @@ export declare class DatasetApi extends BaseApi {
      * @public
      */
     updateRetentionPolicy(datasetId: number, policy: RetentionPolicy): Promise<Dataset>;
+    upsertRetentionPolicies(datasetId: number, request: UpsertRetentionPoliciesRequest): Promise<Dataset>;
+    disableDatasetRetentionPolicy(datasetId: number, policy: TTLPolicy): Promise<Dataset>;
     /**
      * Configures the statistics for a specific dataset column.
      * This method sends a PUT request to the specified endpoint to update the statistics configuration.
@@ -190,7 +194,9 @@ export declare class DatasetApi extends BaseApi {
      * @throws {Error} If there is an issue with the request or the response.
      * @memberof DatasetApi
      */
-    requestDatasetSample(datasetId: number): Promise<{
+    requestDatasetSample(datasetId: number, request?: {
+        compute_pool_id?: string;
+    }): Promise<{
         job_id: string;
     }>;
     /**
@@ -215,13 +221,7 @@ export declare class DatasetApi extends BaseApi {
     createDatasetRefreshSchedule(datasetId: number, refreshSchedule: CreateDatasetRefreshScheduleRequest): Promise<void>;
     updateDatasetRefreshSchedule(datasetId: number, refreshSchedule: UpdateDatasetRefreshScheduleRequest): Promise<void>;
     deleteDatasetRefreshSchedule(datasetId: number): Promise<void>;
-    /**
-     * Validate which connector interfaces are compatible with a dataset.
-     * Filtered by the user's installed apps and optionally by tags.
-     *
-     * @param {number} datasetId - The ID of the dataset to validate interfaces against.
-     * @param {string[]} [tags] - Optional tags to filter interfaces (e.g. ["audience_delivery"]).
-     * @returns {Promise<DatasetInterfaceValidation>} - Accepted interface IDs and per-interface validation errors.
-     */
-    getDatasetInterfaces(datasetId: number, tags?: string[]): Promise<DatasetInterfaceValidation>;
+    putStatisticsConfiguration(datasetId: number, configuration: DatasetStatisticsConfiguration): Promise<StatisticsConfigurationResponse>;
+    getStatisticsConfiguration(datasetId: number): Promise<StatisticsConfigurationResponse>;
+    deleteStatisticsConfiguration(datasetId: number): Promise<StatisticsConfigurationResponse>;
 }

package/build/datasets/index.js

@@ -221,6 +221,14 @@ export class DatasetApi extends BaseApi {
     async updateRetentionPolicy(datasetId, policy) {
         return await this.put(`${resourceName}/${datasetId}/retention-policy`, policy);
     }
+    async upsertRetentionPolicies(datasetId, request) {
+        return await this.put(`${resourceName}/${datasetId}/retention-policy`, request);
+    }
+    async disableDatasetRetentionPolicy(datasetId, policy) {
+        return await this.upsertRetentionPolicies(datasetId, {
+            policies: [{ ...policy, enabled: false }],
+        });
+    }
     /**
      * Configures the statistics for a specific dataset column.
      * This method sends a PUT request to the specified endpoint to update the statistics configuration.
@@ -249,8 +257,8 @@ export class DatasetApi extends BaseApi {
      * @throws {Error} If there is an issue with the request or the response.
      * @memberof DatasetApi
      */
-    async requestDatasetSample(datasetId) {
-        return await this.post(`${resourceName}/${datasetId}/request-sample`);
+    async requestDatasetSample(datasetId, request) {
+        return await this.post(`${resourceName}/${datasetId}/request-sample`, request);
     }
     /**
      * Deletes a sample of a specified dataset by its ID.
@@ -287,16 +295,13 @@ export class DatasetApi extends BaseApi {
     async deleteDatasetRefreshSchedule(datasetId) {
         await this.delete(`${resourceName}/${datasetId}/refresh-schedule`);
     }
-    /**
-     * Validate which connector interfaces are compatible with a dataset.
-     * Filtered by the user's installed apps and optionally by tags.
-     *
-     * @param {number} datasetId - The ID of the dataset to validate interfaces against.
-     * @param {string[]} [tags] - Optional tags to filter interfaces (e.g. ["audience_delivery"]).
-     * @returns {Promise<DatasetInterfaceValidation>} - Accepted interface IDs and per-interface validation errors.
-     */
-    async getDatasetInterfaces(datasetId, tags) {
-        const queryString = this.constructQueryString(tags != null ? { tags } : undefined);
-        return await this.get(`${resourceName}/${datasetId}/interfaces${queryString}`);
+    async putStatisticsConfiguration(datasetId, configuration) {
+        return await this.put(`${resourceName}/${datasetId}/statistics-configuration`, configuration);
+    }
+    async getStatisticsConfiguration(datasetId) {
+        return await this.get(`${resourceName}/${datasetId}/statistics-configuration`);
+    }
+    async deleteStatisticsConfiguration(datasetId) {
+        return await this.base_api.delete(`${resourceName}/${datasetId}/statistics-configuration`);
     }
 }

package/build/datasets/statistics-types.d.ts

@@ -0,0 +1,81 @@
+export type StatName = "value_count" | "null_value_count" | "nan_value_count" | "lower_bound" | "upper_bound" | "approx_count_distinct" | "count_distinct" | "histogram" | "mean" | "standard_deviation" | "completeness";
+export type HistogramOverflow = "none" | "truncate";
+export interface HistogramOptions {
+    max_bins?: number;
+    overflow?: HistogramOverflow;
+}
+export interface StatOptions {
+    histogram?: HistogramOptions;
+}
+export type StatConfig = {
+    enabled_stats: StatName[];
+    stat_options?: StatOptions;
+} | {
+    enabled_stats?: StatName[];
+    stat_options: StatOptions;
+} | {
+    enabled_stats: StatName[];
+    stat_options: StatOptions;
+};
+export interface CronRefresh {
+    trigger: "cron";
+    cron_expression: string;
+}
+export interface OnUpdateRefresh {
+    trigger: "on_update";
+}
+export interface ManualRefresh {
+    trigger: "manual";
+}
+export type RefreshTrigger = CronRefresh | OnUpdateRefresh | ManualRefresh;
+export interface PrimitiveNodeConfig {
+    enabled_stats?: StatName[];
+    stat_options?: StatOptions;
+}
+export interface NonPrimitiveNodeConfig {
+    self?: StatConfig;
+    properties?: NestedPropertyConfig[];
+    items?: NestedNodeConfig;
+}
+export type NestedNodeConfig = PrimitiveNodeConfig | NonPrimitiveNodeConfig;
+export type NestedPropertyConfig = (PrimitiveNodeConfig & {
+    path: string;
+}) | (NonPrimitiveNodeConfig & {
+    path: string;
+});
+export type DatasetFieldConfig = (PrimitiveNodeConfig & {
+    field_name: string;
+}) | (NonPrimitiveNodeConfig & {
+    field_name: string;
+}) | {
+    field_name: string;
+};
+export type RosettaStoneFieldConfig = (PrimitiveNodeConfig & {
+    attribute_name: string;
+}) | (NonPrimitiveNodeConfig & {
+    attribute_name: string;
+}) | {
+    attribute_name: string;
+};
+export interface DatasetFieldNamespace {
+    scope?: StatConfig;
+    fields?: DatasetFieldConfig[];
+}
+export interface RosettaStoneFieldNamespace {
+    scope?: StatConfig;
+    fields?: RosettaStoneFieldConfig[];
+}
+export interface DatasetStatisticsConfiguration {
+    defaults: StatConfig;
+    refresh: RefreshTrigger;
+    dataset?: DatasetFieldNamespace;
+    rosetta_stone?: RosettaStoneFieldNamespace;
+}
+export interface StatisticsConfigurationResponse {
+    id: string;
+    dataset_id: number;
+    version: number;
+    created_at: string;
+    created_by: number;
+    configuration: DatasetStatisticsConfiguration;
+}