tuturuuu 0.0.1
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/README.md +270 -0
- package/package.json +47 -0
- package/src/documents.test.ts +523 -0
- package/src/errors.test.ts +278 -0
- package/src/errors.ts +161 -0
- package/src/index.ts +60 -0
- package/src/storage.test.ts +604 -0
- package/src/storage.ts +702 -0
- package/src/types.test.ts +562 -0
- package/src/types.ts +291 -0
|
@@ -0,0 +1,278 @@
|
|
|
1
|
+
import { describe, expect, it } from 'vitest';
|
|
2
|
+
import {
|
|
3
|
+
AuthenticationError,
|
|
4
|
+
AuthorizationError,
|
|
5
|
+
BadRequestError,
|
|
6
|
+
ConflictError,
|
|
7
|
+
createErrorFromResponse,
|
|
8
|
+
InternalServerError,
|
|
9
|
+
isApiErrorResponse,
|
|
10
|
+
NetworkError,
|
|
11
|
+
NotFoundError,
|
|
12
|
+
RateLimitError,
|
|
13
|
+
TuturuuuError,
|
|
14
|
+
ValidationError,
|
|
15
|
+
} from './errors';
|
|
16
|
+
import type { ApiErrorResponse } from './types';
|
|
17
|
+
|
|
18
|
+
describe('TuturuuuError', () => {
|
|
19
|
+
it('should create error with message', () => {
|
|
20
|
+
const error = new TuturuuuError('Test error');
|
|
21
|
+
expect(error.message).toBe('Test error');
|
|
22
|
+
expect(error.name).toBe('TuturuuuError');
|
|
23
|
+
expect(error.code).toBeUndefined();
|
|
24
|
+
expect(error.statusCode).toBeUndefined();
|
|
25
|
+
});
|
|
26
|
+
|
|
27
|
+
it('should create error with code and status', () => {
|
|
28
|
+
const error = new TuturuuuError('Test error', 'TEST_CODE', 400);
|
|
29
|
+
expect(error.message).toBe('Test error');
|
|
30
|
+
expect(error.code).toBe('TEST_CODE');
|
|
31
|
+
expect(error.statusCode).toBe(400);
|
|
32
|
+
});
|
|
33
|
+
|
|
34
|
+
it('should maintain proper stack trace', () => {
|
|
35
|
+
const error = new TuturuuuError('Test error');
|
|
36
|
+
expect(error.stack).toBeDefined();
|
|
37
|
+
});
|
|
38
|
+
});
|
|
39
|
+
|
|
40
|
+
describe('AuthenticationError', () => {
|
|
41
|
+
it('should create 401 error', () => {
|
|
42
|
+
const error = new AuthenticationError('Invalid credentials');
|
|
43
|
+
expect(error.message).toBe('Invalid credentials');
|
|
44
|
+
expect(error.name).toBe('AuthenticationError');
|
|
45
|
+
expect(error.statusCode).toBe(401);
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
it('should accept error code', () => {
|
|
49
|
+
const error = new AuthenticationError('Invalid token', 'INVALID_TOKEN');
|
|
50
|
+
expect(error.code).toBe('INVALID_TOKEN');
|
|
51
|
+
});
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
describe('AuthorizationError', () => {
|
|
55
|
+
it('should create 403 error', () => {
|
|
56
|
+
const error = new AuthorizationError('Access denied');
|
|
57
|
+
expect(error.message).toBe('Access denied');
|
|
58
|
+
expect(error.name).toBe('AuthorizationError');
|
|
59
|
+
expect(error.statusCode).toBe(403);
|
|
60
|
+
});
|
|
61
|
+
});
|
|
62
|
+
|
|
63
|
+
describe('NotFoundError', () => {
|
|
64
|
+
it('should create 404 error', () => {
|
|
65
|
+
const error = new NotFoundError('Resource not found');
|
|
66
|
+
expect(error.message).toBe('Resource not found');
|
|
67
|
+
expect(error.name).toBe('NotFoundError');
|
|
68
|
+
expect(error.statusCode).toBe(404);
|
|
69
|
+
});
|
|
70
|
+
});
|
|
71
|
+
|
|
72
|
+
describe('BadRequestError', () => {
|
|
73
|
+
it('should create 400 error', () => {
|
|
74
|
+
const error = new BadRequestError('Invalid request');
|
|
75
|
+
expect(error.message).toBe('Invalid request');
|
|
76
|
+
expect(error.name).toBe('BadRequestError');
|
|
77
|
+
expect(error.statusCode).toBe(400);
|
|
78
|
+
});
|
|
79
|
+
});
|
|
80
|
+
|
|
81
|
+
describe('ConflictError', () => {
|
|
82
|
+
it('should create 409 error', () => {
|
|
83
|
+
const error = new ConflictError('Resource conflict');
|
|
84
|
+
expect(error.message).toBe('Resource conflict');
|
|
85
|
+
expect(error.name).toBe('ConflictError');
|
|
86
|
+
expect(error.statusCode).toBe(409);
|
|
87
|
+
});
|
|
88
|
+
});
|
|
89
|
+
|
|
90
|
+
describe('RateLimitError', () => {
|
|
91
|
+
it('should create 429 error', () => {
|
|
92
|
+
const error = new RateLimitError('Too many requests');
|
|
93
|
+
expect(error.message).toBe('Too many requests');
|
|
94
|
+
expect(error.name).toBe('RateLimitError');
|
|
95
|
+
expect(error.statusCode).toBe(429);
|
|
96
|
+
});
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
describe('InternalServerError', () => {
|
|
100
|
+
it('should create 500 error', () => {
|
|
101
|
+
const error = new InternalServerError('Server error');
|
|
102
|
+
expect(error.message).toBe('Server error');
|
|
103
|
+
expect(error.name).toBe('InternalServerError');
|
|
104
|
+
expect(error.statusCode).toBe(500);
|
|
105
|
+
});
|
|
106
|
+
});
|
|
107
|
+
|
|
108
|
+
describe('NetworkError', () => {
|
|
109
|
+
it('should create network error', () => {
|
|
110
|
+
const error = new NetworkError('Connection failed');
|
|
111
|
+
expect(error.message).toBe('Connection failed');
|
|
112
|
+
expect(error.name).toBe('NetworkError');
|
|
113
|
+
expect(error.code).toBe('NETWORK_ERROR');
|
|
114
|
+
});
|
|
115
|
+
});
|
|
116
|
+
|
|
117
|
+
describe('ValidationError', () => {
|
|
118
|
+
it('should create validation error', () => {
|
|
119
|
+
const error = new ValidationError('Invalid input');
|
|
120
|
+
expect(error.message).toBe('Invalid input');
|
|
121
|
+
expect(error.name).toBe('ValidationError');
|
|
122
|
+
expect(error.code).toBe('VALIDATION_ERROR');
|
|
123
|
+
expect(error.statusCode).toBe(400);
|
|
124
|
+
});
|
|
125
|
+
});
|
|
126
|
+
|
|
127
|
+
describe('createErrorFromResponse', () => {
|
|
128
|
+
it('should create BadRequestError for 400', () => {
|
|
129
|
+
const response: ApiErrorResponse = {
|
|
130
|
+
error: 'Bad Request',
|
|
131
|
+
message: 'Invalid parameters',
|
|
132
|
+
code: 'INVALID_PARAMS',
|
|
133
|
+
};
|
|
134
|
+
const error = createErrorFromResponse(response, 400);
|
|
135
|
+
expect(error).toBeInstanceOf(BadRequestError);
|
|
136
|
+
expect(error.message).toBe('Invalid parameters');
|
|
137
|
+
expect(error.code).toBe('INVALID_PARAMS');
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
it('should create AuthenticationError for 401', () => {
|
|
141
|
+
const response: ApiErrorResponse = {
|
|
142
|
+
error: 'Unauthorized',
|
|
143
|
+
message: 'Invalid API key',
|
|
144
|
+
};
|
|
145
|
+
const error = createErrorFromResponse(response, 401);
|
|
146
|
+
expect(error).toBeInstanceOf(AuthenticationError);
|
|
147
|
+
expect(error.message).toBe('Invalid API key');
|
|
148
|
+
});
|
|
149
|
+
|
|
150
|
+
it('should create AuthorizationError for 403', () => {
|
|
151
|
+
const response: ApiErrorResponse = {
|
|
152
|
+
error: 'Forbidden',
|
|
153
|
+
message: 'Insufficient permissions',
|
|
154
|
+
};
|
|
155
|
+
const error = createErrorFromResponse(response, 403);
|
|
156
|
+
expect(error).toBeInstanceOf(AuthorizationError);
|
|
157
|
+
});
|
|
158
|
+
|
|
159
|
+
it('should create NotFoundError for 404', () => {
|
|
160
|
+
const response: ApiErrorResponse = {
|
|
161
|
+
error: 'Not Found',
|
|
162
|
+
message: 'Resource does not exist',
|
|
163
|
+
};
|
|
164
|
+
const error = createErrorFromResponse(response, 404);
|
|
165
|
+
expect(error).toBeInstanceOf(NotFoundError);
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
it('should create ConflictError for 409', () => {
|
|
169
|
+
const response: ApiErrorResponse = {
|
|
170
|
+
error: 'Conflict',
|
|
171
|
+
message: 'Resource already exists',
|
|
172
|
+
};
|
|
173
|
+
const error = createErrorFromResponse(response, 409);
|
|
174
|
+
expect(error).toBeInstanceOf(ConflictError);
|
|
175
|
+
});
|
|
176
|
+
|
|
177
|
+
it('should create RateLimitError for 429', () => {
|
|
178
|
+
const response: ApiErrorResponse = {
|
|
179
|
+
error: 'Too Many Requests',
|
|
180
|
+
message: 'Rate limit exceeded',
|
|
181
|
+
};
|
|
182
|
+
const error = createErrorFromResponse(response, 429);
|
|
183
|
+
expect(error).toBeInstanceOf(RateLimitError);
|
|
184
|
+
});
|
|
185
|
+
|
|
186
|
+
it('should create InternalServerError for 500', () => {
|
|
187
|
+
const response: ApiErrorResponse = {
|
|
188
|
+
error: 'Internal Server Error',
|
|
189
|
+
message: 'Something went wrong',
|
|
190
|
+
};
|
|
191
|
+
const error = createErrorFromResponse(response, 500);
|
|
192
|
+
expect(error).toBeInstanceOf(InternalServerError);
|
|
193
|
+
});
|
|
194
|
+
|
|
195
|
+
it('should create InternalServerError for 502', () => {
|
|
196
|
+
const response: ApiErrorResponse = {
|
|
197
|
+
error: 'Bad Gateway',
|
|
198
|
+
message: 'Gateway error',
|
|
199
|
+
};
|
|
200
|
+
const error = createErrorFromResponse(response, 502);
|
|
201
|
+
expect(error).toBeInstanceOf(InternalServerError);
|
|
202
|
+
});
|
|
203
|
+
|
|
204
|
+
it('should create InternalServerError for 503', () => {
|
|
205
|
+
const response: ApiErrorResponse = {
|
|
206
|
+
error: 'Service Unavailable',
|
|
207
|
+
message: 'Service temporarily unavailable',
|
|
208
|
+
};
|
|
209
|
+
const error = createErrorFromResponse(response, 503);
|
|
210
|
+
expect(error).toBeInstanceOf(InternalServerError);
|
|
211
|
+
});
|
|
212
|
+
|
|
213
|
+
it('should create InternalServerError for 504', () => {
|
|
214
|
+
const response: ApiErrorResponse = {
|
|
215
|
+
error: 'Gateway Timeout',
|
|
216
|
+
message: 'Gateway timeout',
|
|
217
|
+
};
|
|
218
|
+
const error = createErrorFromResponse(response, 504);
|
|
219
|
+
expect(error).toBeInstanceOf(InternalServerError);
|
|
220
|
+
});
|
|
221
|
+
|
|
222
|
+
it('should create generic TuturuuuError for unknown status codes', () => {
|
|
223
|
+
const response: ApiErrorResponse = {
|
|
224
|
+
error: 'Unknown',
|
|
225
|
+
message: 'Unknown error',
|
|
226
|
+
code: 'UNKNOWN',
|
|
227
|
+
};
|
|
228
|
+
const error = createErrorFromResponse(response, 418);
|
|
229
|
+
expect(error).toBeInstanceOf(TuturuuuError);
|
|
230
|
+
expect(error.message).toBe('Unknown error');
|
|
231
|
+
expect(error.statusCode).toBe(418);
|
|
232
|
+
});
|
|
233
|
+
});
|
|
234
|
+
|
|
235
|
+
describe('isApiErrorResponse', () => {
|
|
236
|
+
it('should return true for valid ApiErrorResponse', () => {
|
|
237
|
+
const response = {
|
|
238
|
+
error: 'Error',
|
|
239
|
+
message: 'Error message',
|
|
240
|
+
};
|
|
241
|
+
expect(isApiErrorResponse(response)).toBe(true);
|
|
242
|
+
});
|
|
243
|
+
|
|
244
|
+
it('should return true for ApiErrorResponse with code', () => {
|
|
245
|
+
const response = {
|
|
246
|
+
error: 'Error',
|
|
247
|
+
message: 'Error message',
|
|
248
|
+
code: 'ERROR_CODE',
|
|
249
|
+
};
|
|
250
|
+
expect(isApiErrorResponse(response)).toBe(true);
|
|
251
|
+
});
|
|
252
|
+
|
|
253
|
+
it('should return false for null', () => {
|
|
254
|
+
expect(isApiErrorResponse(null)).toBe(false);
|
|
255
|
+
});
|
|
256
|
+
|
|
257
|
+
it('should return false for undefined', () => {
|
|
258
|
+
expect(isApiErrorResponse(undefined)).toBe(false);
|
|
259
|
+
});
|
|
260
|
+
|
|
261
|
+
it('should return false for non-object', () => {
|
|
262
|
+
expect(isApiErrorResponse('string')).toBe(false);
|
|
263
|
+
expect(isApiErrorResponse(123)).toBe(false);
|
|
264
|
+
expect(isApiErrorResponse(true)).toBe(false);
|
|
265
|
+
});
|
|
266
|
+
|
|
267
|
+
it('should return false for object without error property', () => {
|
|
268
|
+
expect(isApiErrorResponse({ message: 'test' })).toBe(false);
|
|
269
|
+
});
|
|
270
|
+
|
|
271
|
+
it('should return false for object without message property', () => {
|
|
272
|
+
expect(isApiErrorResponse({ error: 'test' })).toBe(false);
|
|
273
|
+
});
|
|
274
|
+
|
|
275
|
+
it('should return false for empty object', () => {
|
|
276
|
+
expect(isApiErrorResponse({})).toBe(false);
|
|
277
|
+
});
|
|
278
|
+
});
|
package/src/errors.ts
ADDED
|
@@ -0,0 +1,161 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Error classes for the Tuturuuu SDK
|
|
3
|
+
*/
|
|
4
|
+
|
|
5
|
+
import type { ApiErrorResponse } from './types';
|
|
6
|
+
|
|
7
|
+
/**
|
|
8
|
+
* Base error class for all SDK errors
|
|
9
|
+
*/
|
|
10
|
+
export class TuturuuuError extends Error {
|
|
11
|
+
public readonly code?: string;
|
|
12
|
+
public readonly statusCode?: number;
|
|
13
|
+
|
|
14
|
+
constructor(message: string, code?: string, statusCode?: number) {
|
|
15
|
+
super(message);
|
|
16
|
+
this.name = 'TuturuuuError';
|
|
17
|
+
this.code = code;
|
|
18
|
+
this.statusCode = statusCode;
|
|
19
|
+
|
|
20
|
+
// Maintains proper stack trace for where our error was thrown
|
|
21
|
+
if (Error.captureStackTrace) {
|
|
22
|
+
Error.captureStackTrace(this, this.constructor);
|
|
23
|
+
}
|
|
24
|
+
}
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
/**
|
|
28
|
+
* Authentication error (401)
|
|
29
|
+
*/
|
|
30
|
+
export class AuthenticationError extends TuturuuuError {
|
|
31
|
+
constructor(message: string, code?: string) {
|
|
32
|
+
super(message, code, 401);
|
|
33
|
+
this.name = 'AuthenticationError';
|
|
34
|
+
}
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
/**
|
|
38
|
+
* Authorization error (403)
|
|
39
|
+
*/
|
|
40
|
+
export class AuthorizationError extends TuturuuuError {
|
|
41
|
+
constructor(message: string, code?: string) {
|
|
42
|
+
super(message, code, 403);
|
|
43
|
+
this.name = 'AuthorizationError';
|
|
44
|
+
}
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
/**
|
|
48
|
+
* Not found error (404)
|
|
49
|
+
*/
|
|
50
|
+
export class NotFoundError extends TuturuuuError {
|
|
51
|
+
constructor(message: string, code?: string) {
|
|
52
|
+
super(message, code, 404);
|
|
53
|
+
this.name = 'NotFoundError';
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
/**
|
|
58
|
+
* Bad request error (400)
|
|
59
|
+
*/
|
|
60
|
+
export class BadRequestError extends TuturuuuError {
|
|
61
|
+
constructor(message: string, code?: string) {
|
|
62
|
+
super(message, code, 400);
|
|
63
|
+
this.name = 'BadRequestError';
|
|
64
|
+
}
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
/**
|
|
68
|
+
* Conflict error (409)
|
|
69
|
+
*/
|
|
70
|
+
export class ConflictError extends TuturuuuError {
|
|
71
|
+
constructor(message: string, code?: string) {
|
|
72
|
+
super(message, code, 409);
|
|
73
|
+
this.name = 'ConflictError';
|
|
74
|
+
}
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
/**
|
|
78
|
+
* Rate limit error (429)
|
|
79
|
+
*/
|
|
80
|
+
export class RateLimitError extends TuturuuuError {
|
|
81
|
+
constructor(message: string, code?: string) {
|
|
82
|
+
super(message, code, 429);
|
|
83
|
+
this.name = 'RateLimitError';
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
/**
|
|
88
|
+
* Internal server error (500)
|
|
89
|
+
*/
|
|
90
|
+
export class InternalServerError extends TuturuuuError {
|
|
91
|
+
constructor(message: string, code?: string) {
|
|
92
|
+
super(message, code, 500);
|
|
93
|
+
this.name = 'InternalServerError';
|
|
94
|
+
}
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
/**
|
|
98
|
+
* Network error
|
|
99
|
+
*/
|
|
100
|
+
export class NetworkError extends TuturuuuError {
|
|
101
|
+
constructor(message: string) {
|
|
102
|
+
super(message, 'NETWORK_ERROR');
|
|
103
|
+
this.name = 'NetworkError';
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
/**
|
|
108
|
+
* Validation error
|
|
109
|
+
*/
|
|
110
|
+
export class ValidationError extends TuturuuuError {
|
|
111
|
+
constructor(message: string) {
|
|
112
|
+
super(message, 'VALIDATION_ERROR', 400);
|
|
113
|
+
this.name = 'ValidationError';
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
/**
|
|
118
|
+
* Helper function to create appropriate error from API response
|
|
119
|
+
*/
|
|
120
|
+
export function createErrorFromResponse(
|
|
121
|
+
response: ApiErrorResponse,
|
|
122
|
+
statusCode: number
|
|
123
|
+
): TuturuuuError {
|
|
124
|
+
const { message, code } = response;
|
|
125
|
+
|
|
126
|
+
switch (statusCode) {
|
|
127
|
+
case 400:
|
|
128
|
+
return new BadRequestError(message, code);
|
|
129
|
+
case 401:
|
|
130
|
+
return new AuthenticationError(message, code);
|
|
131
|
+
case 403:
|
|
132
|
+
return new AuthorizationError(message, code);
|
|
133
|
+
case 404:
|
|
134
|
+
return new NotFoundError(message, code);
|
|
135
|
+
case 409:
|
|
136
|
+
return new ConflictError(message, code);
|
|
137
|
+
case 429:
|
|
138
|
+
return new RateLimitError(message, code);
|
|
139
|
+
case 500:
|
|
140
|
+
case 502:
|
|
141
|
+
case 503:
|
|
142
|
+
case 504:
|
|
143
|
+
return new InternalServerError(message, code);
|
|
144
|
+
default:
|
|
145
|
+
return new TuturuuuError(message, code, statusCode);
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
/**
|
|
150
|
+
* Type guard to check if an object is an ApiErrorResponse
|
|
151
|
+
*/
|
|
152
|
+
export function isApiErrorResponse(obj: unknown): obj is ApiErrorResponse {
|
|
153
|
+
return (
|
|
154
|
+
typeof obj === 'object' &&
|
|
155
|
+
obj !== null &&
|
|
156
|
+
'error' in obj &&
|
|
157
|
+
'message' in obj &&
|
|
158
|
+
typeof (obj as any).error === 'string' &&
|
|
159
|
+
typeof (obj as any).message === 'string'
|
|
160
|
+
);
|
|
161
|
+
}
|
package/src/index.ts
ADDED
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Tuturuuu SDK
|
|
3
|
+
*
|
|
4
|
+
* Official TypeScript/JavaScript SDK for interacting with the Tuturuuu platform.
|
|
5
|
+
* Provides access to storage (files/folders) and documents via API keys.
|
|
6
|
+
*
|
|
7
|
+
* @packageDocumentation
|
|
8
|
+
*/
|
|
9
|
+
|
|
10
|
+
// Errors
|
|
11
|
+
export {
|
|
12
|
+
AuthenticationError,
|
|
13
|
+
AuthorizationError,
|
|
14
|
+
BadRequestError,
|
|
15
|
+
ConflictError,
|
|
16
|
+
createErrorFromResponse,
|
|
17
|
+
InternalServerError,
|
|
18
|
+
isApiErrorResponse,
|
|
19
|
+
NetworkError,
|
|
20
|
+
NotFoundError,
|
|
21
|
+
RateLimitError,
|
|
22
|
+
TuturuuuError,
|
|
23
|
+
ValidationError,
|
|
24
|
+
} from './errors';
|
|
25
|
+
export type { TuturuuuClientConfig } from './storage';
|
|
26
|
+
// Main client
|
|
27
|
+
export { DocumentsClient, StorageClient, TuturuuuClient } from './storage';
|
|
28
|
+
// Types
|
|
29
|
+
export type {
|
|
30
|
+
AnalyticsResponse,
|
|
31
|
+
ApiErrorResponse,
|
|
32
|
+
CreateDocumentData,
|
|
33
|
+
CreateFolderResponse,
|
|
34
|
+
DeleteDocumentResponse,
|
|
35
|
+
DeleteResponse,
|
|
36
|
+
Document,
|
|
37
|
+
DocumentResponse,
|
|
38
|
+
GetDocumentResponse,
|
|
39
|
+
ListDocumentsOptions,
|
|
40
|
+
ListDocumentsResponse,
|
|
41
|
+
ListStorageOptions,
|
|
42
|
+
ListStorageResponse,
|
|
43
|
+
Pagination,
|
|
44
|
+
ShareOptions,
|
|
45
|
+
ShareResponse,
|
|
46
|
+
StorageAnalytics,
|
|
47
|
+
StorageObject,
|
|
48
|
+
UpdateDocumentData,
|
|
49
|
+
UploadOptions,
|
|
50
|
+
UploadResponse,
|
|
51
|
+
} from './types';
|
|
52
|
+
// Zod schemas (for external validation if needed)
|
|
53
|
+
export {
|
|
54
|
+
createDocumentDataSchema,
|
|
55
|
+
listDocumentsOptionsSchema,
|
|
56
|
+
listStorageOptionsSchema,
|
|
57
|
+
shareOptionsSchema,
|
|
58
|
+
updateDocumentDataSchema,
|
|
59
|
+
uploadOptionsSchema,
|
|
60
|
+
} from './types';
|