@instruments/sustainability 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +7 -0
- package/README.md +56 -0
- package/dist/index.d.ts +883 -0
- package/dist/index.js +6816 -0
- package/dist/index.js.map +1 -0
- package/package.json +42 -0
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,883 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
|
|
3
|
+
declare const impactAreaSchema: z.ZodEnum<{
|
|
4
|
+
climate_health: "climate_health";
|
|
5
|
+
human_health: "human_health";
|
|
6
|
+
ecosystem_health: "ecosystem_health";
|
|
7
|
+
social_health_equity: "social_health_equity";
|
|
8
|
+
circular_economy: "circular_economy";
|
|
9
|
+
}>;
|
|
10
|
+
declare const claimKindSchema: z.ZodEnum<{
|
|
11
|
+
certification: "certification";
|
|
12
|
+
declaration: "declaration";
|
|
13
|
+
standard_method: "standard_method";
|
|
14
|
+
chemical_exclusion: "chemical_exclusion";
|
|
15
|
+
rating_system_hint: "rating_system_hint";
|
|
16
|
+
origin_claim: "origin_claim";
|
|
17
|
+
impact_metric: "impact_metric";
|
|
18
|
+
program_participation: "program_participation";
|
|
19
|
+
circularity_claim: "circularity_claim";
|
|
20
|
+
organizational_commitment: "organizational_commitment";
|
|
21
|
+
}>;
|
|
22
|
+
declare const sourceAuthorityTierSchema: z.ZodEnum<{
|
|
23
|
+
official_registry: "official_registry";
|
|
24
|
+
programme_operator: "programme_operator";
|
|
25
|
+
third_party_verified: "third_party_verified";
|
|
26
|
+
manufacturer_declared: "manufacturer_declared";
|
|
27
|
+
expert_interpretation: "expert_interpretation";
|
|
28
|
+
}>;
|
|
29
|
+
declare const frameworkRelationshipSchema: z.ZodEnum<{
|
|
30
|
+
required_by: "required_by";
|
|
31
|
+
may_support: "may_support";
|
|
32
|
+
insufficient_alone: "insufficient_alone";
|
|
33
|
+
contradicts: "contradicts";
|
|
34
|
+
not_applicable: "not_applicable";
|
|
35
|
+
}>;
|
|
36
|
+
declare const greenwashingRiskSchema: z.ZodEnum<{
|
|
37
|
+
low: "low";
|
|
38
|
+
medium: "medium";
|
|
39
|
+
high: "high";
|
|
40
|
+
}>;
|
|
41
|
+
declare const reviewStatusSchema: z.ZodEnum<{
|
|
42
|
+
draft: "draft";
|
|
43
|
+
reviewed: "reviewed";
|
|
44
|
+
disputed: "disputed";
|
|
45
|
+
deprecated: "deprecated";
|
|
46
|
+
}>;
|
|
47
|
+
/** A citation to the primary document or operator behind an entry. */
|
|
48
|
+
declare const sourceLinkSchema: z.ZodObject<{
|
|
49
|
+
label: z.ZodString;
|
|
50
|
+
url: z.ZodString;
|
|
51
|
+
}, z.core.$strip>;
|
|
52
|
+
declare const sourceRequirementSchema: z.ZodObject<{
|
|
53
|
+
sourceTypeId: z.ZodString;
|
|
54
|
+
requiredFields: z.ZodArray<z.ZodString>;
|
|
55
|
+
minimumSourceAuthority: z.ZodEnum<{
|
|
56
|
+
official_registry: "official_registry";
|
|
57
|
+
programme_operator: "programme_operator";
|
|
58
|
+
third_party_verified: "third_party_verified";
|
|
59
|
+
manufacturer_declared: "manufacturer_declared";
|
|
60
|
+
expert_interpretation: "expert_interpretation";
|
|
61
|
+
}>;
|
|
62
|
+
caveats: z.ZodArray<z.ZodString>;
|
|
63
|
+
}, z.core.$strip>;
|
|
64
|
+
declare const frameworkMappingSchema: z.ZodObject<{
|
|
65
|
+
frameworkId: z.ZodString;
|
|
66
|
+
ruleVersionId: z.ZodString;
|
|
67
|
+
relationship: z.ZodEnum<{
|
|
68
|
+
required_by: "required_by";
|
|
69
|
+
may_support: "may_support";
|
|
70
|
+
insufficient_alone: "insufficient_alone";
|
|
71
|
+
contradicts: "contradicts";
|
|
72
|
+
not_applicable: "not_applicable";
|
|
73
|
+
}>;
|
|
74
|
+
}, z.core.$strip>;
|
|
75
|
+
declare const frameworkRuleVersionSchema: z.ZodObject<{
|
|
76
|
+
id: z.ZodString;
|
|
77
|
+
label: z.ZodString;
|
|
78
|
+
status: z.ZodEnum<{
|
|
79
|
+
draft: "draft";
|
|
80
|
+
reviewed: "reviewed";
|
|
81
|
+
disputed: "disputed";
|
|
82
|
+
deprecated: "deprecated";
|
|
83
|
+
}>;
|
|
84
|
+
notes: z.ZodArray<z.ZodString>;
|
|
85
|
+
}, z.core.$strip>;
|
|
86
|
+
declare const frameworkCategorySchema: z.ZodEnum<{
|
|
87
|
+
building_rating: "building_rating";
|
|
88
|
+
health_wellbeing: "health_wellbeing";
|
|
89
|
+
regenerative: "regenerative";
|
|
90
|
+
energy_carbon: "energy_carbon";
|
|
91
|
+
landscape: "landscape";
|
|
92
|
+
waste: "waste";
|
|
93
|
+
vocabulary: "vocabulary";
|
|
94
|
+
commitment: "commitment";
|
|
95
|
+
}>;
|
|
96
|
+
declare const frameworkSchema: z.ZodObject<{
|
|
97
|
+
frameworkId: z.ZodString;
|
|
98
|
+
canonicalName: z.ZodString;
|
|
99
|
+
aliases: z.ZodArray<z.ZodString>;
|
|
100
|
+
operatorName: z.ZodString;
|
|
101
|
+
category: z.ZodEnum<{
|
|
102
|
+
building_rating: "building_rating";
|
|
103
|
+
health_wellbeing: "health_wellbeing";
|
|
104
|
+
regenerative: "regenerative";
|
|
105
|
+
energy_carbon: "energy_carbon";
|
|
106
|
+
landscape: "landscape";
|
|
107
|
+
waste: "waste";
|
|
108
|
+
vocabulary: "vocabulary";
|
|
109
|
+
commitment: "commitment";
|
|
110
|
+
}>;
|
|
111
|
+
region: z.ZodString;
|
|
112
|
+
plainLanguageSummary: z.ZodString;
|
|
113
|
+
sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
114
|
+
label: z.ZodString;
|
|
115
|
+
url: z.ZodString;
|
|
116
|
+
}, z.core.$strip>>>;
|
|
117
|
+
impactAreas: z.ZodArray<z.ZodEnum<{
|
|
118
|
+
climate_health: "climate_health";
|
|
119
|
+
human_health: "human_health";
|
|
120
|
+
ecosystem_health: "ecosystem_health";
|
|
121
|
+
social_health_equity: "social_health_equity";
|
|
122
|
+
circular_economy: "circular_economy";
|
|
123
|
+
}>>;
|
|
124
|
+
ruleVersions: z.ZodArray<z.ZodObject<{
|
|
125
|
+
id: z.ZodString;
|
|
126
|
+
label: z.ZodString;
|
|
127
|
+
status: z.ZodEnum<{
|
|
128
|
+
draft: "draft";
|
|
129
|
+
reviewed: "reviewed";
|
|
130
|
+
disputed: "disputed";
|
|
131
|
+
deprecated: "deprecated";
|
|
132
|
+
}>;
|
|
133
|
+
notes: z.ZodArray<z.ZodString>;
|
|
134
|
+
}, z.core.$strip>>;
|
|
135
|
+
sourceAuthorityTier: z.ZodEnum<{
|
|
136
|
+
official_registry: "official_registry";
|
|
137
|
+
programme_operator: "programme_operator";
|
|
138
|
+
third_party_verified: "third_party_verified";
|
|
139
|
+
manufacturer_declared: "manufacturer_declared";
|
|
140
|
+
expert_interpretation: "expert_interpretation";
|
|
141
|
+
}>;
|
|
142
|
+
caveats: z.ZodArray<z.ZodString>;
|
|
143
|
+
reviewStatus: z.ZodEnum<{
|
|
144
|
+
draft: "draft";
|
|
145
|
+
reviewed: "reviewed";
|
|
146
|
+
disputed: "disputed";
|
|
147
|
+
deprecated: "deprecated";
|
|
148
|
+
}>;
|
|
149
|
+
}, z.core.$strip>;
|
|
150
|
+
declare const claimFamilySchema: z.ZodObject<{
|
|
151
|
+
claimFamilyId: z.ZodString;
|
|
152
|
+
canonicalName: z.ZodString;
|
|
153
|
+
aliases: z.ZodArray<z.ZodString>;
|
|
154
|
+
claimKind: z.ZodEnum<{
|
|
155
|
+
certification: "certification";
|
|
156
|
+
declaration: "declaration";
|
|
157
|
+
standard_method: "standard_method";
|
|
158
|
+
chemical_exclusion: "chemical_exclusion";
|
|
159
|
+
rating_system_hint: "rating_system_hint";
|
|
160
|
+
origin_claim: "origin_claim";
|
|
161
|
+
impact_metric: "impact_metric";
|
|
162
|
+
program_participation: "program_participation";
|
|
163
|
+
circularity_claim: "circularity_claim";
|
|
164
|
+
organizational_commitment: "organizational_commitment";
|
|
165
|
+
}>;
|
|
166
|
+
impactAreas: z.ZodArray<z.ZodEnum<{
|
|
167
|
+
climate_health: "climate_health";
|
|
168
|
+
human_health: "human_health";
|
|
169
|
+
ecosystem_health: "ecosystem_health";
|
|
170
|
+
social_health_equity: "social_health_equity";
|
|
171
|
+
circular_economy: "circular_economy";
|
|
172
|
+
}>>;
|
|
173
|
+
definition: z.ZodString;
|
|
174
|
+
sourceRequirements: z.ZodArray<z.ZodObject<{
|
|
175
|
+
sourceTypeId: z.ZodString;
|
|
176
|
+
requiredFields: z.ZodArray<z.ZodString>;
|
|
177
|
+
minimumSourceAuthority: z.ZodEnum<{
|
|
178
|
+
official_registry: "official_registry";
|
|
179
|
+
programme_operator: "programme_operator";
|
|
180
|
+
third_party_verified: "third_party_verified";
|
|
181
|
+
manufacturer_declared: "manufacturer_declared";
|
|
182
|
+
expert_interpretation: "expert_interpretation";
|
|
183
|
+
}>;
|
|
184
|
+
caveats: z.ZodArray<z.ZodString>;
|
|
185
|
+
}, z.core.$strip>>;
|
|
186
|
+
frameworkMappings: z.ZodArray<z.ZodObject<{
|
|
187
|
+
frameworkId: z.ZodString;
|
|
188
|
+
ruleVersionId: z.ZodString;
|
|
189
|
+
relationship: z.ZodEnum<{
|
|
190
|
+
required_by: "required_by";
|
|
191
|
+
may_support: "may_support";
|
|
192
|
+
insufficient_alone: "insufficient_alone";
|
|
193
|
+
contradicts: "contradicts";
|
|
194
|
+
not_applicable: "not_applicable";
|
|
195
|
+
}>;
|
|
196
|
+
}, z.core.$strip>>;
|
|
197
|
+
sourceAuthorityNotes: z.ZodArray<z.ZodString>;
|
|
198
|
+
greenwashingRisk: z.ZodEnum<{
|
|
199
|
+
low: "low";
|
|
200
|
+
medium: "medium";
|
|
201
|
+
high: "high";
|
|
202
|
+
}>;
|
|
203
|
+
reviewStatus: z.ZodEnum<{
|
|
204
|
+
draft: "draft";
|
|
205
|
+
reviewed: "reviewed";
|
|
206
|
+
disputed: "disputed";
|
|
207
|
+
deprecated: "deprecated";
|
|
208
|
+
}>;
|
|
209
|
+
}, z.core.$strip>;
|
|
210
|
+
declare const sourceTypeCategorySchema: z.ZodEnum<{
|
|
211
|
+
lifecycle_carbon: "lifecycle_carbon";
|
|
212
|
+
ingredient_chemical: "ingredient_chemical";
|
|
213
|
+
iaq_emissions: "iaq_emissions";
|
|
214
|
+
material_origin: "material_origin";
|
|
215
|
+
circularity: "circularity";
|
|
216
|
+
multi_attribute: "multi_attribute";
|
|
217
|
+
social_organizational: "social_organizational";
|
|
218
|
+
regulatory: "regulatory";
|
|
219
|
+
programme_language: "programme_language";
|
|
220
|
+
}>;
|
|
221
|
+
declare const sourceTypeSchema: z.ZodObject<{
|
|
222
|
+
sourceTypeId: z.ZodString;
|
|
223
|
+
canonicalName: z.ZodString;
|
|
224
|
+
aliases: z.ZodArray<z.ZodString>;
|
|
225
|
+
category: z.ZodEnum<{
|
|
226
|
+
lifecycle_carbon: "lifecycle_carbon";
|
|
227
|
+
ingredient_chemical: "ingredient_chemical";
|
|
228
|
+
iaq_emissions: "iaq_emissions";
|
|
229
|
+
material_origin: "material_origin";
|
|
230
|
+
circularity: "circularity";
|
|
231
|
+
multi_attribute: "multi_attribute";
|
|
232
|
+
social_organizational: "social_organizational";
|
|
233
|
+
regulatory: "regulatory";
|
|
234
|
+
programme_language: "programme_language";
|
|
235
|
+
}>;
|
|
236
|
+
issuerExamples: z.ZodArray<z.ZodString>;
|
|
237
|
+
sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
238
|
+
label: z.ZodString;
|
|
239
|
+
url: z.ZodString;
|
|
240
|
+
}, z.core.$strip>>>;
|
|
241
|
+
supportsClaim: z.ZodString;
|
|
242
|
+
doesNotSupport: z.ZodArray<z.ZodString>;
|
|
243
|
+
requiredFields: z.ZodArray<z.ZodString>;
|
|
244
|
+
minimumSourceAuthority: z.ZodEnum<{
|
|
245
|
+
official_registry: "official_registry";
|
|
246
|
+
programme_operator: "programme_operator";
|
|
247
|
+
third_party_verified: "third_party_verified";
|
|
248
|
+
manufacturer_declared: "manufacturer_declared";
|
|
249
|
+
expert_interpretation: "expert_interpretation";
|
|
250
|
+
}>;
|
|
251
|
+
expiryRelevant: z.ZodBoolean;
|
|
252
|
+
caveats: z.ZodArray<z.ZodString>;
|
|
253
|
+
reviewStatus: z.ZodEnum<{
|
|
254
|
+
draft: "draft";
|
|
255
|
+
reviewed: "reviewed";
|
|
256
|
+
disputed: "disputed";
|
|
257
|
+
deprecated: "deprecated";
|
|
258
|
+
}>;
|
|
259
|
+
}, z.core.$strip>;
|
|
260
|
+
declare const claimClassificationSchema: z.ZodObject<{
|
|
261
|
+
rawClaim: z.ZodString;
|
|
262
|
+
claimFamilyId: z.ZodString;
|
|
263
|
+
canonicalName: z.ZodString;
|
|
264
|
+
matchedAlias: z.ZodString;
|
|
265
|
+
confidence: z.ZodNumber;
|
|
266
|
+
sourceTypeIds: z.ZodArray<z.ZodString>;
|
|
267
|
+
sourceRequirements: z.ZodArray<z.ZodObject<{
|
|
268
|
+
sourceTypeId: z.ZodString;
|
|
269
|
+
requiredFields: z.ZodArray<z.ZodString>;
|
|
270
|
+
minimumSourceAuthority: z.ZodEnum<{
|
|
271
|
+
official_registry: "official_registry";
|
|
272
|
+
programme_operator: "programme_operator";
|
|
273
|
+
third_party_verified: "third_party_verified";
|
|
274
|
+
manufacturer_declared: "manufacturer_declared";
|
|
275
|
+
expert_interpretation: "expert_interpretation";
|
|
276
|
+
}>;
|
|
277
|
+
caveats: z.ZodArray<z.ZodString>;
|
|
278
|
+
}, z.core.$strip>>;
|
|
279
|
+
impactAreas: z.ZodArray<z.ZodEnum<{
|
|
280
|
+
climate_health: "climate_health";
|
|
281
|
+
human_health: "human_health";
|
|
282
|
+
ecosystem_health: "ecosystem_health";
|
|
283
|
+
social_health_equity: "social_health_equity";
|
|
284
|
+
circular_economy: "circular_economy";
|
|
285
|
+
}>>;
|
|
286
|
+
greenwashingRisk: z.ZodEnum<{
|
|
287
|
+
low: "low";
|
|
288
|
+
medium: "medium";
|
|
289
|
+
high: "high";
|
|
290
|
+
}>;
|
|
291
|
+
}, z.core.$strip>;
|
|
292
|
+
declare const claimAnalysisSchema: z.ZodObject<{
|
|
293
|
+
kind: z.ZodLiteral<"claimAnalysis">;
|
|
294
|
+
items: z.ZodArray<z.ZodObject<{
|
|
295
|
+
rawClaim: z.ZodString;
|
|
296
|
+
claimFamilyId: z.ZodString;
|
|
297
|
+
canonicalName: z.ZodString;
|
|
298
|
+
matchedAlias: z.ZodString;
|
|
299
|
+
confidence: z.ZodNumber;
|
|
300
|
+
sourceTypeIds: z.ZodArray<z.ZodString>;
|
|
301
|
+
sourceRequirements: z.ZodArray<z.ZodObject<{
|
|
302
|
+
sourceTypeId: z.ZodString;
|
|
303
|
+
requiredFields: z.ZodArray<z.ZodString>;
|
|
304
|
+
minimumSourceAuthority: z.ZodEnum<{
|
|
305
|
+
official_registry: "official_registry";
|
|
306
|
+
programme_operator: "programme_operator";
|
|
307
|
+
third_party_verified: "third_party_verified";
|
|
308
|
+
manufacturer_declared: "manufacturer_declared";
|
|
309
|
+
expert_interpretation: "expert_interpretation";
|
|
310
|
+
}>;
|
|
311
|
+
caveats: z.ZodArray<z.ZodString>;
|
|
312
|
+
}, z.core.$strip>>;
|
|
313
|
+
impactAreas: z.ZodArray<z.ZodEnum<{
|
|
314
|
+
climate_health: "climate_health";
|
|
315
|
+
human_health: "human_health";
|
|
316
|
+
ecosystem_health: "ecosystem_health";
|
|
317
|
+
social_health_equity: "social_health_equity";
|
|
318
|
+
circular_economy: "circular_economy";
|
|
319
|
+
}>>;
|
|
320
|
+
greenwashingRisk: z.ZodEnum<{
|
|
321
|
+
low: "low";
|
|
322
|
+
medium: "medium";
|
|
323
|
+
high: "high";
|
|
324
|
+
}>;
|
|
325
|
+
}, z.core.$strip>>;
|
|
326
|
+
totalInputCount: z.ZodNumber;
|
|
327
|
+
matchedCount: z.ZodNumber;
|
|
328
|
+
unmatchedCount: z.ZodNumber;
|
|
329
|
+
unmatchedRawClaims: z.ZodArray<z.ZodString>;
|
|
330
|
+
coverageRatio: z.ZodNumber;
|
|
331
|
+
}, z.core.$strip>;
|
|
332
|
+
declare const sourceFragmentKindSchema: z.ZodEnum<{
|
|
333
|
+
pim_attribute: "pim_attribute";
|
|
334
|
+
certificate_field: "certificate_field";
|
|
335
|
+
pdf_table_row: "pdf_table_row";
|
|
336
|
+
registry_entry: "registry_entry";
|
|
337
|
+
manufacturer_statement: "manufacturer_statement";
|
|
338
|
+
pdp_claim_block: "pdp_claim_block";
|
|
339
|
+
}>;
|
|
340
|
+
declare const sourceFragmentValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
|
|
341
|
+
declare const sourceFragmentSchema: z.ZodObject<{
|
|
342
|
+
fragmentId: z.ZodOptional<z.ZodString>;
|
|
343
|
+
fragmentKind: z.ZodEnum<{
|
|
344
|
+
pim_attribute: "pim_attribute";
|
|
345
|
+
certificate_field: "certificate_field";
|
|
346
|
+
pdf_table_row: "pdf_table_row";
|
|
347
|
+
registry_entry: "registry_entry";
|
|
348
|
+
manufacturer_statement: "manufacturer_statement";
|
|
349
|
+
pdp_claim_block: "pdp_claim_block";
|
|
350
|
+
}>;
|
|
351
|
+
sourceSystem: z.ZodString;
|
|
352
|
+
attributeId: z.ZodOptional<z.ZodString>;
|
|
353
|
+
rawText: z.ZodOptional<z.ZodString>;
|
|
354
|
+
rawValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
|
|
355
|
+
sourceRecordId: z.ZodOptional<z.ZodString>;
|
|
356
|
+
sourceAuthorityTier: z.ZodOptional<z.ZodEnum<{
|
|
357
|
+
official_registry: "official_registry";
|
|
358
|
+
programme_operator: "programme_operator";
|
|
359
|
+
third_party_verified: "third_party_verified";
|
|
360
|
+
manufacturer_declared: "manufacturer_declared";
|
|
361
|
+
expert_interpretation: "expert_interpretation";
|
|
362
|
+
}>>;
|
|
363
|
+
context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
|
|
364
|
+
}, z.core.$strip>;
|
|
365
|
+
declare const sourceFragmentStatusSchema: z.ZodEnum<{
|
|
366
|
+
mapped: "mapped";
|
|
367
|
+
unmapped: "unmapped";
|
|
368
|
+
empty: "empty";
|
|
369
|
+
}>;
|
|
370
|
+
declare const sourceFragmentAnalysisItemSchema: z.ZodObject<{
|
|
371
|
+
sourceFragmentId: z.ZodString;
|
|
372
|
+
status: z.ZodEnum<{
|
|
373
|
+
mapped: "mapped";
|
|
374
|
+
unmapped: "unmapped";
|
|
375
|
+
empty: "empty";
|
|
376
|
+
}>;
|
|
377
|
+
fragmentKind: z.ZodEnum<{
|
|
378
|
+
pim_attribute: "pim_attribute";
|
|
379
|
+
certificate_field: "certificate_field";
|
|
380
|
+
pdf_table_row: "pdf_table_row";
|
|
381
|
+
registry_entry: "registry_entry";
|
|
382
|
+
manufacturer_statement: "manufacturer_statement";
|
|
383
|
+
pdp_claim_block: "pdp_claim_block";
|
|
384
|
+
}>;
|
|
385
|
+
sourceSystem: z.ZodString;
|
|
386
|
+
attributeId: z.ZodOptional<z.ZodString>;
|
|
387
|
+
sourceRecordId: z.ZodOptional<z.ZodString>;
|
|
388
|
+
rawText: z.ZodString;
|
|
389
|
+
conceptId: z.ZodOptional<z.ZodString>;
|
|
390
|
+
claimFamilyIds: z.ZodArray<z.ZodString>;
|
|
391
|
+
sourceTypeIds: z.ZodArray<z.ZodString>;
|
|
392
|
+
requiredContextFields: z.ZodArray<z.ZodString>;
|
|
393
|
+
missingContextFields: z.ZodArray<z.ZodString>;
|
|
394
|
+
greenwashingRisks: z.ZodArray<z.ZodEnum<{
|
|
395
|
+
low: "low";
|
|
396
|
+
medium: "medium";
|
|
397
|
+
high: "high";
|
|
398
|
+
}>>;
|
|
399
|
+
notes: z.ZodArray<z.ZodString>;
|
|
400
|
+
}, z.core.$strip>;
|
|
401
|
+
declare const sourceFragmentAnalysisSchema: z.ZodObject<{
|
|
402
|
+
kind: z.ZodLiteral<"sourceFragmentAnalysis">;
|
|
403
|
+
items: z.ZodArray<z.ZodObject<{
|
|
404
|
+
sourceFragmentId: z.ZodString;
|
|
405
|
+
status: z.ZodEnum<{
|
|
406
|
+
mapped: "mapped";
|
|
407
|
+
unmapped: "unmapped";
|
|
408
|
+
empty: "empty";
|
|
409
|
+
}>;
|
|
410
|
+
fragmentKind: z.ZodEnum<{
|
|
411
|
+
pim_attribute: "pim_attribute";
|
|
412
|
+
certificate_field: "certificate_field";
|
|
413
|
+
pdf_table_row: "pdf_table_row";
|
|
414
|
+
registry_entry: "registry_entry";
|
|
415
|
+
manufacturer_statement: "manufacturer_statement";
|
|
416
|
+
pdp_claim_block: "pdp_claim_block";
|
|
417
|
+
}>;
|
|
418
|
+
sourceSystem: z.ZodString;
|
|
419
|
+
attributeId: z.ZodOptional<z.ZodString>;
|
|
420
|
+
sourceRecordId: z.ZodOptional<z.ZodString>;
|
|
421
|
+
rawText: z.ZodString;
|
|
422
|
+
conceptId: z.ZodOptional<z.ZodString>;
|
|
423
|
+
claimFamilyIds: z.ZodArray<z.ZodString>;
|
|
424
|
+
sourceTypeIds: z.ZodArray<z.ZodString>;
|
|
425
|
+
requiredContextFields: z.ZodArray<z.ZodString>;
|
|
426
|
+
missingContextFields: z.ZodArray<z.ZodString>;
|
|
427
|
+
greenwashingRisks: z.ZodArray<z.ZodEnum<{
|
|
428
|
+
low: "low";
|
|
429
|
+
medium: "medium";
|
|
430
|
+
high: "high";
|
|
431
|
+
}>>;
|
|
432
|
+
notes: z.ZodArray<z.ZodString>;
|
|
433
|
+
}, z.core.$strip>>;
|
|
434
|
+
totalInputCount: z.ZodNumber;
|
|
435
|
+
mappedCount: z.ZodNumber;
|
|
436
|
+
unmappedCount: z.ZodNumber;
|
|
437
|
+
emptyCount: z.ZodNumber;
|
|
438
|
+
coverageRatio: z.ZodNumber;
|
|
439
|
+
}, z.core.$strip>;
|
|
440
|
+
type ClaimFamily = z.infer<typeof claimFamilySchema>;
|
|
441
|
+
type ClaimAnalysis = z.infer<typeof claimAnalysisSchema>;
|
|
442
|
+
type ClaimClassification = z.infer<typeof claimClassificationSchema>;
|
|
443
|
+
type Framework = z.infer<typeof frameworkSchema>;
|
|
444
|
+
type FrameworkCategory = z.infer<typeof frameworkCategorySchema>;
|
|
445
|
+
type SourceTypeCategory = z.infer<typeof sourceTypeCategorySchema>;
|
|
446
|
+
type SourceRequirement = z.infer<typeof sourceRequirementSchema>;
|
|
447
|
+
type SourceFragment = z.infer<typeof sourceFragmentSchema>;
|
|
448
|
+
type SourceFragmentAnalysis = z.infer<typeof sourceFragmentAnalysisSchema>;
|
|
449
|
+
type SourceFragmentAnalysisItem = z.infer<typeof sourceFragmentAnalysisItemSchema>;
|
|
450
|
+
type SourceType = z.infer<typeof sourceTypeSchema>;
|
|
451
|
+
type ImpactArea = z.infer<typeof impactAreaSchema>;
|
|
452
|
+
type ReferenceLookupKind = "claimFamily" | "framework" | "sourceType";
|
|
453
|
+
type ReferenceLookupInput = {
|
|
454
|
+
id: string;
|
|
455
|
+
kind: ReferenceLookupKind;
|
|
456
|
+
};
|
|
457
|
+
type ReferenceLookup = {
|
|
458
|
+
kind: "referenceLookup";
|
|
459
|
+
related: {
|
|
460
|
+
claimFamilies: ClaimFamily[];
|
|
461
|
+
frameworks: Framework[];
|
|
462
|
+
sourceTypes: SourceType[];
|
|
463
|
+
};
|
|
464
|
+
target: ClaimFamily | Framework | SourceType;
|
|
465
|
+
targetKind: ReferenceLookupKind;
|
|
466
|
+
};
|
|
467
|
+
declare const referenceSearchItemSchema: z.ZodObject<{
|
|
468
|
+
targetKind: z.ZodEnum<{
|
|
469
|
+
claimFamily: "claimFamily";
|
|
470
|
+
framework: "framework";
|
|
471
|
+
sourceType: "sourceType";
|
|
472
|
+
}>;
|
|
473
|
+
id: z.ZodString;
|
|
474
|
+
label: z.ZodString;
|
|
475
|
+
score: z.ZodNumber;
|
|
476
|
+
matchedFields: z.ZodArray<z.ZodString>;
|
|
477
|
+
related: z.ZodObject<{
|
|
478
|
+
claimFamilyIds: z.ZodArray<z.ZodString>;
|
|
479
|
+
frameworkIds: z.ZodArray<z.ZodString>;
|
|
480
|
+
sourceTypeIds: z.ZodArray<z.ZodString>;
|
|
481
|
+
}, z.core.$strip>;
|
|
482
|
+
}, z.core.$strip>;
|
|
483
|
+
declare const referenceSearchSchema: z.ZodObject<{
|
|
484
|
+
kind: z.ZodLiteral<"referenceSearch">;
|
|
485
|
+
query: z.ZodString;
|
|
486
|
+
items: z.ZodArray<z.ZodObject<{
|
|
487
|
+
targetKind: z.ZodEnum<{
|
|
488
|
+
claimFamily: "claimFamily";
|
|
489
|
+
framework: "framework";
|
|
490
|
+
sourceType: "sourceType";
|
|
491
|
+
}>;
|
|
492
|
+
id: z.ZodString;
|
|
493
|
+
label: z.ZodString;
|
|
494
|
+
score: z.ZodNumber;
|
|
495
|
+
matchedFields: z.ZodArray<z.ZodString>;
|
|
496
|
+
related: z.ZodObject<{
|
|
497
|
+
claimFamilyIds: z.ZodArray<z.ZodString>;
|
|
498
|
+
frameworkIds: z.ZodArray<z.ZodString>;
|
|
499
|
+
sourceTypeIds: z.ZodArray<z.ZodString>;
|
|
500
|
+
}, z.core.$strip>;
|
|
501
|
+
}, z.core.$strip>>;
|
|
502
|
+
totalCount: z.ZodNumber;
|
|
503
|
+
}, z.core.$strip>;
|
|
504
|
+
type ReferenceSearchInput = {
|
|
505
|
+
limit?: number;
|
|
506
|
+
query: string;
|
|
507
|
+
};
|
|
508
|
+
type ReferenceSearchItem = z.infer<typeof referenceSearchItemSchema>;
|
|
509
|
+
type ReferenceSearch = z.infer<typeof referenceSearchSchema>;
|
|
510
|
+
type ReferenceCorpus = {
|
|
511
|
+
claimFamilies: readonly ClaimFamily[];
|
|
512
|
+
frameworks: readonly Framework[];
|
|
513
|
+
sourceTypes: readonly SourceType[];
|
|
514
|
+
};
|
|
515
|
+
declare const frameworks: readonly Framework[];
|
|
516
|
+
declare const sourceTypes: readonly SourceType[];
|
|
517
|
+
declare const claimFamilies: readonly ClaimFamily[];
|
|
518
|
+
declare function classifyClaims(raw: string): ClaimClassification[];
|
|
519
|
+
declare function analyzeClaimCorpus(corpus: ReferenceCorpus, raw: string): ClaimAnalysis;
|
|
520
|
+
declare function analyzeClaims(raw: string): ClaimAnalysis;
|
|
521
|
+
declare function analyzeSourceFragmentCorpus(corpus: ReferenceCorpus, fragments: readonly SourceFragment[]): SourceFragmentAnalysis;
|
|
522
|
+
declare function analyzeSourceFragments(fragments: readonly SourceFragment[]): SourceFragmentAnalysis;
|
|
523
|
+
declare function getClaimFamily(claimFamilyId: string): ClaimFamily;
|
|
524
|
+
declare function getFramework(frameworkId: string): Framework;
|
|
525
|
+
declare function getSourceType(sourceTypeId: string): SourceType;
|
|
526
|
+
declare function getSourceRequirements(claimFamilyId: string): SourceRequirement[];
|
|
527
|
+
declare function searchReferenceCorpus(corpus: ReferenceCorpus, input: ReferenceSearchInput): ReferenceSearch;
|
|
528
|
+
declare function searchReferences(input: ReferenceSearchInput): ReferenceSearch;
|
|
529
|
+
declare function lookupReferenceCorpus(corpus: ReferenceCorpus, input: ReferenceLookupInput): ReferenceLookup;
|
|
530
|
+
declare function lookupReference(input: ReferenceLookupInput): ReferenceLookup;
|
|
531
|
+
|
|
532
|
+
type GreenwashLens = {
|
|
533
|
+
reads: string;
|
|
534
|
+
proves: string;
|
|
535
|
+
watchFor: string;
|
|
536
|
+
};
|
|
537
|
+
declare const greenwashLensById: Record<string, GreenwashLens>;
|
|
538
|
+
declare function getGreenwashLens(claimFamilyId: string): GreenwashLens | null;
|
|
539
|
+
|
|
540
|
+
declare const contextEffectSchema: z.ZodEnum<{
|
|
541
|
+
insufficient_alone: "insufficient_alone";
|
|
542
|
+
not_applicable: "not_applicable";
|
|
543
|
+
regulated: "regulated";
|
|
544
|
+
required: "required";
|
|
545
|
+
strengthens: "strengthens";
|
|
546
|
+
relevant: "relevant";
|
|
547
|
+
}>;
|
|
548
|
+
declare const useContextSchema: z.ZodEnum<{
|
|
549
|
+
healthcare: "healthcare";
|
|
550
|
+
education: "education";
|
|
551
|
+
workplace: "workplace";
|
|
552
|
+
hospitality: "hospitality";
|
|
553
|
+
residential: "residential";
|
|
554
|
+
laboratory: "laboratory";
|
|
555
|
+
interior_general: "interior_general";
|
|
556
|
+
}>;
|
|
557
|
+
declare const regionSchema: z.ZodEnum<{
|
|
558
|
+
california: "california";
|
|
559
|
+
us_general: "us_general";
|
|
560
|
+
eu: "eu";
|
|
561
|
+
uk: "uk";
|
|
562
|
+
nordics: "nordics";
|
|
563
|
+
global: "global";
|
|
564
|
+
}>;
|
|
565
|
+
declare const contextRefKindSchema: z.ZodEnum<{
|
|
566
|
+
claimFamily: "claimFamily";
|
|
567
|
+
framework: "framework";
|
|
568
|
+
sourceType: "sourceType";
|
|
569
|
+
}>;
|
|
570
|
+
declare const contextRequirementSchema: z.ZodObject<{
|
|
571
|
+
refKind: z.ZodEnum<{
|
|
572
|
+
claimFamily: "claimFamily";
|
|
573
|
+
framework: "framework";
|
|
574
|
+
sourceType: "sourceType";
|
|
575
|
+
}>;
|
|
576
|
+
refId: z.ZodString;
|
|
577
|
+
effect: z.ZodEnum<{
|
|
578
|
+
insufficient_alone: "insufficient_alone";
|
|
579
|
+
not_applicable: "not_applicable";
|
|
580
|
+
regulated: "regulated";
|
|
581
|
+
required: "required";
|
|
582
|
+
strengthens: "strengthens";
|
|
583
|
+
relevant: "relevant";
|
|
584
|
+
}>;
|
|
585
|
+
rationale: z.ZodString;
|
|
586
|
+
caveat: z.ZodOptional<z.ZodString>;
|
|
587
|
+
source: z.ZodOptional<z.ZodObject<{
|
|
588
|
+
label: z.ZodString;
|
|
589
|
+
url: z.ZodString;
|
|
590
|
+
}, z.core.$strip>>;
|
|
591
|
+
}, z.core.$strip>;
|
|
592
|
+
declare const decisionContextSchema: z.ZodObject<{
|
|
593
|
+
contextId: z.ZodString;
|
|
594
|
+
label: z.ZodString;
|
|
595
|
+
materialCategory: z.ZodString;
|
|
596
|
+
useContext: z.ZodEnum<{
|
|
597
|
+
healthcare: "healthcare";
|
|
598
|
+
education: "education";
|
|
599
|
+
workplace: "workplace";
|
|
600
|
+
hospitality: "hospitality";
|
|
601
|
+
residential: "residential";
|
|
602
|
+
laboratory: "laboratory";
|
|
603
|
+
interior_general: "interior_general";
|
|
604
|
+
}>;
|
|
605
|
+
region: z.ZodEnum<{
|
|
606
|
+
california: "california";
|
|
607
|
+
us_general: "us_general";
|
|
608
|
+
eu: "eu";
|
|
609
|
+
uk: "uk";
|
|
610
|
+
nordics: "nordics";
|
|
611
|
+
global: "global";
|
|
612
|
+
}>;
|
|
613
|
+
target: z.ZodNullable<z.ZodObject<{
|
|
614
|
+
frameworkId: z.ZodString;
|
|
615
|
+
ruleVersionId: z.ZodString;
|
|
616
|
+
}, z.core.$strip>>;
|
|
617
|
+
summary: z.ZodString;
|
|
618
|
+
teaching: z.ZodString;
|
|
619
|
+
requirements: z.ZodArray<z.ZodObject<{
|
|
620
|
+
refKind: z.ZodEnum<{
|
|
621
|
+
claimFamily: "claimFamily";
|
|
622
|
+
framework: "framework";
|
|
623
|
+
sourceType: "sourceType";
|
|
624
|
+
}>;
|
|
625
|
+
refId: z.ZodString;
|
|
626
|
+
effect: z.ZodEnum<{
|
|
627
|
+
insufficient_alone: "insufficient_alone";
|
|
628
|
+
not_applicable: "not_applicable";
|
|
629
|
+
regulated: "regulated";
|
|
630
|
+
required: "required";
|
|
631
|
+
strengthens: "strengthens";
|
|
632
|
+
relevant: "relevant";
|
|
633
|
+
}>;
|
|
634
|
+
rationale: z.ZodString;
|
|
635
|
+
caveat: z.ZodOptional<z.ZodString>;
|
|
636
|
+
source: z.ZodOptional<z.ZodObject<{
|
|
637
|
+
label: z.ZodString;
|
|
638
|
+
url: z.ZodString;
|
|
639
|
+
}, z.core.$strip>>;
|
|
640
|
+
}, z.core.$strip>>;
|
|
641
|
+
caveats: z.ZodArray<z.ZodString>;
|
|
642
|
+
sources: z.ZodArray<z.ZodObject<{
|
|
643
|
+
label: z.ZodString;
|
|
644
|
+
url: z.ZodString;
|
|
645
|
+
}, z.core.$strip>>;
|
|
646
|
+
reviewStatus: z.ZodEnum<{
|
|
647
|
+
draft: "draft";
|
|
648
|
+
reviewed: "reviewed";
|
|
649
|
+
disputed: "disputed";
|
|
650
|
+
deprecated: "deprecated";
|
|
651
|
+
}>;
|
|
652
|
+
}, z.core.$strip>;
|
|
653
|
+
type ContextEffect = z.infer<typeof contextEffectSchema>;
|
|
654
|
+
type UseContext = z.infer<typeof useContextSchema>;
|
|
655
|
+
type Region = z.infer<typeof regionSchema>;
|
|
656
|
+
type ContextRequirement = z.infer<typeof contextRequirementSchema>;
|
|
657
|
+
type DecisionContext = z.infer<typeof decisionContextSchema>;
|
|
658
|
+
declare const decisionContexts: readonly DecisionContext[];
|
|
659
|
+
declare function getDecisionContext(contextId: string): DecisionContext;
|
|
660
|
+
declare const contextEffectOrder: readonly ContextEffect[];
|
|
661
|
+
declare const contextEffectLabels: Record<ContextEffect, string>;
|
|
662
|
+
declare const useContextLabels: Record<UseContext, string>;
|
|
663
|
+
declare const regionLabels: Record<Region, string>;
|
|
664
|
+
type ContextMatchInput = {
|
|
665
|
+
query?: string;
|
|
666
|
+
target?: string;
|
|
667
|
+
useContext?: UseContext;
|
|
668
|
+
region?: Region;
|
|
669
|
+
};
|
|
670
|
+
type ContextMatch = {
|
|
671
|
+
context: DecisionContext;
|
|
672
|
+
confidence: number;
|
|
673
|
+
signals: string[];
|
|
674
|
+
};
|
|
675
|
+
declare function matchDecisionContext(input: ContextMatchInput): ContextMatch | null;
|
|
676
|
+
declare const contextAssessmentItemSchema: z.ZodObject<{
|
|
677
|
+
refKind: z.ZodEnum<{
|
|
678
|
+
claimFamily: "claimFamily";
|
|
679
|
+
framework: "framework";
|
|
680
|
+
sourceType: "sourceType";
|
|
681
|
+
}>;
|
|
682
|
+
refId: z.ZodString;
|
|
683
|
+
label: z.ZodString;
|
|
684
|
+
effect: z.ZodEnum<{
|
|
685
|
+
insufficient_alone: "insufficient_alone";
|
|
686
|
+
not_applicable: "not_applicable";
|
|
687
|
+
regulated: "regulated";
|
|
688
|
+
required: "required";
|
|
689
|
+
strengthens: "strengthens";
|
|
690
|
+
relevant: "relevant";
|
|
691
|
+
}>;
|
|
692
|
+
rationale: z.ZodString;
|
|
693
|
+
caveat: z.ZodOptional<z.ZodString>;
|
|
694
|
+
source: z.ZodOptional<z.ZodObject<{
|
|
695
|
+
label: z.ZodString;
|
|
696
|
+
url: z.ZodString;
|
|
697
|
+
}, z.core.$strip>>;
|
|
698
|
+
held: z.ZodBoolean;
|
|
699
|
+
}, z.core.$strip>;
|
|
700
|
+
declare const contextAssessmentGroupSchema: z.ZodObject<{
|
|
701
|
+
effect: z.ZodEnum<{
|
|
702
|
+
insufficient_alone: "insufficient_alone";
|
|
703
|
+
not_applicable: "not_applicable";
|
|
704
|
+
regulated: "regulated";
|
|
705
|
+
required: "required";
|
|
706
|
+
strengthens: "strengthens";
|
|
707
|
+
relevant: "relevant";
|
|
708
|
+
}>;
|
|
709
|
+
effectLabel: z.ZodString;
|
|
710
|
+
items: z.ZodArray<z.ZodObject<{
|
|
711
|
+
refKind: z.ZodEnum<{
|
|
712
|
+
claimFamily: "claimFamily";
|
|
713
|
+
framework: "framework";
|
|
714
|
+
sourceType: "sourceType";
|
|
715
|
+
}>;
|
|
716
|
+
refId: z.ZodString;
|
|
717
|
+
label: z.ZodString;
|
|
718
|
+
effect: z.ZodEnum<{
|
|
719
|
+
insufficient_alone: "insufficient_alone";
|
|
720
|
+
not_applicable: "not_applicable";
|
|
721
|
+
regulated: "regulated";
|
|
722
|
+
required: "required";
|
|
723
|
+
strengthens: "strengthens";
|
|
724
|
+
relevant: "relevant";
|
|
725
|
+
}>;
|
|
726
|
+
rationale: z.ZodString;
|
|
727
|
+
caveat: z.ZodOptional<z.ZodString>;
|
|
728
|
+
source: z.ZodOptional<z.ZodObject<{
|
|
729
|
+
label: z.ZodString;
|
|
730
|
+
url: z.ZodString;
|
|
731
|
+
}, z.core.$strip>>;
|
|
732
|
+
held: z.ZodBoolean;
|
|
733
|
+
}, z.core.$strip>>;
|
|
734
|
+
}, z.core.$strip>;
|
|
735
|
+
declare const contextAssessmentSchema: z.ZodObject<{
|
|
736
|
+
kind: z.ZodLiteral<"contextAssessment">;
|
|
737
|
+
contextId: z.ZodString;
|
|
738
|
+
label: z.ZodString;
|
|
739
|
+
summary: z.ZodString;
|
|
740
|
+
teaching: z.ZodString;
|
|
741
|
+
target: z.ZodNullable<z.ZodObject<{
|
|
742
|
+
frameworkId: z.ZodString;
|
|
743
|
+
frameworkName: z.ZodString;
|
|
744
|
+
ruleVersionId: z.ZodString;
|
|
745
|
+
}, z.core.$strip>>;
|
|
746
|
+
useContext: z.ZodEnum<{
|
|
747
|
+
healthcare: "healthcare";
|
|
748
|
+
education: "education";
|
|
749
|
+
workplace: "workplace";
|
|
750
|
+
hospitality: "hospitality";
|
|
751
|
+
residential: "residential";
|
|
752
|
+
laboratory: "laboratory";
|
|
753
|
+
interior_general: "interior_general";
|
|
754
|
+
}>;
|
|
755
|
+
region: z.ZodEnum<{
|
|
756
|
+
california: "california";
|
|
757
|
+
us_general: "us_general";
|
|
758
|
+
eu: "eu";
|
|
759
|
+
uk: "uk";
|
|
760
|
+
nordics: "nordics";
|
|
761
|
+
global: "global";
|
|
762
|
+
}>;
|
|
763
|
+
materialCategory: z.ZodString;
|
|
764
|
+
matchConfidence: z.ZodNumber;
|
|
765
|
+
matchSignals: z.ZodArray<z.ZodString>;
|
|
766
|
+
groups: z.ZodArray<z.ZodObject<{
|
|
767
|
+
effect: z.ZodEnum<{
|
|
768
|
+
insufficient_alone: "insufficient_alone";
|
|
769
|
+
not_applicable: "not_applicable";
|
|
770
|
+
regulated: "regulated";
|
|
771
|
+
required: "required";
|
|
772
|
+
strengthens: "strengthens";
|
|
773
|
+
relevant: "relevant";
|
|
774
|
+
}>;
|
|
775
|
+
effectLabel: z.ZodString;
|
|
776
|
+
items: z.ZodArray<z.ZodObject<{
|
|
777
|
+
refKind: z.ZodEnum<{
|
|
778
|
+
claimFamily: "claimFamily";
|
|
779
|
+
framework: "framework";
|
|
780
|
+
sourceType: "sourceType";
|
|
781
|
+
}>;
|
|
782
|
+
refId: z.ZodString;
|
|
783
|
+
label: z.ZodString;
|
|
784
|
+
effect: z.ZodEnum<{
|
|
785
|
+
insufficient_alone: "insufficient_alone";
|
|
786
|
+
not_applicable: "not_applicable";
|
|
787
|
+
regulated: "regulated";
|
|
788
|
+
required: "required";
|
|
789
|
+
strengthens: "strengthens";
|
|
790
|
+
relevant: "relevant";
|
|
791
|
+
}>;
|
|
792
|
+
rationale: z.ZodString;
|
|
793
|
+
caveat: z.ZodOptional<z.ZodString>;
|
|
794
|
+
source: z.ZodOptional<z.ZodObject<{
|
|
795
|
+
label: z.ZodString;
|
|
796
|
+
url: z.ZodString;
|
|
797
|
+
}, z.core.$strip>>;
|
|
798
|
+
held: z.ZodBoolean;
|
|
799
|
+
}, z.core.$strip>>;
|
|
800
|
+
}, z.core.$strip>>;
|
|
801
|
+
unmappedHeld: z.ZodArray<z.ZodString>;
|
|
802
|
+
caveats: z.ZodArray<z.ZodString>;
|
|
803
|
+
}, z.core.$strip>;
|
|
804
|
+
type ContextAssessment = z.infer<typeof contextAssessmentSchema>;
|
|
805
|
+
declare function assessContext(match: ContextMatch, held?: readonly string[]): ContextAssessment;
|
|
806
|
+
declare function validateDecisionContextRefs(): string[];
|
|
807
|
+
|
|
808
|
+
declare const claimVocabulary: {
|
|
809
|
+
id: string;
|
|
810
|
+
name: string;
|
|
811
|
+
definition: string;
|
|
812
|
+
kind: "certification" | "declaration" | "standard_method" | "chemical_exclusion" | "rating_system_hint" | "origin_claim" | "impact_metric" | "program_participation" | "circularity_claim" | "organizational_commitment";
|
|
813
|
+
}[];
|
|
814
|
+
type TypedValue = {
|
|
815
|
+
kind: "number";
|
|
816
|
+
raw: string;
|
|
817
|
+
number: number;
|
|
818
|
+
unit: string;
|
|
819
|
+
} | {
|
|
820
|
+
kind: "boolean";
|
|
821
|
+
raw: string;
|
|
822
|
+
bool: boolean;
|
|
823
|
+
} | {
|
|
824
|
+
kind: "text";
|
|
825
|
+
raw: string;
|
|
826
|
+
};
|
|
827
|
+
declare const extractedClaimSchema: z.ZodObject<{
|
|
828
|
+
claimFamilyId: z.ZodEnum<{
|
|
829
|
+
[x: string]: string;
|
|
830
|
+
}>;
|
|
831
|
+
quote: z.ZodString;
|
|
832
|
+
value: z.ZodObject<{
|
|
833
|
+
kind: z.ZodEnum<{
|
|
834
|
+
number: "number";
|
|
835
|
+
boolean: "boolean";
|
|
836
|
+
text: "text";
|
|
837
|
+
}>;
|
|
838
|
+
raw: z.ZodString;
|
|
839
|
+
number: z.ZodNumber;
|
|
840
|
+
unit: z.ZodString;
|
|
841
|
+
bool: z.ZodBoolean;
|
|
842
|
+
}, z.core.$strip>;
|
|
843
|
+
}, z.core.$strip>;
|
|
844
|
+
type ExtractedClaim = z.infer<typeof extractedClaimSchema>;
|
|
845
|
+
declare const materialExtractionSchema: z.ZodObject<{
|
|
846
|
+
productName: z.ZodString;
|
|
847
|
+
claims: z.ZodArray<z.ZodObject<{
|
|
848
|
+
claimFamilyId: z.ZodEnum<{
|
|
849
|
+
[x: string]: string;
|
|
850
|
+
}>;
|
|
851
|
+
quote: z.ZodString;
|
|
852
|
+
value: z.ZodObject<{
|
|
853
|
+
kind: z.ZodEnum<{
|
|
854
|
+
number: "number";
|
|
855
|
+
boolean: "boolean";
|
|
856
|
+
text: "text";
|
|
857
|
+
}>;
|
|
858
|
+
raw: z.ZodString;
|
|
859
|
+
number: z.ZodNumber;
|
|
860
|
+
unit: z.ZodString;
|
|
861
|
+
bool: z.ZodBoolean;
|
|
862
|
+
}, z.core.$strip>;
|
|
863
|
+
}, z.core.$strip>>;
|
|
864
|
+
}, z.core.$strip>;
|
|
865
|
+
type MaterialExtraction = z.infer<typeof materialExtractionSchema>;
|
|
866
|
+
type MaterialClaimRecord = {
|
|
867
|
+
claimFamilyId: string;
|
|
868
|
+
claimName: string;
|
|
869
|
+
claimKind: string;
|
|
870
|
+
matchedText: string;
|
|
871
|
+
value: TypedValue;
|
|
872
|
+
impactAreas: string[];
|
|
873
|
+
sourceTypeIds: string[];
|
|
874
|
+
requiredFields: string[];
|
|
875
|
+
missingFields: string[];
|
|
876
|
+
greenwashingRisk: "low" | "medium" | "high";
|
|
877
|
+
lens: GreenwashLens | null;
|
|
878
|
+
reviewStatus: "draft";
|
|
879
|
+
};
|
|
880
|
+
declare function enrichExtractedClaim(claim: ExtractedClaim): MaterialClaimRecord | null;
|
|
881
|
+
declare function enrichExtraction(extraction: MaterialExtraction): MaterialClaimRecord[];
|
|
882
|
+
|
|
883
|
+
export { type ClaimAnalysis, type ClaimClassification, type ClaimFamily, type ContextAssessment, type ContextEffect, type ContextMatch, type ContextMatchInput, type ContextRequirement, type DecisionContext, type ExtractedClaim, type Framework, type FrameworkCategory, type GreenwashLens, type ImpactArea, type MaterialClaimRecord, type MaterialExtraction, type ReferenceCorpus, type ReferenceLookup, type ReferenceLookupInput, type ReferenceLookupKind, type ReferenceSearch, type ReferenceSearchInput, type ReferenceSearchItem, type Region, type SourceFragment, type SourceFragmentAnalysis, type SourceFragmentAnalysisItem, type SourceRequirement, type SourceType, type SourceTypeCategory, type TypedValue, type UseContext, analyzeClaimCorpus, analyzeClaims, analyzeSourceFragmentCorpus, analyzeSourceFragments, assessContext, claimAnalysisSchema, claimClassificationSchema, claimFamilies, claimFamilySchema, claimKindSchema, claimVocabulary, classifyClaims, contextAssessmentGroupSchema, contextAssessmentItemSchema, contextAssessmentSchema, contextEffectLabels, contextEffectOrder, contextEffectSchema, contextRefKindSchema, contextRequirementSchema, decisionContextSchema, decisionContexts, enrichExtractedClaim, enrichExtraction, extractedClaimSchema, frameworkCategorySchema, frameworkMappingSchema, frameworkRelationshipSchema, frameworkRuleVersionSchema, frameworkSchema, frameworks, getClaimFamily, getDecisionContext, getFramework, getGreenwashLens, getSourceRequirements, getSourceType, greenwashLensById, greenwashingRiskSchema, impactAreaSchema, lookupReference, lookupReferenceCorpus, matchDecisionContext, materialExtractionSchema, referenceSearchItemSchema, referenceSearchSchema, regionLabels, regionSchema, reviewStatusSchema, searchReferenceCorpus, searchReferences, sourceAuthorityTierSchema, sourceFragmentAnalysisItemSchema, sourceFragmentAnalysisSchema, sourceFragmentKindSchema, sourceFragmentSchema, sourceFragmentStatusSchema, sourceFragmentValueSchema, sourceLinkSchema, sourceRequirementSchema, sourceTypeCategorySchema, sourceTypeSchema, sourceTypes, useContextLabels, useContextSchema, validateDecisionContextRefs };
|