reasoninglayer 0.2.1

Rust client SDK for the Reasoning Layer API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Data source DTOs.

use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SourceSummaryDto {
    pub available: bool,
    pub source_id: String,
    pub source_type: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DiscoveredFeatureDto {
    #[serde(default)]
    pub constraints: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub is_identifier: bool,
    pub is_relation: bool,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub relation_target: Option<String>,
    pub required: bool,
    pub source_name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub type_hint: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DiscoveredSortDto {
    pub confidence: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default)]
    pub features: Vec<DiscoveredFeatureDto>,
    pub name: String,
    pub source_name: String,
    #[serde(default)]
    pub suggested_parents: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DiscoveredSourceRelationDto {
    pub cardinality: String,
    pub confidence: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub inverse_name: Option<String>,
    pub relation_name: String,
    pub source_sort: String,
    pub target_sort: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct StructuredIngestionStatsDto {
    pub columns_discovered: u64,
    pub documents_rendered: u64,
    pub elapsed_ms: u64,
    pub entities_created: u64,
    pub entities_extracted: u64,
    pub records_processed: u64,
    pub relations_created: u64,
    pub relations_discovered: u64,
    pub sorts_created: u64,
    pub tables_discovered: u64,
    pub terms_created: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RegisterSourceRequest {
    pub source_id: String,
    pub source_name: String,
    pub source_type: String,
    #[serde(default)]
    pub config: BTreeMap<String, serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RegisterSourceResponse {
    pub success: bool,
    pub source_id: String,
    pub source_type: String,
    pub message: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ListSourcesResponse {
    #[serde(default)]
    pub sources: Vec<SourceSummaryDto>,
    pub total: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SourceDetailResponse {
    pub source_id: String,
    pub source_type: String,
    pub available: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DiscoverSchemaRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sample_size: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub include_sample_data: Option<bool>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DiscoverSchemaResponse {
    pub source_id: String,
    #[serde(default)]
    pub sorts: Vec<DiscoveredSortDto>,
    #[serde(default)]
    pub relations: Vec<DiscoveredSourceRelationDto>,
    pub total_columns: u64,
    #[serde(default)]
    pub warnings: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IngestFromSourceRequest {
    pub owner_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub type_filter: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_records_per_type: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub batch_size: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub records_per_document: Option<u32>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct IngestFromSourceResponse {
    pub success: bool,
    pub source_id: String,
    pub source_type: String,
    #[serde(default)]
    pub stats: StructuredIngestionStatsDto,
    #[serde(default)]
    pub errors: Vec<String>,
}