@carrot-foundation/schemas 0.1.6 → 0.1.14
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/dist/index.d.ts +2 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/mass-id/index.d.ts +3 -0
- package/dist/mass-id/index.d.ts.map +1 -0
- package/dist/mass-id/mass-id.data.schema.d.ts +256 -0
- package/dist/mass-id/mass-id.data.schema.d.ts.map +1 -0
- package/dist/mass-id/mass-id.schema.d.ts +291 -0
- package/dist/mass-id/mass-id.schema.d.ts.map +1 -0
- package/dist/shared/base.schema.d.ts +111 -0
- package/dist/shared/base.schema.d.ts.map +1 -0
- package/dist/shared/definitions.schema.d.ts +96 -0
- package/dist/shared/definitions.schema.d.ts.map +1 -0
- package/dist/shared/entities/location.schema.d.ts +55 -0
- package/dist/shared/entities/location.schema.d.ts.map +1 -0
- package/dist/shared/entities/participant.schema.d.ts +8 -0
- package/dist/shared/entities/participant.schema.d.ts.map +1 -0
- package/dist/shared/helpers.schema.d.ts +4 -0
- package/dist/shared/helpers.schema.d.ts.map +1 -0
- package/dist/shared/nft.schema.d.ts +116 -0
- package/dist/shared/nft.schema.d.ts.map +1 -0
- package/package.json +1 -1
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mass-id/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC"}
|
|
@@ -0,0 +1,256 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
declare const LocalClassificationSchema: z.ZodObject<{
|
|
3
|
+
code: z.ZodString;
|
|
4
|
+
description: z.ZodString;
|
|
5
|
+
system: z.ZodString;
|
|
6
|
+
}, z.core.$strict>;
|
|
7
|
+
export type LocalClassification = z.infer<typeof LocalClassificationSchema>;
|
|
8
|
+
declare const MeasurementUnitSchema: z.ZodEnum<{
|
|
9
|
+
kg: "kg";
|
|
10
|
+
ton: "ton";
|
|
11
|
+
}>;
|
|
12
|
+
export type MeasurementUnit = z.infer<typeof MeasurementUnitSchema>;
|
|
13
|
+
declare const ContaminationLevelSchema: z.ZodEnum<{
|
|
14
|
+
None: "None";
|
|
15
|
+
Low: "Low";
|
|
16
|
+
Medium: "Medium";
|
|
17
|
+
High: "High";
|
|
18
|
+
}>;
|
|
19
|
+
export type ContaminationLevel = z.infer<typeof ContaminationLevelSchema>;
|
|
20
|
+
declare const WasteClassificationSchema: z.ZodObject<{
|
|
21
|
+
primary_type: z.ZodString;
|
|
22
|
+
subtype: z.ZodString;
|
|
23
|
+
local_classification: z.ZodOptional<z.ZodObject<{
|
|
24
|
+
code: z.ZodString;
|
|
25
|
+
description: z.ZodString;
|
|
26
|
+
system: z.ZodString;
|
|
27
|
+
}, z.core.$strict>>;
|
|
28
|
+
measurement_unit: z.ZodEnum<{
|
|
29
|
+
kg: "kg";
|
|
30
|
+
ton: "ton";
|
|
31
|
+
}>;
|
|
32
|
+
net_weight: z.ZodNumber;
|
|
33
|
+
contamination_level: z.ZodOptional<z.ZodEnum<{
|
|
34
|
+
None: "None";
|
|
35
|
+
Low: "Low";
|
|
36
|
+
Medium: "Medium";
|
|
37
|
+
High: "High";
|
|
38
|
+
}>>;
|
|
39
|
+
}, z.core.$strict>;
|
|
40
|
+
export type WasteClassification = z.infer<typeof WasteClassificationSchema>;
|
|
41
|
+
declare const EventAttributeFormatSchema: z.ZodEnum<{
|
|
42
|
+
KILOGRAM: "KILOGRAM";
|
|
43
|
+
DATE: "DATE";
|
|
44
|
+
CURRENCY: "CURRENCY";
|
|
45
|
+
PERCENTAGE: "PERCENTAGE";
|
|
46
|
+
COORDINATE: "COORDINATE";
|
|
47
|
+
}>;
|
|
48
|
+
export type EventAttributeFormat = z.infer<typeof EventAttributeFormatSchema>;
|
|
49
|
+
declare const EventAttributeSchema: z.ZodObject<{
|
|
50
|
+
name: z.ZodString;
|
|
51
|
+
value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
|
|
52
|
+
format: z.ZodOptional<z.ZodEnum<{
|
|
53
|
+
KILOGRAM: "KILOGRAM";
|
|
54
|
+
DATE: "DATE";
|
|
55
|
+
CURRENCY: "CURRENCY";
|
|
56
|
+
PERCENTAGE: "PERCENTAGE";
|
|
57
|
+
COORDINATE: "COORDINATE";
|
|
58
|
+
}>>;
|
|
59
|
+
}, z.core.$strict>;
|
|
60
|
+
export type EventAttribute = z.infer<typeof EventAttributeSchema>;
|
|
61
|
+
declare const EventDocumentSchema: z.ZodObject<{
|
|
62
|
+
type: z.ZodString;
|
|
63
|
+
document_number: z.ZodOptional<z.ZodString>;
|
|
64
|
+
reference: z.ZodString;
|
|
65
|
+
issue_date: z.ZodOptional<z.ZodISODate>;
|
|
66
|
+
issuer: z.ZodOptional<z.ZodString>;
|
|
67
|
+
}, z.core.$strict>;
|
|
68
|
+
export type EventDocumentation = z.infer<typeof EventDocumentSchema>;
|
|
69
|
+
declare const ChainOfCustodyEventSchema: z.ZodObject<{
|
|
70
|
+
event_id: z.ZodUUID;
|
|
71
|
+
event_name: z.ZodString;
|
|
72
|
+
description: z.ZodString;
|
|
73
|
+
timestamp: z.ZodISODateTime;
|
|
74
|
+
participant_id: z.ZodUUID;
|
|
75
|
+
location_id: z.ZodUUID;
|
|
76
|
+
weight: z.ZodOptional<z.ZodNumber>;
|
|
77
|
+
attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
78
|
+
name: z.ZodString;
|
|
79
|
+
value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
|
|
80
|
+
format: z.ZodOptional<z.ZodEnum<{
|
|
81
|
+
KILOGRAM: "KILOGRAM";
|
|
82
|
+
DATE: "DATE";
|
|
83
|
+
CURRENCY: "CURRENCY";
|
|
84
|
+
PERCENTAGE: "PERCENTAGE";
|
|
85
|
+
COORDINATE: "COORDINATE";
|
|
86
|
+
}>>;
|
|
87
|
+
}, z.core.$strict>>>;
|
|
88
|
+
documentation: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
89
|
+
type: z.ZodString;
|
|
90
|
+
document_number: z.ZodOptional<z.ZodString>;
|
|
91
|
+
reference: z.ZodString;
|
|
92
|
+
issue_date: z.ZodOptional<z.ZodISODate>;
|
|
93
|
+
issuer: z.ZodOptional<z.ZodString>;
|
|
94
|
+
}, z.core.$strict>>>;
|
|
95
|
+
notes: z.ZodOptional<z.ZodString>;
|
|
96
|
+
}, z.core.$strict>;
|
|
97
|
+
export type ChainOfCustodyEvent = z.infer<typeof ChainOfCustodyEventSchema>;
|
|
98
|
+
declare const ChainOfCustodySchema: z.ZodObject<{
|
|
99
|
+
events: z.ZodArray<z.ZodObject<{
|
|
100
|
+
event_id: z.ZodUUID;
|
|
101
|
+
event_name: z.ZodString;
|
|
102
|
+
description: z.ZodString;
|
|
103
|
+
timestamp: z.ZodISODateTime;
|
|
104
|
+
participant_id: z.ZodUUID;
|
|
105
|
+
location_id: z.ZodUUID;
|
|
106
|
+
weight: z.ZodOptional<z.ZodNumber>;
|
|
107
|
+
attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
108
|
+
name: z.ZodString;
|
|
109
|
+
value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
|
|
110
|
+
format: z.ZodOptional<z.ZodEnum<{
|
|
111
|
+
KILOGRAM: "KILOGRAM";
|
|
112
|
+
DATE: "DATE";
|
|
113
|
+
CURRENCY: "CURRENCY";
|
|
114
|
+
PERCENTAGE: "PERCENTAGE";
|
|
115
|
+
COORDINATE: "COORDINATE";
|
|
116
|
+
}>>;
|
|
117
|
+
}, z.core.$strict>>>;
|
|
118
|
+
documentation: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
119
|
+
type: z.ZodString;
|
|
120
|
+
document_number: z.ZodOptional<z.ZodString>;
|
|
121
|
+
reference: z.ZodString;
|
|
122
|
+
issue_date: z.ZodOptional<z.ZodISODate>;
|
|
123
|
+
issuer: z.ZodOptional<z.ZodString>;
|
|
124
|
+
}, z.core.$strict>>>;
|
|
125
|
+
notes: z.ZodOptional<z.ZodString>;
|
|
126
|
+
}, z.core.$strict>>;
|
|
127
|
+
total_distance_km: z.ZodNumber;
|
|
128
|
+
total_duration_hours: z.ZodNumber;
|
|
129
|
+
}, z.core.$strict>;
|
|
130
|
+
export type ChainOfCustody = z.infer<typeof ChainOfCustodySchema>;
|
|
131
|
+
declare const TransportRouteSchema: z.ZodObject<{
|
|
132
|
+
from_location_id: z.ZodUUID;
|
|
133
|
+
to_location_id: z.ZodUUID;
|
|
134
|
+
distance_km: z.ZodNumber;
|
|
135
|
+
transport_method: z.ZodString;
|
|
136
|
+
duration_hours: z.ZodNumber;
|
|
137
|
+
}, z.core.$strict>;
|
|
138
|
+
export type TransportRoute = z.infer<typeof TransportRouteSchema>;
|
|
139
|
+
declare const GeographicDataSchema: z.ZodObject<{
|
|
140
|
+
origin_location_id: z.ZodUUID;
|
|
141
|
+
processing_location_ids: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
|
|
142
|
+
final_destination_id: z.ZodUUID;
|
|
143
|
+
transport_routes: z.ZodArray<z.ZodObject<{
|
|
144
|
+
from_location_id: z.ZodUUID;
|
|
145
|
+
to_location_id: z.ZodUUID;
|
|
146
|
+
distance_km: z.ZodNumber;
|
|
147
|
+
transport_method: z.ZodString;
|
|
148
|
+
duration_hours: z.ZodNumber;
|
|
149
|
+
}, z.core.$strict>>;
|
|
150
|
+
}, z.core.$strict>;
|
|
151
|
+
export type GeographicData = z.infer<typeof GeographicDataSchema>;
|
|
152
|
+
export declare const MassIDDataSchema: z.ZodObject<{
|
|
153
|
+
waste_classification: z.ZodObject<{
|
|
154
|
+
primary_type: z.ZodString;
|
|
155
|
+
subtype: z.ZodString;
|
|
156
|
+
local_classification: z.ZodOptional<z.ZodObject<{
|
|
157
|
+
code: z.ZodString;
|
|
158
|
+
description: z.ZodString;
|
|
159
|
+
system: z.ZodString;
|
|
160
|
+
}, z.core.$strict>>;
|
|
161
|
+
measurement_unit: z.ZodEnum<{
|
|
162
|
+
kg: "kg";
|
|
163
|
+
ton: "ton";
|
|
164
|
+
}>;
|
|
165
|
+
net_weight: z.ZodNumber;
|
|
166
|
+
contamination_level: z.ZodOptional<z.ZodEnum<{
|
|
167
|
+
None: "None";
|
|
168
|
+
Low: "Low";
|
|
169
|
+
Medium: "Medium";
|
|
170
|
+
High: "High";
|
|
171
|
+
}>>;
|
|
172
|
+
}, z.core.$strict>;
|
|
173
|
+
locations: z.ZodArray<z.ZodObject<{
|
|
174
|
+
id: z.ZodUUID;
|
|
175
|
+
municipality: z.ZodString;
|
|
176
|
+
administrative_division: z.ZodString;
|
|
177
|
+
administrative_division_code: z.ZodString;
|
|
178
|
+
country: z.ZodString;
|
|
179
|
+
country_code: z.ZodString;
|
|
180
|
+
responsible_participant_id: z.ZodUUID;
|
|
181
|
+
coordinates: z.ZodObject<{
|
|
182
|
+
latitude: z.ZodNumber;
|
|
183
|
+
longitude: z.ZodNumber;
|
|
184
|
+
precision_level: z.ZodEnum<{
|
|
185
|
+
exact: "exact";
|
|
186
|
+
neighborhood: "neighborhood";
|
|
187
|
+
city: "city";
|
|
188
|
+
region: "region";
|
|
189
|
+
country: "country";
|
|
190
|
+
}>;
|
|
191
|
+
}, z.core.$strict>;
|
|
192
|
+
facility_type: z.ZodEnum<{
|
|
193
|
+
"Waste Generation": "Waste Generation";
|
|
194
|
+
"Collection Point": "Collection Point";
|
|
195
|
+
"Transfer Station": "Transfer Station";
|
|
196
|
+
"Sorting Facility": "Sorting Facility";
|
|
197
|
+
"Composting Facility": "Composting Facility";
|
|
198
|
+
"Recycling Facility": "Recycling Facility";
|
|
199
|
+
"Processing Facility": "Processing Facility";
|
|
200
|
+
"Disposal Facility": "Disposal Facility";
|
|
201
|
+
"Administrative Office": "Administrative Office";
|
|
202
|
+
}>;
|
|
203
|
+
}, z.core.$strict>>;
|
|
204
|
+
participants: z.ZodArray<z.ZodObject<{
|
|
205
|
+
id: z.ZodUUID;
|
|
206
|
+
name: z.ZodString;
|
|
207
|
+
roles: z.ZodArray<z.ZodString>;
|
|
208
|
+
}, z.core.$strict>>;
|
|
209
|
+
chain_of_custody: z.ZodObject<{
|
|
210
|
+
events: z.ZodArray<z.ZodObject<{
|
|
211
|
+
event_id: z.ZodUUID;
|
|
212
|
+
event_name: z.ZodString;
|
|
213
|
+
description: z.ZodString;
|
|
214
|
+
timestamp: z.ZodISODateTime;
|
|
215
|
+
participant_id: z.ZodUUID;
|
|
216
|
+
location_id: z.ZodUUID;
|
|
217
|
+
weight: z.ZodOptional<z.ZodNumber>;
|
|
218
|
+
attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
219
|
+
name: z.ZodString;
|
|
220
|
+
value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
|
|
221
|
+
format: z.ZodOptional<z.ZodEnum<{
|
|
222
|
+
KILOGRAM: "KILOGRAM";
|
|
223
|
+
DATE: "DATE";
|
|
224
|
+
CURRENCY: "CURRENCY";
|
|
225
|
+
PERCENTAGE: "PERCENTAGE";
|
|
226
|
+
COORDINATE: "COORDINATE";
|
|
227
|
+
}>>;
|
|
228
|
+
}, z.core.$strict>>>;
|
|
229
|
+
documentation: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
230
|
+
type: z.ZodString;
|
|
231
|
+
document_number: z.ZodOptional<z.ZodString>;
|
|
232
|
+
reference: z.ZodString;
|
|
233
|
+
issue_date: z.ZodOptional<z.ZodISODate>;
|
|
234
|
+
issuer: z.ZodOptional<z.ZodString>;
|
|
235
|
+
}, z.core.$strict>>>;
|
|
236
|
+
notes: z.ZodOptional<z.ZodString>;
|
|
237
|
+
}, z.core.$strict>>;
|
|
238
|
+
total_distance_km: z.ZodNumber;
|
|
239
|
+
total_duration_hours: z.ZodNumber;
|
|
240
|
+
}, z.core.$strict>;
|
|
241
|
+
geographic_data: z.ZodObject<{
|
|
242
|
+
origin_location_id: z.ZodUUID;
|
|
243
|
+
processing_location_ids: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
|
|
244
|
+
final_destination_id: z.ZodUUID;
|
|
245
|
+
transport_routes: z.ZodArray<z.ZodObject<{
|
|
246
|
+
from_location_id: z.ZodUUID;
|
|
247
|
+
to_location_id: z.ZodUUID;
|
|
248
|
+
distance_km: z.ZodNumber;
|
|
249
|
+
transport_method: z.ZodString;
|
|
250
|
+
duration_hours: z.ZodNumber;
|
|
251
|
+
}, z.core.$strict>>;
|
|
252
|
+
}, z.core.$strict>;
|
|
253
|
+
}, z.core.$strict>;
|
|
254
|
+
export type MassIDData = z.infer<typeof MassIDDataSchema>;
|
|
255
|
+
export {};
|
|
256
|
+
//# sourceMappingURL=mass-id.data.schema.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"mass-id.data.schema.d.ts","sourceRoot":"","sources":["../../src/mass-id/mass-id.data.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,QAAA,MAAM,yBAAyB;;;;kBAiC3B,CAAC;AAEL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,QAAA,MAAM,qBAAqB;;;EAIzB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,QAAA,MAAM,wBAAwB;;;;;EAM1B,CAAC;AAEL,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;kBAuB3B,CAAC;AAEL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,QAAA,MAAM,0BAA0B;;;;;;EAM5B,CAAC;AAEL,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,QAAA,MAAM,oBAAoB;;;;;;;;;;kBAmCtB,CAAC;AACL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,QAAA,MAAM,mBAAmB;;;;;;kBA+DrB,CAAC;AACL,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAErE,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuD3B,CAAC;AACL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoBtB,CAAC;AACL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,QAAA,MAAM,oBAAoB;;;;;;kBAqCtB,CAAC;AACL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,QAAA,MAAM,oBAAoB;;;;;;;;;;;kBAuBtB,CAAC;AACL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8DzB,CAAC;AACL,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
|
|
@@ -0,0 +1,291 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
declare const AttributeWasteTypeSchema: z.ZodObject<{
|
|
3
|
+
trait_type: z.ZodLiteral<"Waste Type">;
|
|
4
|
+
value: z.ZodString;
|
|
5
|
+
}, z.core.$strict>;
|
|
6
|
+
export type AttributeWasteType = z.infer<typeof AttributeWasteTypeSchema>;
|
|
7
|
+
declare const AttributeWasteSubtypeSchema: z.ZodObject<{
|
|
8
|
+
trait_type: z.ZodLiteral<"Waste Subtype">;
|
|
9
|
+
value: z.ZodString;
|
|
10
|
+
}, z.core.$strict>;
|
|
11
|
+
export type AttributeWasteSubtype = z.infer<typeof AttributeWasteSubtypeSchema>;
|
|
12
|
+
declare const AttributeWeightSchema: z.ZodObject<{
|
|
13
|
+
trait_type: z.ZodLiteral<"Weight (kg)">;
|
|
14
|
+
value: z.ZodNumber;
|
|
15
|
+
display_type: z.ZodLiteral<"number">;
|
|
16
|
+
}, z.core.$strict>;
|
|
17
|
+
export type AttributeWeight = z.infer<typeof AttributeWeightSchema>;
|
|
18
|
+
declare const AttributeOriginCountrySchema: z.ZodObject<{
|
|
19
|
+
trait_type: z.ZodLiteral<"Origin Country">;
|
|
20
|
+
value: z.ZodString;
|
|
21
|
+
}, z.core.$strict>;
|
|
22
|
+
export type AttributeOriginCountry = z.infer<typeof AttributeOriginCountrySchema>;
|
|
23
|
+
declare const AttributeOriginMunicipalitySchema: z.ZodObject<{
|
|
24
|
+
trait_type: z.ZodLiteral<"Origin Municipality">;
|
|
25
|
+
value: z.ZodString;
|
|
26
|
+
}, z.core.$strict>;
|
|
27
|
+
export type AttributeOriginMunicipality = z.infer<typeof AttributeOriginMunicipalitySchema>;
|
|
28
|
+
declare const AttributeOriginDivisionSchema: z.ZodObject<{
|
|
29
|
+
trait_type: z.ZodLiteral<"Origin Administrative Division">;
|
|
30
|
+
value: z.ZodString;
|
|
31
|
+
}, z.core.$strict>;
|
|
32
|
+
export type AttributeOriginDivision = z.infer<typeof AttributeOriginDivisionSchema>;
|
|
33
|
+
declare const AttributeRecyclerSchema: z.ZodObject<{
|
|
34
|
+
trait_type: z.ZodLiteral<"Recycler">;
|
|
35
|
+
value: z.ZodString;
|
|
36
|
+
}, z.core.$strict>;
|
|
37
|
+
export type AttributeRecycler = z.infer<typeof AttributeRecyclerSchema>;
|
|
38
|
+
declare const AttributeIntegratorSchema: z.ZodObject<{
|
|
39
|
+
trait_type: z.ZodLiteral<"Integrator">;
|
|
40
|
+
value: z.ZodString;
|
|
41
|
+
}, z.core.$strict>;
|
|
42
|
+
export type AttributeIntegrator = z.infer<typeof AttributeIntegratorSchema>;
|
|
43
|
+
declare const AttributePickUpDateSchema: z.ZodObject<{
|
|
44
|
+
trait_type: z.ZodLiteral<"Pick-up Date">;
|
|
45
|
+
value: z.ZodString;
|
|
46
|
+
display_type: z.ZodLiteral<"date">;
|
|
47
|
+
}, z.core.$strict>;
|
|
48
|
+
export type AttributePickUpDate = z.infer<typeof AttributePickUpDateSchema>;
|
|
49
|
+
declare const AttributeRecyclingDateSchema: z.ZodObject<{
|
|
50
|
+
trait_type: z.ZodLiteral<"Recycling Date">;
|
|
51
|
+
value: z.ZodString;
|
|
52
|
+
display_type: z.ZodLiteral<"date">;
|
|
53
|
+
}, z.core.$strict>;
|
|
54
|
+
export type AttributeRecyclingDate = z.infer<typeof AttributeRecyclingDateSchema>;
|
|
55
|
+
declare const MassIDAttributesSchema: z.ZodTuple<[z.ZodObject<{
|
|
56
|
+
trait_type: z.ZodLiteral<"Waste Type">;
|
|
57
|
+
value: z.ZodString;
|
|
58
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
59
|
+
trait_type: z.ZodLiteral<"Waste Subtype">;
|
|
60
|
+
value: z.ZodString;
|
|
61
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
62
|
+
trait_type: z.ZodLiteral<"Weight (kg)">;
|
|
63
|
+
value: z.ZodNumber;
|
|
64
|
+
display_type: z.ZodLiteral<"number">;
|
|
65
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
66
|
+
trait_type: z.ZodLiteral<"Origin Country">;
|
|
67
|
+
value: z.ZodString;
|
|
68
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
69
|
+
trait_type: z.ZodLiteral<"Origin Municipality">;
|
|
70
|
+
value: z.ZodString;
|
|
71
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
72
|
+
trait_type: z.ZodLiteral<"Origin Administrative Division">;
|
|
73
|
+
value: z.ZodString;
|
|
74
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
75
|
+
trait_type: z.ZodLiteral<"Recycler">;
|
|
76
|
+
value: z.ZodString;
|
|
77
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
78
|
+
trait_type: z.ZodLiteral<"Integrator">;
|
|
79
|
+
value: z.ZodString;
|
|
80
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
81
|
+
trait_type: z.ZodLiteral<"Pick-up Date">;
|
|
82
|
+
value: z.ZodString;
|
|
83
|
+
display_type: z.ZodLiteral<"date">;
|
|
84
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
85
|
+
trait_type: z.ZodLiteral<"Recycling Date">;
|
|
86
|
+
value: z.ZodString;
|
|
87
|
+
display_type: z.ZodLiteral<"date">;
|
|
88
|
+
}, z.core.$strict>], null>;
|
|
89
|
+
export type MassIDAttributes = z.infer<typeof MassIDAttributesSchema>;
|
|
90
|
+
export declare const MassIDIpfsSchema: z.ZodObject<{
|
|
91
|
+
$schema: z.ZodURL;
|
|
92
|
+
created_at: z.ZodISODateTime;
|
|
93
|
+
external_id: z.ZodUUID;
|
|
94
|
+
external_url: z.ZodURL;
|
|
95
|
+
original_content_hash: z.ZodCustomStringFormat<"sha256_hex">;
|
|
96
|
+
content_hash: z.ZodCustomStringFormat<"sha256_hex">;
|
|
97
|
+
creator: z.ZodOptional<z.ZodObject<{
|
|
98
|
+
name: z.ZodString;
|
|
99
|
+
id: z.ZodUUID;
|
|
100
|
+
}, z.core.$strict>>;
|
|
101
|
+
relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
102
|
+
target_uri: z.ZodString;
|
|
103
|
+
type: z.ZodEnum<{
|
|
104
|
+
collection: "collection";
|
|
105
|
+
credit: "credit";
|
|
106
|
+
"gas-id": "gas-id";
|
|
107
|
+
"mass-id": "mass-id";
|
|
108
|
+
"mass-id-audit": "mass-id-audit";
|
|
109
|
+
methodology: "methodology";
|
|
110
|
+
"purchase-id": "purchase-id";
|
|
111
|
+
"recycled-id": "recycled-id";
|
|
112
|
+
}>;
|
|
113
|
+
description: z.ZodOptional<z.ZodString>;
|
|
114
|
+
}, z.core.$strict>>>;
|
|
115
|
+
environment: z.ZodOptional<z.ZodObject<{
|
|
116
|
+
blockchain_network: z.ZodEnum<{
|
|
117
|
+
mainnet: "mainnet";
|
|
118
|
+
testnet: "testnet";
|
|
119
|
+
}>;
|
|
120
|
+
deployment: z.ZodEnum<{
|
|
121
|
+
production: "production";
|
|
122
|
+
development: "development";
|
|
123
|
+
testing: "testing";
|
|
124
|
+
}>;
|
|
125
|
+
data_set_name: z.ZodEnum<{
|
|
126
|
+
TEST: "TEST";
|
|
127
|
+
PROD: "PROD";
|
|
128
|
+
}>;
|
|
129
|
+
}, z.core.$strict>>;
|
|
130
|
+
blockchain: z.ZodObject<{
|
|
131
|
+
smart_contract_address: z.ZodString;
|
|
132
|
+
chain_id: z.ZodNumber;
|
|
133
|
+
network_name: z.ZodString;
|
|
134
|
+
token_id: z.ZodString;
|
|
135
|
+
}, z.core.$strict>;
|
|
136
|
+
name: z.ZodString;
|
|
137
|
+
short_name: z.ZodString;
|
|
138
|
+
description: z.ZodString;
|
|
139
|
+
image: z.ZodString;
|
|
140
|
+
background_color: z.ZodOptional<z.ZodString>;
|
|
141
|
+
animation_url: z.ZodOptional<z.ZodString>;
|
|
142
|
+
external_links: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
143
|
+
label: z.ZodString;
|
|
144
|
+
url: z.ZodURL;
|
|
145
|
+
description: z.ZodOptional<z.ZodString>;
|
|
146
|
+
}, z.core.$strict>>>;
|
|
147
|
+
schema: z.ZodObject<{
|
|
148
|
+
hash: z.ZodCustomStringFormat<"sha256_hex">;
|
|
149
|
+
version: z.ZodString;
|
|
150
|
+
type: z.ZodLiteral<"MassID">;
|
|
151
|
+
}, z.core.$strict>;
|
|
152
|
+
attributes: z.ZodTuple<[z.ZodObject<{
|
|
153
|
+
trait_type: z.ZodLiteral<"Waste Type">;
|
|
154
|
+
value: z.ZodString;
|
|
155
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
156
|
+
trait_type: z.ZodLiteral<"Waste Subtype">;
|
|
157
|
+
value: z.ZodString;
|
|
158
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
159
|
+
trait_type: z.ZodLiteral<"Weight (kg)">;
|
|
160
|
+
value: z.ZodNumber;
|
|
161
|
+
display_type: z.ZodLiteral<"number">;
|
|
162
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
163
|
+
trait_type: z.ZodLiteral<"Origin Country">;
|
|
164
|
+
value: z.ZodString;
|
|
165
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
166
|
+
trait_type: z.ZodLiteral<"Origin Municipality">;
|
|
167
|
+
value: z.ZodString;
|
|
168
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
169
|
+
trait_type: z.ZodLiteral<"Origin Administrative Division">;
|
|
170
|
+
value: z.ZodString;
|
|
171
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
172
|
+
trait_type: z.ZodLiteral<"Recycler">;
|
|
173
|
+
value: z.ZodString;
|
|
174
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
175
|
+
trait_type: z.ZodLiteral<"Integrator">;
|
|
176
|
+
value: z.ZodString;
|
|
177
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
178
|
+
trait_type: z.ZodLiteral<"Pick-up Date">;
|
|
179
|
+
value: z.ZodString;
|
|
180
|
+
display_type: z.ZodLiteral<"date">;
|
|
181
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
182
|
+
trait_type: z.ZodLiteral<"Recycling Date">;
|
|
183
|
+
value: z.ZodString;
|
|
184
|
+
display_type: z.ZodLiteral<"date">;
|
|
185
|
+
}, z.core.$strict>], null>;
|
|
186
|
+
data: z.ZodObject<{
|
|
187
|
+
waste_classification: z.ZodObject<{
|
|
188
|
+
primary_type: z.ZodString;
|
|
189
|
+
subtype: z.ZodString;
|
|
190
|
+
local_classification: z.ZodOptional<z.ZodObject<{
|
|
191
|
+
code: z.ZodString;
|
|
192
|
+
description: z.ZodString;
|
|
193
|
+
system: z.ZodString;
|
|
194
|
+
}, z.core.$strict>>;
|
|
195
|
+
measurement_unit: z.ZodEnum<{
|
|
196
|
+
kg: "kg";
|
|
197
|
+
ton: "ton";
|
|
198
|
+
}>;
|
|
199
|
+
net_weight: z.ZodNumber;
|
|
200
|
+
contamination_level: z.ZodOptional<z.ZodEnum<{
|
|
201
|
+
None: "None";
|
|
202
|
+
Low: "Low";
|
|
203
|
+
Medium: "Medium";
|
|
204
|
+
High: "High";
|
|
205
|
+
}>>;
|
|
206
|
+
}, z.core.$strict>;
|
|
207
|
+
locations: z.ZodArray<z.ZodObject<{
|
|
208
|
+
id: z.ZodUUID;
|
|
209
|
+
municipality: z.ZodString;
|
|
210
|
+
administrative_division: z.ZodString;
|
|
211
|
+
administrative_division_code: z.ZodString;
|
|
212
|
+
country: z.ZodString;
|
|
213
|
+
country_code: z.ZodString;
|
|
214
|
+
responsible_participant_id: z.ZodUUID;
|
|
215
|
+
coordinates: z.ZodObject<{
|
|
216
|
+
latitude: z.ZodNumber;
|
|
217
|
+
longitude: z.ZodNumber;
|
|
218
|
+
precision_level: z.ZodEnum<{
|
|
219
|
+
exact: "exact";
|
|
220
|
+
neighborhood: "neighborhood";
|
|
221
|
+
city: "city";
|
|
222
|
+
region: "region";
|
|
223
|
+
country: "country";
|
|
224
|
+
}>;
|
|
225
|
+
}, z.core.$strict>;
|
|
226
|
+
facility_type: z.ZodEnum<{
|
|
227
|
+
"Waste Generation": "Waste Generation";
|
|
228
|
+
"Collection Point": "Collection Point";
|
|
229
|
+
"Transfer Station": "Transfer Station";
|
|
230
|
+
"Sorting Facility": "Sorting Facility";
|
|
231
|
+
"Composting Facility": "Composting Facility";
|
|
232
|
+
"Recycling Facility": "Recycling Facility";
|
|
233
|
+
"Processing Facility": "Processing Facility";
|
|
234
|
+
"Disposal Facility": "Disposal Facility";
|
|
235
|
+
"Administrative Office": "Administrative Office";
|
|
236
|
+
}>;
|
|
237
|
+
}, z.core.$strict>>;
|
|
238
|
+
participants: z.ZodArray<z.ZodObject<{
|
|
239
|
+
id: z.ZodUUID;
|
|
240
|
+
name: z.ZodString;
|
|
241
|
+
roles: z.ZodArray<z.ZodString>;
|
|
242
|
+
}, z.core.$strict>>;
|
|
243
|
+
chain_of_custody: z.ZodObject<{
|
|
244
|
+
events: z.ZodArray<z.ZodObject<{
|
|
245
|
+
event_id: z.ZodUUID;
|
|
246
|
+
event_name: z.ZodString;
|
|
247
|
+
description: z.ZodString;
|
|
248
|
+
timestamp: z.ZodISODateTime;
|
|
249
|
+
participant_id: z.ZodUUID;
|
|
250
|
+
location_id: z.ZodUUID;
|
|
251
|
+
weight: z.ZodOptional<z.ZodNumber>;
|
|
252
|
+
attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
253
|
+
name: z.ZodString;
|
|
254
|
+
value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
|
|
255
|
+
format: z.ZodOptional<z.ZodEnum<{
|
|
256
|
+
KILOGRAM: "KILOGRAM";
|
|
257
|
+
DATE: "DATE";
|
|
258
|
+
CURRENCY: "CURRENCY";
|
|
259
|
+
PERCENTAGE: "PERCENTAGE";
|
|
260
|
+
COORDINATE: "COORDINATE";
|
|
261
|
+
}>>;
|
|
262
|
+
}, z.core.$strict>>>;
|
|
263
|
+
documentation: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
264
|
+
type: z.ZodString;
|
|
265
|
+
document_number: z.ZodOptional<z.ZodString>;
|
|
266
|
+
reference: z.ZodString;
|
|
267
|
+
issue_date: z.ZodOptional<z.ZodISODate>;
|
|
268
|
+
issuer: z.ZodOptional<z.ZodString>;
|
|
269
|
+
}, z.core.$strict>>>;
|
|
270
|
+
notes: z.ZodOptional<z.ZodString>;
|
|
271
|
+
}, z.core.$strict>>;
|
|
272
|
+
total_distance_km: z.ZodNumber;
|
|
273
|
+
total_duration_hours: z.ZodNumber;
|
|
274
|
+
}, z.core.$strict>;
|
|
275
|
+
geographic_data: z.ZodObject<{
|
|
276
|
+
origin_location_id: z.ZodUUID;
|
|
277
|
+
processing_location_ids: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
|
|
278
|
+
final_destination_id: z.ZodUUID;
|
|
279
|
+
transport_routes: z.ZodArray<z.ZodObject<{
|
|
280
|
+
from_location_id: z.ZodUUID;
|
|
281
|
+
to_location_id: z.ZodUUID;
|
|
282
|
+
distance_km: z.ZodNumber;
|
|
283
|
+
transport_method: z.ZodString;
|
|
284
|
+
duration_hours: z.ZodNumber;
|
|
285
|
+
}, z.core.$strict>>;
|
|
286
|
+
}, z.core.$strict>;
|
|
287
|
+
}, z.core.$strict>;
|
|
288
|
+
}, z.core.$strict>;
|
|
289
|
+
export type MassIDIpfs = z.infer<typeof MassIDIpfsSchema>;
|
|
290
|
+
export {};
|
|
291
|
+
//# sourceMappingURL=mass-id.schema.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"mass-id.schema.d.ts","sourceRoot":"","sources":["../../src/mass-id/mass-id.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,QAAA,MAAM,wBAAwB;;;kBAQ1B,CAAC;AAEL,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,QAAA,MAAM,2BAA2B;;;kBAQ7B,CAAC;AAEL,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,QAAA,MAAM,qBAAqB;;;;kBASvB,CAAC;AAEL,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,QAAA,MAAM,4BAA4B;;;kBAW9B,CAAC;AAEL,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,QAAA,MAAM,iCAAiC;;;kBAWnC,CAAC;AAEL,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AAEF,QAAA,MAAM,6BAA6B;;;kBAY/B,CAAC;AAEL,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,QAAA,MAAM,uBAAuB;;;kBAWzB,CAAC;AAEL,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,QAAA,MAAM,yBAAyB;;;kBAY3B,CAAC;AAEL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,QAAA,MAAM,yBAAyB;;;;kBAe3B,CAAC;AAEL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,QAAA,MAAM,4BAA4B;;;;kBAe9B,CAAC;AAEL,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAgBxB,CAAC;AAEL,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuB3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
|
|
@@ -0,0 +1,111 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
declare const SchemaInfoSchema: z.ZodObject<{
|
|
3
|
+
hash: z.ZodCustomStringFormat<"sha256_hex">;
|
|
4
|
+
type: z.ZodEnum<{
|
|
5
|
+
MassID: "MassID";
|
|
6
|
+
"MassID Audit": "MassID Audit";
|
|
7
|
+
RecycledID: "RecycledID";
|
|
8
|
+
GasID: "GasID";
|
|
9
|
+
PurchaseID: "PurchaseID";
|
|
10
|
+
Methodology: "Methodology";
|
|
11
|
+
Credit: "Credit";
|
|
12
|
+
Collection: "Collection";
|
|
13
|
+
}>;
|
|
14
|
+
version: z.ZodString;
|
|
15
|
+
}, z.core.$strict>;
|
|
16
|
+
export type SchemaInfo = z.infer<typeof SchemaInfoSchema>;
|
|
17
|
+
declare const RecordCreatorSchema: z.ZodObject<{
|
|
18
|
+
name: z.ZodString;
|
|
19
|
+
id: z.ZodUUID;
|
|
20
|
+
}, z.core.$strict>;
|
|
21
|
+
export type RecordCreator = z.infer<typeof RecordCreatorSchema>;
|
|
22
|
+
declare const RecordRelationshipSchema: z.ZodObject<{
|
|
23
|
+
target_uri: z.ZodString;
|
|
24
|
+
type: z.ZodEnum<{
|
|
25
|
+
collection: "collection";
|
|
26
|
+
credit: "credit";
|
|
27
|
+
"gas-id": "gas-id";
|
|
28
|
+
"mass-id": "mass-id";
|
|
29
|
+
"mass-id-audit": "mass-id-audit";
|
|
30
|
+
methodology: "methodology";
|
|
31
|
+
"purchase-id": "purchase-id";
|
|
32
|
+
"recycled-id": "recycled-id";
|
|
33
|
+
}>;
|
|
34
|
+
description: z.ZodOptional<z.ZodString>;
|
|
35
|
+
}, z.core.$strict>;
|
|
36
|
+
export type RecordRelationship = z.infer<typeof RecordRelationshipSchema>;
|
|
37
|
+
export declare const RecordEnvironmentSchema: z.ZodObject<{
|
|
38
|
+
blockchain_network: z.ZodEnum<{
|
|
39
|
+
mainnet: "mainnet";
|
|
40
|
+
testnet: "testnet";
|
|
41
|
+
}>;
|
|
42
|
+
deployment: z.ZodEnum<{
|
|
43
|
+
production: "production";
|
|
44
|
+
development: "development";
|
|
45
|
+
testing: "testing";
|
|
46
|
+
}>;
|
|
47
|
+
data_set_name: z.ZodEnum<{
|
|
48
|
+
TEST: "TEST";
|
|
49
|
+
PROD: "PROD";
|
|
50
|
+
}>;
|
|
51
|
+
}, z.core.$strict>;
|
|
52
|
+
export type RecordEnvironment = z.infer<typeof RecordEnvironmentSchema>;
|
|
53
|
+
export declare const BaseIpfsSchema: z.ZodObject<{
|
|
54
|
+
$schema: z.ZodURL;
|
|
55
|
+
schema: z.ZodObject<{
|
|
56
|
+
hash: z.ZodCustomStringFormat<"sha256_hex">;
|
|
57
|
+
type: z.ZodEnum<{
|
|
58
|
+
MassID: "MassID";
|
|
59
|
+
"MassID Audit": "MassID Audit";
|
|
60
|
+
RecycledID: "RecycledID";
|
|
61
|
+
GasID: "GasID";
|
|
62
|
+
PurchaseID: "PurchaseID";
|
|
63
|
+
Methodology: "Methodology";
|
|
64
|
+
Credit: "Credit";
|
|
65
|
+
Collection: "Collection";
|
|
66
|
+
}>;
|
|
67
|
+
version: z.ZodString;
|
|
68
|
+
}, z.core.$strict>;
|
|
69
|
+
created_at: z.ZodISODateTime;
|
|
70
|
+
external_id: z.ZodUUID;
|
|
71
|
+
external_url: z.ZodURL;
|
|
72
|
+
original_content_hash: z.ZodCustomStringFormat<"sha256_hex">;
|
|
73
|
+
content_hash: z.ZodCustomStringFormat<"sha256_hex">;
|
|
74
|
+
creator: z.ZodOptional<z.ZodObject<{
|
|
75
|
+
name: z.ZodString;
|
|
76
|
+
id: z.ZodUUID;
|
|
77
|
+
}, z.core.$strict>>;
|
|
78
|
+
relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
79
|
+
target_uri: z.ZodString;
|
|
80
|
+
type: z.ZodEnum<{
|
|
81
|
+
collection: "collection";
|
|
82
|
+
credit: "credit";
|
|
83
|
+
"gas-id": "gas-id";
|
|
84
|
+
"mass-id": "mass-id";
|
|
85
|
+
"mass-id-audit": "mass-id-audit";
|
|
86
|
+
methodology: "methodology";
|
|
87
|
+
"purchase-id": "purchase-id";
|
|
88
|
+
"recycled-id": "recycled-id";
|
|
89
|
+
}>;
|
|
90
|
+
description: z.ZodOptional<z.ZodString>;
|
|
91
|
+
}, z.core.$strict>>>;
|
|
92
|
+
environment: z.ZodOptional<z.ZodObject<{
|
|
93
|
+
blockchain_network: z.ZodEnum<{
|
|
94
|
+
mainnet: "mainnet";
|
|
95
|
+
testnet: "testnet";
|
|
96
|
+
}>;
|
|
97
|
+
deployment: z.ZodEnum<{
|
|
98
|
+
production: "production";
|
|
99
|
+
development: "development";
|
|
100
|
+
testing: "testing";
|
|
101
|
+
}>;
|
|
102
|
+
data_set_name: z.ZodEnum<{
|
|
103
|
+
TEST: "TEST";
|
|
104
|
+
PROD: "PROD";
|
|
105
|
+
}>;
|
|
106
|
+
}, z.core.$strict>>;
|
|
107
|
+
data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
108
|
+
}, z.core.$strict>;
|
|
109
|
+
export type BaseIpfs = z.infer<typeof BaseIpfsSchema>;
|
|
110
|
+
export {};
|
|
111
|
+
//# sourceMappingURL=base.schema.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"base.schema.d.ts","sourceRoot":"","sources":["../../src/shared/base.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;kBAkBlB,CAAC;AAEL,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,QAAA,MAAM,mBAAmB;;;kBAerB,CAAC;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;kBA4B1B,CAAC;AAEL,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;kBAkBhC,CAAC;AAEL,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8CvB,CAAC;AAEL,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}
|
|
@@ -0,0 +1,96 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
export declare const UuidSchema: z.ZodUUID;
|
|
3
|
+
export type Uuid = z.infer<typeof UuidSchema>;
|
|
4
|
+
export declare const EthereumAddressSchema: z.ZodString;
|
|
5
|
+
export type EthereumAddress = z.infer<typeof EthereumAddressSchema>;
|
|
6
|
+
export declare const IsoTimestampSchema: z.ZodISODateTime;
|
|
7
|
+
export type IsoTimestamp = z.infer<typeof IsoTimestampSchema>;
|
|
8
|
+
export declare const IsoDateSchema: z.ZodISODate;
|
|
9
|
+
export type IsoDate = z.infer<typeof IsoDateSchema>;
|
|
10
|
+
export declare const IsoCountryCodeSchema: z.ZodString;
|
|
11
|
+
export type IsoCountryCode = z.infer<typeof IsoCountryCodeSchema>;
|
|
12
|
+
export declare const IsoAdministrativeDivisionCodeSchema: z.ZodString;
|
|
13
|
+
export type IsoAdministrativeDivisionCode = z.infer<typeof IsoAdministrativeDivisionCodeSchema>;
|
|
14
|
+
export declare const LatitudeSchema: z.ZodNumber;
|
|
15
|
+
export type Latitude = z.infer<typeof LatitudeSchema>;
|
|
16
|
+
export declare const LongitudeSchema: z.ZodNumber;
|
|
17
|
+
export type Longitude = z.infer<typeof LongitudeSchema>;
|
|
18
|
+
export declare const WeightKgSchema: z.ZodNumber;
|
|
19
|
+
export type WeightKg = z.infer<typeof WeightKgSchema>;
|
|
20
|
+
export declare const NonEmptyStringSchema: z.ZodString;
|
|
21
|
+
export type NonEmptyString = z.infer<typeof NonEmptyStringSchema>;
|
|
22
|
+
export declare const SlugSchema: z.ZodString;
|
|
23
|
+
export type Slug = z.infer<typeof SlugSchema>;
|
|
24
|
+
export declare const WasteTypeSchema: z.ZodString;
|
|
25
|
+
export type WasteType = z.infer<typeof WasteTypeSchema>;
|
|
26
|
+
export declare const WasteSubtypeSchema: z.ZodString;
|
|
27
|
+
export type WasteSubtype = z.infer<typeof WasteSubtypeSchema>;
|
|
28
|
+
export declare const ParticipantRoleSchema: z.ZodString;
|
|
29
|
+
export type ParticipantRole = z.infer<typeof ParticipantRoleSchema>;
|
|
30
|
+
export declare const ParticipantNameSchema: z.ZodString;
|
|
31
|
+
export type ParticipantName = z.infer<typeof ParticipantNameSchema>;
|
|
32
|
+
export declare const FacilityTypeSchema: z.ZodEnum<{
|
|
33
|
+
"Waste Generation": "Waste Generation";
|
|
34
|
+
"Collection Point": "Collection Point";
|
|
35
|
+
"Transfer Station": "Transfer Station";
|
|
36
|
+
"Sorting Facility": "Sorting Facility";
|
|
37
|
+
"Composting Facility": "Composting Facility";
|
|
38
|
+
"Recycling Facility": "Recycling Facility";
|
|
39
|
+
"Processing Facility": "Processing Facility";
|
|
40
|
+
"Disposal Facility": "Disposal Facility";
|
|
41
|
+
"Administrative Office": "Administrative Office";
|
|
42
|
+
}>;
|
|
43
|
+
export type FacilityType = z.infer<typeof FacilityTypeSchema>;
|
|
44
|
+
export declare const BlockchainChainIdSchema: z.ZodNumber;
|
|
45
|
+
export type BlockchainChainId = z.infer<typeof BlockchainChainIdSchema>;
|
|
46
|
+
export declare const PercentageSchema: z.ZodNumber;
|
|
47
|
+
export type Percentage = z.infer<typeof PercentageSchema>;
|
|
48
|
+
export declare const NonNegativeIntegerSchema: z.ZodNumber;
|
|
49
|
+
export type NonNegativeInteger = z.infer<typeof NonNegativeIntegerSchema>;
|
|
50
|
+
export declare const PositiveIntegerSchema: z.ZodNumber;
|
|
51
|
+
export type PositiveInteger = z.infer<typeof PositiveIntegerSchema>;
|
|
52
|
+
export declare const NonNegativeFloatSchema: z.ZodNumber;
|
|
53
|
+
export type NonNegativeFloat = z.infer<typeof NonNegativeFloatSchema>;
|
|
54
|
+
export declare const HoursSchema: z.ZodNumber;
|
|
55
|
+
export type Hours = z.infer<typeof HoursSchema>;
|
|
56
|
+
export declare const IpfsUriSchema: z.ZodString;
|
|
57
|
+
export type IpfsUri = z.infer<typeof IpfsUriSchema>;
|
|
58
|
+
export declare const SemanticVersionSchema: z.ZodString;
|
|
59
|
+
export type SemanticVersion = z.infer<typeof SemanticVersionSchema>;
|
|
60
|
+
export declare const TokenIdSchema: z.ZodString;
|
|
61
|
+
export type TokenId = z.infer<typeof TokenIdSchema>;
|
|
62
|
+
export declare const HexColorSchema: z.ZodString;
|
|
63
|
+
export type HexColor = z.infer<typeof HexColorSchema>;
|
|
64
|
+
export declare const Sha256HashSchema: z.ZodCustomStringFormat<"sha256_hex">;
|
|
65
|
+
export type Sha256Hash = z.infer<typeof Sha256HashSchema>;
|
|
66
|
+
export declare const Keccak256HashSchema: z.ZodCustomStringFormat<"sha256_hex">;
|
|
67
|
+
export type Keccak256Hash = z.infer<typeof Keccak256HashSchema>;
|
|
68
|
+
export declare const ExternalIdSchema: z.ZodUUID;
|
|
69
|
+
export type ExternalId = z.infer<typeof ExternalIdSchema>;
|
|
70
|
+
export declare const ExternalUrlSchema: z.ZodURL;
|
|
71
|
+
export type ExternalUrl = z.infer<typeof ExternalUrlSchema>;
|
|
72
|
+
export declare const RecordSchemaTypeSchema: z.ZodEnum<{
|
|
73
|
+
MassID: "MassID";
|
|
74
|
+
"MassID Audit": "MassID Audit";
|
|
75
|
+
RecycledID: "RecycledID";
|
|
76
|
+
GasID: "GasID";
|
|
77
|
+
PurchaseID: "PurchaseID";
|
|
78
|
+
Methodology: "Methodology";
|
|
79
|
+
Credit: "Credit";
|
|
80
|
+
Collection: "Collection";
|
|
81
|
+
}>;
|
|
82
|
+
export type RecordSchemaType = z.infer<typeof RecordSchemaTypeSchema>;
|
|
83
|
+
export declare const TokenSymbolSchema: z.ZodString;
|
|
84
|
+
export type TokenSymbol = z.infer<typeof TokenSymbolSchema>;
|
|
85
|
+
export declare const RecordRelationshipTypeSchema: z.ZodEnum<{
|
|
86
|
+
collection: "collection";
|
|
87
|
+
credit: "credit";
|
|
88
|
+
"gas-id": "gas-id";
|
|
89
|
+
"mass-id": "mass-id";
|
|
90
|
+
"mass-id-audit": "mass-id-audit";
|
|
91
|
+
methodology: "methodology";
|
|
92
|
+
"purchase-id": "purchase-id";
|
|
93
|
+
"recycled-id": "recycled-id";
|
|
94
|
+
}>;
|
|
95
|
+
export type RecordRelationshipType = z.infer<typeof RecordRelationshipTypeSchema>;
|
|
96
|
+
//# sourceMappingURL=definitions.schema.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"definitions.schema.d.ts","sourceRoot":"","sources":["../../src/shared/definitions.schema.ts"],"names":[],"mappings":"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"}
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
declare const PrecisionLevelSchema: z.ZodEnum<{
|
|
3
|
+
exact: "exact";
|
|
4
|
+
neighborhood: "neighborhood";
|
|
5
|
+
city: "city";
|
|
6
|
+
region: "region";
|
|
7
|
+
country: "country";
|
|
8
|
+
}>;
|
|
9
|
+
export type PrecisionLevel = z.infer<typeof PrecisionLevelSchema>;
|
|
10
|
+
export declare const CoordinatesSchema: z.ZodObject<{
|
|
11
|
+
latitude: z.ZodNumber;
|
|
12
|
+
longitude: z.ZodNumber;
|
|
13
|
+
precision_level: z.ZodEnum<{
|
|
14
|
+
exact: "exact";
|
|
15
|
+
neighborhood: "neighborhood";
|
|
16
|
+
city: "city";
|
|
17
|
+
region: "region";
|
|
18
|
+
country: "country";
|
|
19
|
+
}>;
|
|
20
|
+
}, z.core.$strict>;
|
|
21
|
+
export type Coordinates = z.infer<typeof CoordinatesSchema>;
|
|
22
|
+
export declare const LocationSchema: z.ZodObject<{
|
|
23
|
+
id: z.ZodUUID;
|
|
24
|
+
municipality: z.ZodString;
|
|
25
|
+
administrative_division: z.ZodString;
|
|
26
|
+
administrative_division_code: z.ZodString;
|
|
27
|
+
country: z.ZodString;
|
|
28
|
+
country_code: z.ZodString;
|
|
29
|
+
responsible_participant_id: z.ZodUUID;
|
|
30
|
+
coordinates: z.ZodObject<{
|
|
31
|
+
latitude: z.ZodNumber;
|
|
32
|
+
longitude: z.ZodNumber;
|
|
33
|
+
precision_level: z.ZodEnum<{
|
|
34
|
+
exact: "exact";
|
|
35
|
+
neighborhood: "neighborhood";
|
|
36
|
+
city: "city";
|
|
37
|
+
region: "region";
|
|
38
|
+
country: "country";
|
|
39
|
+
}>;
|
|
40
|
+
}, z.core.$strict>;
|
|
41
|
+
facility_type: z.ZodEnum<{
|
|
42
|
+
"Waste Generation": "Waste Generation";
|
|
43
|
+
"Collection Point": "Collection Point";
|
|
44
|
+
"Transfer Station": "Transfer Station";
|
|
45
|
+
"Sorting Facility": "Sorting Facility";
|
|
46
|
+
"Composting Facility": "Composting Facility";
|
|
47
|
+
"Recycling Facility": "Recycling Facility";
|
|
48
|
+
"Processing Facility": "Processing Facility";
|
|
49
|
+
"Disposal Facility": "Disposal Facility";
|
|
50
|
+
"Administrative Office": "Administrative Office";
|
|
51
|
+
}>;
|
|
52
|
+
}, z.core.$strict>;
|
|
53
|
+
export type Location = z.infer<typeof LocationSchema>;
|
|
54
|
+
export {};
|
|
55
|
+
//# sourceMappingURL=location.schema.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"location.schema.d.ts","sourceRoot":"","sources":["../../../src/shared/entities/location.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,QAAA,MAAM,oBAAoB;;;;;;EAMtB,CAAC;AAEL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,iBAAiB;;;;;;;;;;kBAe1B,CAAC;AACL,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0CvB,CAAC;AAEL,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
export declare const ParticipantSchema: z.ZodObject<{
|
|
3
|
+
id: z.ZodUUID;
|
|
4
|
+
name: z.ZodString;
|
|
5
|
+
roles: z.ZodArray<z.ZodString>;
|
|
6
|
+
}, z.core.$strict>;
|
|
7
|
+
export type Participant = z.infer<typeof ParticipantSchema>;
|
|
8
|
+
//# sourceMappingURL=participant.schema.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"participant.schema.d.ts","sourceRoot":"","sources":["../../../src/shared/entities/participant.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,iBAAiB;;;;kBAwB1B,CAAC;AAEL,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
|
|
@@ -0,0 +1,4 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
export declare function uniqueArrayItems<T extends z.ZodTypeAny>(schema: T, errorMessage?: string): z.ZodArray<T>;
|
|
3
|
+
export declare function uniqueBy<T extends z.ZodTypeAny, K>(schema: T, selector: (item: z.infer<T>) => K, errorMessage?: string): z.ZodArray<T>;
|
|
4
|
+
//# sourceMappingURL=helpers.schema.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"helpers.schema.d.ts","sourceRoot":"","sources":["../../src/shared/helpers.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACrD,MAAM,EAAE,CAAC,EACT,YAAY,GAAE,MAAqC,iBAOpD;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,CAAC,EAChD,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,EACjC,YAAY,GAAE,MAA+B,iBAW9C"}
|
|
@@ -0,0 +1,116 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
declare const NftSchemaTypeSchema: z.ZodEnum<{
|
|
3
|
+
MassID: "MassID";
|
|
4
|
+
RecycledID: "RecycledID";
|
|
5
|
+
GasID: "GasID";
|
|
6
|
+
PurchaseID: "PurchaseID";
|
|
7
|
+
}>;
|
|
8
|
+
export type NftSchemaType = z.infer<typeof NftSchemaTypeSchema>;
|
|
9
|
+
declare const BlockchainReferenceSchema: z.ZodObject<{
|
|
10
|
+
smart_contract_address: z.ZodString;
|
|
11
|
+
chain_id: z.ZodNumber;
|
|
12
|
+
network_name: z.ZodString;
|
|
13
|
+
token_id: z.ZodString;
|
|
14
|
+
}, z.core.$strict>;
|
|
15
|
+
export type BlockchainReference = z.infer<typeof BlockchainReferenceSchema>;
|
|
16
|
+
declare const ExternalLinkSchema: z.ZodObject<{
|
|
17
|
+
label: z.ZodString;
|
|
18
|
+
url: z.ZodURL;
|
|
19
|
+
description: z.ZodOptional<z.ZodString>;
|
|
20
|
+
}, z.core.$strict>;
|
|
21
|
+
export type ExternalLink = z.infer<typeof ExternalLinkSchema>;
|
|
22
|
+
declare const NftAttributeSchema: z.ZodObject<{
|
|
23
|
+
trait_type: z.ZodString;
|
|
24
|
+
value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
|
|
25
|
+
display_type: z.ZodOptional<z.ZodEnum<{
|
|
26
|
+
number: "number";
|
|
27
|
+
date: "date";
|
|
28
|
+
boost_number: "boost_number";
|
|
29
|
+
boost_percentage: "boost_percentage";
|
|
30
|
+
}>>;
|
|
31
|
+
max_value: z.ZodOptional<z.ZodNumber>;
|
|
32
|
+
}, z.core.$strict>;
|
|
33
|
+
export type NftAttribute = z.infer<typeof NftAttributeSchema>;
|
|
34
|
+
export declare const NftIpfsSchema: z.ZodObject<{
|
|
35
|
+
$schema: z.ZodURL;
|
|
36
|
+
created_at: z.ZodISODateTime;
|
|
37
|
+
external_id: z.ZodUUID;
|
|
38
|
+
external_url: z.ZodURL;
|
|
39
|
+
original_content_hash: z.ZodCustomStringFormat<"sha256_hex">;
|
|
40
|
+
content_hash: z.ZodCustomStringFormat<"sha256_hex">;
|
|
41
|
+
creator: z.ZodOptional<z.ZodObject<{
|
|
42
|
+
name: z.ZodString;
|
|
43
|
+
id: z.ZodUUID;
|
|
44
|
+
}, z.core.$strict>>;
|
|
45
|
+
relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
46
|
+
target_uri: z.ZodString;
|
|
47
|
+
type: z.ZodEnum<{
|
|
48
|
+
collection: "collection";
|
|
49
|
+
credit: "credit";
|
|
50
|
+
"gas-id": "gas-id";
|
|
51
|
+
"mass-id": "mass-id";
|
|
52
|
+
"mass-id-audit": "mass-id-audit";
|
|
53
|
+
methodology: "methodology";
|
|
54
|
+
"purchase-id": "purchase-id";
|
|
55
|
+
"recycled-id": "recycled-id";
|
|
56
|
+
}>;
|
|
57
|
+
description: z.ZodOptional<z.ZodString>;
|
|
58
|
+
}, z.core.$strict>>>;
|
|
59
|
+
environment: z.ZodOptional<z.ZodObject<{
|
|
60
|
+
blockchain_network: z.ZodEnum<{
|
|
61
|
+
mainnet: "mainnet";
|
|
62
|
+
testnet: "testnet";
|
|
63
|
+
}>;
|
|
64
|
+
deployment: z.ZodEnum<{
|
|
65
|
+
production: "production";
|
|
66
|
+
development: "development";
|
|
67
|
+
testing: "testing";
|
|
68
|
+
}>;
|
|
69
|
+
data_set_name: z.ZodEnum<{
|
|
70
|
+
TEST: "TEST";
|
|
71
|
+
PROD: "PROD";
|
|
72
|
+
}>;
|
|
73
|
+
}, z.core.$strict>>;
|
|
74
|
+
data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
75
|
+
schema: z.ZodObject<{
|
|
76
|
+
hash: z.ZodCustomStringFormat<"sha256_hex">;
|
|
77
|
+
version: z.ZodString;
|
|
78
|
+
type: z.ZodEnum<{
|
|
79
|
+
MassID: "MassID";
|
|
80
|
+
RecycledID: "RecycledID";
|
|
81
|
+
GasID: "GasID";
|
|
82
|
+
PurchaseID: "PurchaseID";
|
|
83
|
+
}>;
|
|
84
|
+
}, z.core.$strict>;
|
|
85
|
+
blockchain: z.ZodObject<{
|
|
86
|
+
smart_contract_address: z.ZodString;
|
|
87
|
+
chain_id: z.ZodNumber;
|
|
88
|
+
network_name: z.ZodString;
|
|
89
|
+
token_id: z.ZodString;
|
|
90
|
+
}, z.core.$strict>;
|
|
91
|
+
name: z.ZodString;
|
|
92
|
+
short_name: z.ZodString;
|
|
93
|
+
description: z.ZodString;
|
|
94
|
+
image: z.ZodString;
|
|
95
|
+
background_color: z.ZodOptional<z.ZodString>;
|
|
96
|
+
animation_url: z.ZodOptional<z.ZodString>;
|
|
97
|
+
external_links: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
98
|
+
label: z.ZodString;
|
|
99
|
+
url: z.ZodURL;
|
|
100
|
+
description: z.ZodOptional<z.ZodString>;
|
|
101
|
+
}, z.core.$strict>>>;
|
|
102
|
+
attributes: z.ZodArray<z.ZodObject<{
|
|
103
|
+
trait_type: z.ZodString;
|
|
104
|
+
value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
|
|
105
|
+
display_type: z.ZodOptional<z.ZodEnum<{
|
|
106
|
+
number: "number";
|
|
107
|
+
date: "date";
|
|
108
|
+
boost_number: "boost_number";
|
|
109
|
+
boost_percentage: "boost_percentage";
|
|
110
|
+
}>>;
|
|
111
|
+
max_value: z.ZodOptional<z.ZodNumber>;
|
|
112
|
+
}, z.core.$strict>>;
|
|
113
|
+
}, z.core.$strict>;
|
|
114
|
+
export type NftIpfs = z.infer<typeof NftIpfsSchema>;
|
|
115
|
+
export {};
|
|
116
|
+
//# sourceMappingURL=nft.schema.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"nft.schema.d.ts","sourceRoot":"","sources":["../../src/shared/nft.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,QAAA,MAAM,mBAAmB;;;;;EAQvB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,QAAA,MAAM,yBAAyB;;;;;kBAqB3B,CAAC;AAEL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,QAAA,MAAM,kBAAkB;;;;kBAkBpB,CAAC;AAEL,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,QAAA,MAAM,kBAAkB;;;;;;;;;;kBAyBpB,CAAC;AAEL,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0HxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}
|