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

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/company-info/index.d.ts

@@ -18,4 +18,4 @@ declare class CompanyInfoApi extends BaseApi {
      */
     getAllProvidersCompanyInfo(): Promise<ApiRecords<CompanyInfo>>;
 }
-export { type CompanyInfo, type WhoAmI, CompanyInfoApi };
+export { type CompanyInfo, CompanyInfoApi, type WhoAmI };

package/build/connections/index.d.ts

@@ -69,4 +69,4 @@ declare class ConnectionsApi extends BaseApi {
      */
     getConnections(): Promise<ApiRecords<ConnectionV2>>;
 }
-export { type Connection, type ConnectionV2, type ConnectionStatus, ConnectionsApi, };
+export { type Connection, type ConnectionStatus, ConnectionsApi, type ConnectionV2, };

package/build/contracts/index.d.ts

@@ -36,4 +36,4 @@ declare class ContractsApi extends BaseApi {
      */
     getActiveContract(): Promise<ContractDetails>;
 }
-export { ContractsApi, type ContractDetails, type CustomerContract, type PaymentMethod, type ContractRateView, };
+export { type ContractDetails, type ContractRateView, ContractsApi, type CustomerContract, type PaymentMethod, };

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

@@ -1,9 +1,10 @@
 import type { ApiRecords } from "src/types";
 import { BaseApi } from "../base-api";
-import type { DataPlane } from "./types";
+import type { DataPlane, HealthCheckJobResponse } from "./types";
 export declare class DataPlaneApi extends BaseApi {
     getDataPlanes(): Promise<ApiRecords<DataPlane>>;
     getDataPlane(dataPlaneId: string): Promise<DataPlane>;
     setDefaultComputePool(dataPlaneId: string, computePoolId: string): Promise<DataPlane>;
     clearDefaultComputePool(dataPlaneId: string): Promise<void>;
+    runHealthCheck(dataPlaneId: string, computePoolId?: string): Promise<HealthCheckJobResponse>;
 }

package/build/data-planes/index.js

@@ -13,4 +13,8 @@ export class DataPlaneApi extends BaseApi {
     async clearDefaultComputePool(dataPlaneId) {
         await this.delete(`${resourceName}/${dataPlaneId}/default-compute-pool`);
     }
+    async runHealthCheck(dataPlaneId, computePoolId) {
+        const body = computePoolId != null ? { compute_pool_id: computePoolId } : {};
+        return await this.post(`${resourceName}/${dataPlaneId}/health-check`, body);
+    }
 }

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;
@@ -34,3 +34,9 @@ export interface DataPlane {
     compute_pools?: ComputePoolResponse[];
     collaborators?: DataPlaneCollaborators;
 }
+export interface HealthCheckRequest {
+    compute_pool_id?: string;
+}
+export interface HealthCheckJobResponse {
+    job_id: string;
+}

package/build/data-streams/index.d.ts

@@ -24,4 +24,4 @@ declare class DataStreamsApi extends BaseApi {
     getDataStreamBySlug(slug: string, companyId: number, authenticated: boolean): Promise<DataStream>;
     private getBaseUri;
 }
-export { DataStreamsApi, type DataRules, type ColumnSet, type ColumnWithFilterAndExport, type AttributeSet, type DataStream, };
+export { type AttributeSet, type ColumnSet, type ColumnWithFilterAndExport, type DataRules, type DataStream, DataStreamsApi, };

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, DatasetInterfaceError, DatasetInterfaceRef, DatasetInterfaceValidation, DatasetStatus, DatasetTableSummary, DatasetTableSummaryAPIResponse, DatasetWriteMode, FilePerSnapshotResponse, Histogram, IngestDatasetFileRequest, JsonSchemaValidationNode, 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 { CronRefresh, DatasetFieldConfig, DatasetFieldNamespace, DatasetStatisticsConfiguration, HistogramOptions, HistogramOverflow, ManualRefresh, NestedNodeConfig, NestedPropertyConfig, NonPrimitiveNodeConfig, OnUpdateRefresh, PrimitiveNodeConfig, RefreshTrigger, RosettaStoneFieldConfig, RosettaStoneFieldNamespace, StatConfig, StatisticsConfigurationResponse, StatName, StatOptions, } from "./statistics-types";
+export type { AdvancedStatistics, AdvancedStatisticsMetadata, BasicStatistics, ColumnStatistics, ColumnSummary, Columns, Configuration, CreateDatasetRefreshScheduleRequest, CreateDatasetRequest, Dataset, DatasetInterfaceError, DatasetInterfaceRef, DatasetInterfaceValidation, DatasetStatus, DatasetTableSummaryAPIResponse, DatasetWriteMode, FilePerSnapshotResponse, Histogram, JsonSchemaValidationNode, 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, };
 /**
  * @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;
     }>;
     /**
@@ -224,4 +230,7 @@ export declare class DatasetApi extends BaseApi {
      * @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.
@@ -299,4 +307,13 @@ export class DatasetApi extends BaseApi {
         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;
+}

package/build/datasets/statistics-types.js

@@ -0,0 +1 @@
+export {};

package/build/datasets/types.d.ts

@@ -22,6 +22,9 @@ export interface Dataset {
     external_id?: string;
     data_plane?: DataPlane;
     materialized_view_config?: string;
+    compute_pool_config?: {
+        default_compute_pool_id?: string;
+    };
 }
 export interface DatasetStats extends DatasetSummaryStatistics {
     last_snapshot_added_bytes: number;
@@ -78,8 +81,6 @@ export interface DatasetTableSummaryAPIResponse {
 export type SchemaPropertiesType = "string" | "boolean" | "double" | "long" | "timestamptz" | "object" | "array";
 export type DatasetStatus = "active" | "archived" | "pending";
 export type DatasetWriteMode = "append" | "overwrite";
-type ExpressionlessRetentionPolicyType = "retain_everything" | "expire_everything";
-type ExpressionedRetentionPolicyType = "retain_when" | "expire_when";
 type SchemaType = "object" | "value";
 export declare enum Operator {
     GreaterThan = ">",
@@ -87,16 +88,66 @@ export declare enum Operator {
     GreaterThanOrEqualTo = ">=",
     LessThanOrEqualTo = "<="
 }
+export interface SnapshotAgeExpression {
+    type: "snapshot_age";
+    operator: Operator;
+    period: string;
+}
 export type RetentionPolicy = {
-    type: ExpressionlessRetentionPolicyType;
+    type: "retain_everything";
 } | {
-    type: ExpressionedRetentionPolicyType;
-    expression?: {
-        type: "snapshot_age";
-        operator: Operator;
-        period: string;
-    };
+    type: "expire_everything";
+} | {
+    type: "retain_when";
+    expression?: SnapshotAgeExpression;
+} | {
+    type: "expire_when";
+    expression?: SnapshotAgeExpression;
 };
+export interface RowClock {
+    kind: "event_time";
+    attribute?: string;
+}
+export type TTLPolicyKind = "row_ttl" | "table_ttl" | "snapshot_ttl";
+export interface RowTTLPolicy {
+    type: {
+        kind: "row_ttl";
+        clock?: RowClock;
+    };
+    enabled: boolean;
+    interval: string;
+}
+export type TableClockKind = "created_at" | "max_event_time" | "static_time";
+export interface TableClock {
+    kind: TableClockKind;
+    column?: string;
+}
+export interface TableTTLPolicy {
+    type: {
+        kind: "table_ttl";
+        clock: TableClock;
+    };
+    enabled: boolean;
+    interval: string;
+}
+export interface SnapshotTTLPolicy {
+    type: {
+        kind: "snapshot_ttl";
+    };
+    enabled: boolean;
+    interval: string;
+    snapshot_retention_policy: RetentionPolicy;
+}
+export type TTLPolicy = RowTTLPolicy | TableTTLPolicy | SnapshotTTLPolicy;
+export interface RetentionScheduleConfig {
+    schedule: string;
+    schedule_zone_id?: string;
+    status?: "active" | "pending" | "archived";
+}
+export interface UpsertRetentionPoliciesRequest {
+    policies: TTLPolicy[];
+    schedule_config?: RetentionScheduleConfig;
+}
 export type SchemaFileConfigType = "flat" | "json" | "parquet";
 export interface FlatFileConfig {
     type: "flat";
@@ -205,7 +256,6 @@ export interface BasicStatistics {
     lower_bound: string | number | null | boolean;
     upper_bound: string | number | null | boolean;
     value_count: number;
-    column_store_bytes: number;
 }
 export interface AdvancedStatistics {
     approx_count_distinct: number | null;
@@ -244,9 +294,30 @@ export interface CreateDatasetRequest {
 export interface IngestDatasetFileRequest {
     source_file: string;
 }
+export interface DatasetInterfaceRef {
+    app_id: number;
+    interface_id: string;
+}
+/**
+ * A JSON-Schema 2020-12 "Basic" output node, used recursively in validation errors.
+ * `errors` is keyed by JSON-Schema keyword (`"required"`, `"type"`, etc.); values
+ * are human-readable strings.
+ */
+export interface JsonSchemaValidationNode {
+    valid: boolean;
+    evaluationPath: string;
+    schemaLocation: string;
+    instanceLocation: string;
+    errors?: Record<string, string>;
+    details?: JsonSchemaValidationNode[];
+}
+export interface DatasetInterfaceError extends DatasetInterfaceRef {
+    details: JsonSchemaValidationNode;
+}
 export interface DatasetInterfaceValidation {
-    accepted: string[];
-    errors: Record<string, string[]>;
+    dataset_id: number;
+    accepted: DatasetInterfaceRef[];
+    errors: DatasetInterfaceError[];
 }
 export interface UpdateDatasetRefreshScheduleRequest {
     cron?: string;

package/build/datasets/types.js

@@ -1,3 +1,4 @@
+// ---- Snapshot-level retention (legacy) ----
 export var Operator;
 (function (Operator) {
     Operator["GreaterThan"] = ">";

package/build/forecast/index.d.ts

@@ -49,4 +49,4 @@ declare class ForecastApi extends BaseApi {
      */
     getPublicForecast(forecastId: string): Promise<ForecastResponse>;
 }
-export { ForecastApi, type ForecastRequest, type ForecastResponse, type CostForecastRequest, type CostForecastResponse, type ForecastResult, type CostForecastResult, type ForecastResultFailure, type JobState, };
+export { type CostForecastRequest, type CostForecastResponse, type CostForecastResult, ForecastApi, type ForecastRequest, type ForecastResponse, type ForecastResult, type ForecastResultFailure, type JobState, };

package/build/index.d.ts

@@ -15,6 +15,7 @@ export * from "./data-planes";
 export * from "./data-planes/types";
 export * from "./data-streams";
 export * from "./datasets";
+export * from "./datasets/statistics-types";
 export * from "./datasets/types";
 export * from "./encryption-materials";
 export * from "./encryption-materials/types";