@distilled.cloud/cloudflare 0.12.1 → 0.12.3

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.
Files changed (16) hide show
  1. package/lib/services/accounts.d.ts +69 -57
  2. package/lib/services/accounts.d.ts.map +1 -1
  3. package/lib/services/accounts.js +577 -1528
  4. package/lib/services/accounts.js.map +1 -1
  5. package/lib/services/queues.d.ts +38 -20
  6. package/lib/services/queues.d.ts.map +1 -1
  7. package/lib/services/queues.js +423 -1178
  8. package/lib/services/queues.js.map +1 -1
  9. package/lib/services/r2.d.ts +47 -35
  10. package/lib/services/r2.d.ts.map +1 -1
  11. package/lib/services/r2.js +395 -861
  12. package/lib/services/r2.js.map +1 -1
  13. package/package.json +2 -2
  14. package/src/services/accounts.ts +1068 -3546
  15. package/src/services/queues.ts +856 -2964
  16. package/src/services/r2.ts +861 -2220
package/src/services/r2.ts CHANGED
@@ -10,7 +10,9 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
10
10
  import * as API from "../client/api.ts";
11
11
  import * as T from "../traits.ts";
12
12
  import type { Credentials } from "../credentials.ts";
13
- import { type DefaultErrors } from "../errors.ts";
13
+ import {
14
+ type DefaultErrors,
15
+ } from "../errors.ts";
14
16
  import { UploadableSchema } from "../schemas.ts";
15
17
  import { SensitiveString } from "../sensitive.ts";
16
18
 
@@ -22,73 +24,85 @@ export class BucketAlreadyExists extends Schema.TaggedErrorClass<BucketAlreadyEx
22
24
  "BucketAlreadyExists",
23
25
  { code: Schema.Number, message: Schema.String },
24
26
  ) {}
25
- T.applyErrorMatchers(BucketAlreadyExists, [{ code: 10004 }]);
27
+ T.applyErrorMatchers(BucketAlreadyExists, [{"code":10004}]);
26
28
 
27
29
  export class BucketNotFound extends Schema.TaggedErrorClass<BucketNotFound>()(
28
30
  "BucketNotFound",
29
31
  { code: Schema.Number, message: Schema.String },
30
32
  ) {}
31
- T.applyErrorMatchers(BucketNotFound, [{ code: 10085 }]);
33
+ T.applyErrorMatchers(BucketNotFound, [{"code":10085}]);
32
34
 
33
35
  export class DomainNotFound extends Schema.TaggedErrorClass<DomainNotFound>()(
34
36
  "DomainNotFound",
35
37
  { code: Schema.Number, message: Schema.String },
36
38
  ) {}
37
- T.applyErrorMatchers(DomainNotFound, [{ code: 10053 }]);
39
+ T.applyErrorMatchers(DomainNotFound, [{"code":10053}]);
40
+
41
+ export class EventNotificationConfigNotFound extends Schema.TaggedErrorClass<EventNotificationConfigNotFound>()(
42
+ "EventNotificationConfigNotFound",
43
+ { code: Schema.Number, message: Schema.String },
44
+ ) {}
45
+ T.applyErrorMatchers(EventNotificationConfigNotFound, [{"code":11011}]);
46
+
47
+ export class EventNotificationRuleConflict extends Schema.TaggedErrorClass<EventNotificationRuleConflict>()(
48
+ "EventNotificationRuleConflict",
49
+ { code: Schema.Number, message: Schema.String },
50
+ ) {}
51
+ T.applyErrorMatchers(EventNotificationRuleConflict, [{"code":11020}]);
38
52
 
39
53
  export class InvalidBucketName extends Schema.TaggedErrorClass<InvalidBucketName>()(
40
54
  "InvalidBucketName",
41
55
  { code: Schema.Number, message: Schema.String },
42
56
  ) {}
43
- T.applyErrorMatchers(InvalidBucketName, [{ code: 10005 }]);
57
+ T.applyErrorMatchers(InvalidBucketName, [{"code":10005}]);
44
58
 
45
59
  export class InvalidEventNotificationConfig extends Schema.TaggedErrorClass<InvalidEventNotificationConfig>()(
46
60
  "InvalidEventNotificationConfig",
47
61
  { code: Schema.Number, message: Schema.String },
48
62
  ) {}
49
- T.applyErrorMatchers(InvalidEventNotificationConfig, [{ code: 11014 }]);
63
+ T.applyErrorMatchers(InvalidEventNotificationConfig, [{"code":11014},{"code":11019}]);
50
64
 
51
65
  export class InvalidRoute extends Schema.TaggedErrorClass<InvalidRoute>()(
52
66
  "InvalidRoute",
53
67
  { code: Schema.Number, message: Schema.String },
54
68
  ) {}
55
- T.applyErrorMatchers(InvalidRoute, [{ code: 7003 }]);
69
+ T.applyErrorMatchers(InvalidRoute, [{"code":7003}]);
56
70
 
57
71
  export class InvalidUpstreamCredentials extends Schema.TaggedErrorClass<InvalidUpstreamCredentials>()(
58
72
  "InvalidUpstreamCredentials",
59
73
  { code: Schema.Number, message: Schema.String },
60
74
  ) {}
61
- T.applyErrorMatchers(InvalidUpstreamCredentials, [{ code: 10063 }]);
75
+ T.applyErrorMatchers(InvalidUpstreamCredentials, [{"code":10063}]);
62
76
 
63
77
  export class NoCorsConfiguration extends Schema.TaggedErrorClass<NoCorsConfiguration>()(
64
78
  "NoCorsConfiguration",
65
79
  { code: Schema.Number, message: Schema.String },
66
80
  ) {}
67
- T.applyErrorMatchers(NoCorsConfiguration, [{ code: 10059 }]);
81
+ T.applyErrorMatchers(NoCorsConfiguration, [{"code":10059}]);
68
82
 
69
83
  export class NoEventNotificationConfig extends Schema.TaggedErrorClass<NoEventNotificationConfig>()(
70
84
  "NoEventNotificationConfig",
71
85
  { code: Schema.Number, message: Schema.String },
72
86
  ) {}
73
- T.applyErrorMatchers(NoEventNotificationConfig, [{ code: 11015 }]);
87
+ T.applyErrorMatchers(NoEventNotificationConfig, [{"code":11015}]);
74
88
 
75
- export class NoRoute extends Schema.TaggedErrorClass<NoRoute>()("NoRoute", {
76
- code: Schema.Number,
77
- message: Schema.String,
78
- }) {}
79
- T.applyErrorMatchers(NoRoute, [{ code: 10015 }]);
89
+ export class NoRoute extends Schema.TaggedErrorClass<NoRoute>()(
90
+ "NoRoute",
91
+ { code: Schema.Number, message: Schema.String },
92
+ ) {}
93
+ T.applyErrorMatchers(NoRoute, [{"code":10015}]);
80
94
 
81
95
  export class NoSuchBucket extends Schema.TaggedErrorClass<NoSuchBucket>()(
82
96
  "NoSuchBucket",
83
97
  { code: Schema.Number, message: Schema.String },
84
98
  ) {}
85
- T.applyErrorMatchers(NoSuchBucket, [{ code: 10006 }]);
99
+ T.applyErrorMatchers(NoSuchBucket, [{"code":10006}]);
86
100
 
87
101
  export class QueueNotFound extends Schema.TaggedErrorClass<QueueNotFound>()(
88
102
  "QueueNotFound",
89
103
  { code: Schema.Number, message: Schema.String },
90
104
  ) {}
91
- T.applyErrorMatchers(QueueNotFound, [{ code: 11000 }]);
105
+ T.applyErrorMatchers(QueueNotFound, [{"code":11000}]);
92
106
 
93
107
  // =============================================================================
94
108
  // AllSuperSlurperJob
@@ -98,24 +112,17 @@ export interface AbortAllSuperSlurperJobRequest {
98
112
  accountId: string;
99
113
  }
100
114
 
101
- export const AbortAllSuperSlurperJobRequest =
102
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
103
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
104
- }).pipe(
105
- T.Http({
106
- method: "PUT",
107
- path: "/accounts/{account_id}/slurper/jobs/abortAll",
108
- }),
109
- ) as unknown as Schema.Schema<AbortAllSuperSlurperJobRequest>;
115
+ export const AbortAllSuperSlurperJobRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
116
+ accountId: Schema.String.pipe(T.HttpPath("account_id"))
117
+ })
118
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/slurper/jobs/abortAll" })) as unknown as Schema.Schema<AbortAllSuperSlurperJobRequest>;
110
119
 
111
120
  export type AbortAllSuperSlurperJobResponse = string;
112
121
 
113
- export const AbortAllSuperSlurperJobResponse =
114
- /*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(
115
- T.ResponsePath("result"),
116
- ) as unknown as Schema.Schema<AbortAllSuperSlurperJobResponse>;
122
+ export const AbortAllSuperSlurperJobResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<AbortAllSuperSlurperJobResponse>;
117
123
 
118
- export type AbortAllSuperSlurperJobError = DefaultErrors;
124
+ export type AbortAllSuperSlurperJobError =
125
+ | DefaultErrors;
119
126
 
120
127
  export const abortAllSuperSlurperJob: API.OperationMethod<
121
128
  AbortAllSuperSlurperJobRequest,
@@ -128,6 +135,7 @@ export const abortAllSuperSlurperJob: API.OperationMethod<
128
135
  errors: [],
129
136
  }));
130
137
 
138
+
131
139
  // =============================================================================
132
140
  // Bucket
133
141
  // =============================================================================
@@ -143,15 +151,9 @@ export interface GetBucketRequest {
143
151
  export const GetBucketRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
144
152
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
145
153
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
146
- jurisdiction: Schema.optional(
147
- Schema.Literals(["default", "eu", "fedramp"]),
148
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
149
- }).pipe(
150
- T.Http({
151
- method: "GET",
152
- path: "/accounts/{account_id}/r2/buckets/{bucketName}",
153
- }),
154
- ) as unknown as Schema.Schema<GetBucketRequest>;
154
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
155
+ })
156
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/r2/buckets/{bucketName}" })) as unknown as Schema.Schema<GetBucketRequest>;
155
157
 
156
158
  export interface GetBucketResponse {
157
159
  /** Creation timestamp. */
@@ -159,20 +161,7 @@ export interface GetBucketResponse {
159
161
  /** Jurisdiction where objects in this bucket are guaranteed to be stored. */
160
162
  jurisdiction?: "default" | "eu" | "fedramp" | null;
161
163
  /** Location of the bucket. */
162
- location?:
163
- | "apac"
164
- | "eeur"
165
- | "enam"
166
- | "weur"
167
- | "wnam"
168
- | "oc"
169
- | "APAC"
170
- | "EEUR"
171
- | "ENAM"
172
- | "WEUR"
173
- | "WNAM"
174
- | "OC"
175
- | null;
164
+ location?: "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc" | "APAC" | "EEUR" | "ENAM" | "WEUR" | "WNAM" | "OC" | null;
176
165
  /** Name of the bucket. */
177
166
  name?: string | null;
178
167
  /** Storage class for newly uploaded objects, unless specified otherwise. */
@@ -181,50 +170,16 @@ export interface GetBucketResponse {
181
170
 
182
171
  export const GetBucketResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
183
172
  creationDate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
184
- jurisdiction: Schema.optional(
185
- Schema.Union([Schema.Literals(["default", "eu", "fedramp"]), Schema.Null]),
186
- ),
187
- location: Schema.optional(
188
- Schema.Union([
189
- Schema.Literals([
190
- "apac",
191
- "eeur",
192
- "enam",
193
- "weur",
194
- "wnam",
195
- "oc",
196
- "APAC",
197
- "EEUR",
198
- "ENAM",
199
- "WEUR",
200
- "WNAM",
201
- "OC",
202
- ]),
203
- Schema.Null,
204
- ]),
205
- ),
173
+ jurisdiction: Schema.optional(Schema.Union([Schema.Literals(["default", "eu", "fedramp"]), Schema.Null])),
174
+ location: Schema.optional(Schema.Union([Schema.Literals(["apac", "eeur", "enam", "weur", "wnam", "oc", "APAC", "EEUR", "ENAM", "WEUR", "WNAM", "OC"]), Schema.Null])),
206
175
  name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
207
- storageClass: Schema.optional(
208
- Schema.Union([
209
- Schema.Literals(["Standard", "InfrequentAccess"]),
210
- Schema.Null,
211
- ]),
212
- ),
213
- })
214
- .pipe(
215
- Schema.encodeKeys({
216
- creationDate: "creation_date",
217
- jurisdiction: "jurisdiction",
218
- location: "location",
219
- name: "name",
220
- storageClass: "storage_class",
221
- }),
222
- )
223
- .pipe(
224
- T.ResponsePath("result"),
225
- ) as unknown as Schema.Schema<GetBucketResponse>;
226
-
227
- export type GetBucketError = DefaultErrors | NoSuchBucket | InvalidRoute;
176
+ storageClass: Schema.optional(Schema.Union([Schema.Literals(["Standard", "InfrequentAccess"]), Schema.Null]))
177
+ }).pipe(Schema.encodeKeys({ creationDate: "creation_date", jurisdiction: "jurisdiction", location: "location", name: "name", storageClass: "storage_class" })).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<GetBucketResponse>;
178
+
179
+ export type GetBucketError =
180
+ | DefaultErrors
181
+ | NoSuchBucket
182
+ | InvalidRoute;
228
183
 
229
184
  export const getBucket: API.OperationMethod<
230
185
  GetBucketRequest,
@@ -259,105 +214,32 @@ export interface ListBucketsRequest {
259
214
  export const ListBucketsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
260
215
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
261
216
  cursor: Schema.optional(Schema.String).pipe(T.HttpQuery("cursor")),
262
- direction: Schema.optional(Schema.Literals(["asc", "desc"])).pipe(
263
- T.HttpQuery("direction"),
264
- ),
265
- nameContains: Schema.optional(Schema.String).pipe(
266
- T.HttpQuery("name_contains"),
267
- ),
217
+ direction: Schema.optional(Schema.Literals(["asc", "desc"])).pipe(T.HttpQuery("direction")),
218
+ nameContains: Schema.optional(Schema.String).pipe(T.HttpQuery("name_contains")),
268
219
  order: Schema.optional(Schema.Literal("name")).pipe(T.HttpQuery("order")),
269
220
  perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
270
221
  startAfter: Schema.optional(Schema.String).pipe(T.HttpQuery("start_after")),
271
- jurisdiction: Schema.optional(
272
- Schema.Literals(["default", "eu", "fedramp"]),
273
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
274
- }).pipe(
275
- T.Http({ method: "GET", path: "/accounts/{account_id}/r2/buckets" }),
276
- ) as unknown as Schema.Schema<ListBucketsRequest>;
222
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
223
+ })
224
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/r2/buckets" })) as unknown as Schema.Schema<ListBucketsRequest>;
277
225
 
278
226
  export interface ListBucketsResponse {
279
- buckets?:
280
- | {
281
- creationDate?: string | null;
282
- jurisdiction?: "default" | "eu" | "fedramp" | null;
283
- location?:
284
- | "apac"
285
- | "eeur"
286
- | "enam"
287
- | "weur"
288
- | "wnam"
289
- | "oc"
290
- | "APAC"
291
- | "EEUR"
292
- | "ENAM"
293
- | "WEUR"
294
- | "WNAM"
295
- | "OC"
296
- | null;
297
- name?: string | null;
298
- storageClass?: "Standard" | "InfrequentAccess" | null;
299
- }[]
300
- | null;
227
+ buckets?: ({ creationDate?: string | null; jurisdiction?: "default" | "eu" | "fedramp" | null; location?: "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc" | "APAC" | "EEUR" | "ENAM" | "WEUR" | "WNAM" | "OC" | null; name?: string | null; storageClass?: "Standard" | "InfrequentAccess" | null })[] | null;
301
228
  }
302
229
 
303
230
  export const ListBucketsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
304
- buckets: Schema.optional(
305
- Schema.Union([
306
- Schema.Array(
307
- Schema.Struct({
308
- creationDate: Schema.optional(
309
- Schema.Union([Schema.String, Schema.Null]),
310
- ),
311
- jurisdiction: Schema.optional(
312
- Schema.Union([
313
- Schema.Literals(["default", "eu", "fedramp"]),
314
- Schema.Null,
315
- ]),
316
- ),
317
- location: Schema.optional(
318
- Schema.Union([
319
- Schema.Literals([
320
- "apac",
321
- "eeur",
322
- "enam",
323
- "weur",
324
- "wnam",
325
- "oc",
326
- "APAC",
327
- "EEUR",
328
- "ENAM",
329
- "WEUR",
330
- "WNAM",
331
- "OC",
332
- ]),
333
- Schema.Null,
334
- ]),
335
- ),
336
- name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
337
- storageClass: Schema.optional(
338
- Schema.Union([
339
- Schema.Literals(["Standard", "InfrequentAccess"]),
340
- Schema.Null,
341
- ]),
342
- ),
343
- }).pipe(
344
- Schema.encodeKeys({
345
- creationDate: "creation_date",
346
- jurisdiction: "jurisdiction",
347
- location: "location",
348
- name: "name",
349
- storageClass: "storage_class",
350
- }),
351
- ),
352
- ),
353
- Schema.Null,
354
- ]),
355
- ),
356
- }).pipe(
357
- T.ResponsePath("result"),
358
- ) as unknown as Schema.Schema<ListBucketsResponse>;
359
-
360
- export type ListBucketsError = DefaultErrors | InvalidRoute;
231
+ buckets: Schema.optional(Schema.Union([Schema.Array(Schema.Struct({
232
+ creationDate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
233
+ jurisdiction: Schema.optional(Schema.Union([Schema.Literals(["default", "eu", "fedramp"]), Schema.Null])),
234
+ location: Schema.optional(Schema.Union([Schema.Literals(["apac", "eeur", "enam", "weur", "wnam", "oc", "APAC", "EEUR", "ENAM", "WEUR", "WNAM", "OC"]), Schema.Null])),
235
+ name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
236
+ storageClass: Schema.optional(Schema.Union([Schema.Literals(["Standard", "InfrequentAccess"]), Schema.Null]))
237
+ }).pipe(Schema.encodeKeys({ creationDate: "creation_date", jurisdiction: "jurisdiction", location: "location", name: "name", storageClass: "storage_class" }))), Schema.Null]))
238
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<ListBucketsResponse>;
239
+
240
+ export type ListBucketsError =
241
+ | DefaultErrors
242
+ | InvalidRoute;
361
243
 
362
244
  export const listBuckets: API.OperationMethod<
363
245
  ListBucketsRequest,
@@ -385,19 +267,12 @@ export interface CreateBucketRequest {
385
267
 
386
268
  export const CreateBucketRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
387
269
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
388
- jurisdiction: Schema.optional(
389
- Schema.Literals(["default", "eu", "fedramp"]),
390
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
270
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction")),
391
271
  name: Schema.String,
392
- locationHint: Schema.optional(
393
- Schema.Literals(["apac", "eeur", "enam", "weur", "wnam", "oc"]),
394
- ),
395
- storageClass: Schema.optional(
396
- Schema.Literals(["Standard", "InfrequentAccess"]),
397
- ),
398
- }).pipe(
399
- T.Http({ method: "POST", path: "/accounts/{account_id}/r2/buckets" }),
400
- ) as unknown as Schema.Schema<CreateBucketRequest>;
272
+ locationHint: Schema.optional(Schema.Literals(["apac", "eeur", "enam", "weur", "wnam", "oc"])),
273
+ storageClass: Schema.optional(Schema.Literals(["Standard", "InfrequentAccess"]))
274
+ })
275
+ .pipe(T.Http({ method: "POST", path: "/accounts/{account_id}/r2/buckets" })) as unknown as Schema.Schema<CreateBucketRequest>;
401
276
 
402
277
  export interface CreateBucketResponse {
403
278
  /** Creation timestamp. */
@@ -405,20 +280,7 @@ export interface CreateBucketResponse {
405
280
  /** Jurisdiction where objects in this bucket are guaranteed to be stored. */
406
281
  jurisdiction?: "default" | "eu" | "fedramp" | null;
407
282
  /** Location of the bucket. */
408
- location?:
409
- | "apac"
410
- | "eeur"
411
- | "enam"
412
- | "weur"
413
- | "wnam"
414
- | "oc"
415
- | "APAC"
416
- | "EEUR"
417
- | "ENAM"
418
- | "WEUR"
419
- | "WNAM"
420
- | "OC"
421
- | null;
283
+ location?: "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc" | "APAC" | "EEUR" | "ENAM" | "WEUR" | "WNAM" | "OC" | null;
422
284
  /** Name of the bucket. */
423
285
  name?: string | null;
424
286
  /** Storage class for newly uploaded objects, unless specified otherwise. */
@@ -427,48 +289,11 @@ export interface CreateBucketResponse {
427
289
 
428
290
  export const CreateBucketResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
429
291
  creationDate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
430
- jurisdiction: Schema.optional(
431
- Schema.Union([Schema.Literals(["default", "eu", "fedramp"]), Schema.Null]),
432
- ),
433
- location: Schema.optional(
434
- Schema.Union([
435
- Schema.Literals([
436
- "apac",
437
- "eeur",
438
- "enam",
439
- "weur",
440
- "wnam",
441
- "oc",
442
- "APAC",
443
- "EEUR",
444
- "ENAM",
445
- "WEUR",
446
- "WNAM",
447
- "OC",
448
- ]),
449
- Schema.Null,
450
- ]),
451
- ),
292
+ jurisdiction: Schema.optional(Schema.Union([Schema.Literals(["default", "eu", "fedramp"]), Schema.Null])),
293
+ location: Schema.optional(Schema.Union([Schema.Literals(["apac", "eeur", "enam", "weur", "wnam", "oc", "APAC", "EEUR", "ENAM", "WEUR", "WNAM", "OC"]), Schema.Null])),
452
294
  name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
453
- storageClass: Schema.optional(
454
- Schema.Union([
455
- Schema.Literals(["Standard", "InfrequentAccess"]),
456
- Schema.Null,
457
- ]),
458
- ),
459
- })
460
- .pipe(
461
- Schema.encodeKeys({
462
- creationDate: "creation_date",
463
- jurisdiction: "jurisdiction",
464
- location: "location",
465
- name: "name",
466
- storageClass: "storage_class",
467
- }),
468
- )
469
- .pipe(
470
- T.ResponsePath("result"),
471
- ) as unknown as Schema.Schema<CreateBucketResponse>;
295
+ storageClass: Schema.optional(Schema.Union([Schema.Literals(["Standard", "InfrequentAccess"]), Schema.Null]))
296
+ }).pipe(Schema.encodeKeys({ creationDate: "creation_date", jurisdiction: "jurisdiction", location: "location", name: "name", storageClass: "storage_class" })).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<CreateBucketResponse>;
472
297
 
473
298
  export type CreateBucketError =
474
299
  | DefaultErrors
@@ -500,18 +325,10 @@ export interface PatchBucketRequest {
500
325
  export const PatchBucketRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
501
326
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
502
327
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
503
- storageClass: Schema.Literals(["Standard", "InfrequentAccess"]).pipe(
504
- T.HttpHeader("cf-r2-storage-class"),
505
- ),
506
- jurisdiction: Schema.optional(
507
- Schema.Literals(["default", "eu", "fedramp"]),
508
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
509
- }).pipe(
510
- T.Http({
511
- method: "PATCH",
512
- path: "/accounts/{account_id}/r2/buckets/{bucketName}",
513
- }),
514
- ) as unknown as Schema.Schema<PatchBucketRequest>;
328
+ storageClass: Schema.Literals(["Standard", "InfrequentAccess"]).pipe(T.HttpHeader("cf-r2-storage-class")),
329
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
330
+ })
331
+ .pipe(T.Http({ method: "PATCH", path: "/accounts/{account_id}/r2/buckets/{bucketName}" })) as unknown as Schema.Schema<PatchBucketRequest>;
515
332
 
516
333
  export interface PatchBucketResponse {
517
334
  /** Creation timestamp. */
@@ -519,20 +336,7 @@ export interface PatchBucketResponse {
519
336
  /** Jurisdiction where objects in this bucket are guaranteed to be stored. */
520
337
  jurisdiction?: "default" | "eu" | "fedramp" | null;
521
338
  /** Location of the bucket. */
522
- location?:
523
- | "apac"
524
- | "eeur"
525
- | "enam"
526
- | "weur"
527
- | "wnam"
528
- | "oc"
529
- | "APAC"
530
- | "EEUR"
531
- | "ENAM"
532
- | "WEUR"
533
- | "WNAM"
534
- | "OC"
535
- | null;
339
+ location?: "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc" | "APAC" | "EEUR" | "ENAM" | "WEUR" | "WNAM" | "OC" | null;
536
340
  /** Name of the bucket. */
537
341
  name?: string | null;
538
342
  /** Storage class for newly uploaded objects, unless specified otherwise. */
@@ -541,50 +345,16 @@ export interface PatchBucketResponse {
541
345
 
542
346
  export const PatchBucketResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
543
347
  creationDate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
544
- jurisdiction: Schema.optional(
545
- Schema.Union([Schema.Literals(["default", "eu", "fedramp"]), Schema.Null]),
546
- ),
547
- location: Schema.optional(
548
- Schema.Union([
549
- Schema.Literals([
550
- "apac",
551
- "eeur",
552
- "enam",
553
- "weur",
554
- "wnam",
555
- "oc",
556
- "APAC",
557
- "EEUR",
558
- "ENAM",
559
- "WEUR",
560
- "WNAM",
561
- "OC",
562
- ]),
563
- Schema.Null,
564
- ]),
565
- ),
348
+ jurisdiction: Schema.optional(Schema.Union([Schema.Literals(["default", "eu", "fedramp"]), Schema.Null])),
349
+ location: Schema.optional(Schema.Union([Schema.Literals(["apac", "eeur", "enam", "weur", "wnam", "oc", "APAC", "EEUR", "ENAM", "WEUR", "WNAM", "OC"]), Schema.Null])),
566
350
  name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
567
- storageClass: Schema.optional(
568
- Schema.Union([
569
- Schema.Literals(["Standard", "InfrequentAccess"]),
570
- Schema.Null,
571
- ]),
572
- ),
573
- })
574
- .pipe(
575
- Schema.encodeKeys({
576
- creationDate: "creation_date",
577
- jurisdiction: "jurisdiction",
578
- location: "location",
579
- name: "name",
580
- storageClass: "storage_class",
581
- }),
582
- )
583
- .pipe(
584
- T.ResponsePath("result"),
585
- ) as unknown as Schema.Schema<PatchBucketResponse>;
586
-
587
- export type PatchBucketError = DefaultErrors | NoSuchBucket | InvalidRoute;
351
+ storageClass: Schema.optional(Schema.Union([Schema.Literals(["Standard", "InfrequentAccess"]), Schema.Null]))
352
+ }).pipe(Schema.encodeKeys({ creationDate: "creation_date", jurisdiction: "jurisdiction", location: "location", name: "name", storageClass: "storage_class" })).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<PatchBucketResponse>;
353
+
354
+ export type PatchBucketError =
355
+ | DefaultErrors
356
+ | NoSuchBucket
357
+ | InvalidRoute;
588
358
 
589
359
  export const patchBucket: API.OperationMethod<
590
360
  PatchBucketRequest,
@@ -608,22 +378,13 @@ export interface DeleteBucketRequest {
608
378
  export const DeleteBucketRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
609
379
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
610
380
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
611
- jurisdiction: Schema.optional(
612
- Schema.Literals(["default", "eu", "fedramp"]),
613
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
614
- }).pipe(
615
- T.Http({
616
- method: "DELETE",
617
- path: "/accounts/{account_id}/r2/buckets/{bucketName}",
618
- }),
619
- ) as unknown as Schema.Schema<DeleteBucketRequest>;
381
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
382
+ })
383
+ .pipe(T.Http({ method: "DELETE", path: "/accounts/{account_id}/r2/buckets/{bucketName}" })) as unknown as Schema.Schema<DeleteBucketRequest>;
620
384
 
621
385
  export type DeleteBucketResponse = unknown;
622
386
 
623
- export const DeleteBucketResponse =
624
- /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
625
- T.ResponsePath("result"),
626
- ) as unknown as Schema.Schema<DeleteBucketResponse>;
387
+ export const DeleteBucketResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<DeleteBucketResponse>;
627
388
 
628
389
  export type DeleteBucketError =
629
390
  | DefaultErrors
@@ -642,6 +403,7 @@ export const deleteBucket: API.OperationMethod<
642
403
  errors: [NoSuchBucket, InvalidRoute, NoRoute],
643
404
  }));
644
405
 
406
+
645
407
  // =============================================================================
646
408
  // BucketCor
647
409
  // =============================================================================
@@ -657,60 +419,26 @@ export interface GetBucketCorsRequest {
657
419
  export const GetBucketCorsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
658
420
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
659
421
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
660
- jurisdiction: Schema.optional(
661
- Schema.Literals(["default", "eu", "fedramp"]),
662
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
663
- }).pipe(
664
- T.Http({
665
- method: "GET",
666
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/cors",
667
- }),
668
- ) as unknown as Schema.Schema<GetBucketCorsRequest>;
422
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
423
+ })
424
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/r2/buckets/{bucketName}/cors" })) as unknown as Schema.Schema<GetBucketCorsRequest>;
669
425
 
670
426
  export interface GetBucketCorsResponse {
671
- rules?:
672
- | {
673
- allowed: {
674
- methods: ("GET" | "PUT" | "POST" | "DELETE" | "HEAD")[];
675
- origins: string[];
676
- headers?: string[] | null;
677
- };
678
- id?: string | null;
679
- exposeHeaders?: string[] | null;
680
- maxAgeSeconds?: number | null;
681
- }[]
682
- | null;
427
+ rules?: ({ allowed: { methods: ("GET" | "PUT" | "POST" | "DELETE" | "HEAD")[]; origins: string[]; headers?: string[] | null }; id?: string | null; exposeHeaders?: string[] | null; maxAgeSeconds?: number | null })[] | null;
683
428
  }
684
429
 
685
430
  export const GetBucketCorsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
686
- rules: Schema.optional(
687
- Schema.Union([
688
- Schema.Array(
689
- Schema.Struct({
690
- allowed: Schema.Struct({
691
- methods: Schema.Array(
692
- Schema.Literals(["GET", "PUT", "POST", "DELETE", "HEAD"]),
693
- ),
694
- origins: Schema.Array(Schema.String),
695
- headers: Schema.optional(
696
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
697
- ),
698
- }),
699
- id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
700
- exposeHeaders: Schema.optional(
701
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
702
- ),
703
- maxAgeSeconds: Schema.optional(
704
- Schema.Union([Schema.Number, Schema.Null]),
705
- ),
706
- }),
707
- ),
708
- Schema.Null,
709
- ]),
710
- ),
711
- }).pipe(
712
- T.ResponsePath("result"),
713
- ) as unknown as Schema.Schema<GetBucketCorsResponse>;
431
+ rules: Schema.optional(Schema.Union([Schema.Array(Schema.Struct({
432
+ allowed: Schema.Struct({
433
+ methods: Schema.Array(Schema.Literals(["GET", "PUT", "POST", "DELETE", "HEAD"])),
434
+ origins: Schema.Array(Schema.String),
435
+ headers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null]))
436
+ }),
437
+ id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
438
+ exposeHeaders: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
439
+ maxAgeSeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null]))
440
+ })), Schema.Null]))
441
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<GetBucketCorsResponse>;
714
442
 
715
443
  export type GetBucketCorsError =
716
444
  | DefaultErrors
@@ -736,55 +464,34 @@ export interface PutBucketCorsRequest {
736
464
  /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
737
465
  jurisdiction?: "default" | "eu" | "fedramp";
738
466
  /** Body param: */
739
- rules?: {
740
- allowed: {
741
- methods: ("GET" | "PUT" | "POST" | "DELETE" | "HEAD")[];
742
- origins: string[];
743
- headers?: string[];
744
- };
745
- id?: string;
746
- exposeHeaders?: string[];
747
- maxAgeSeconds?: number;
748
- }[];
467
+ rules?: ({ allowed: { methods: ("GET" | "PUT" | "POST" | "DELETE" | "HEAD")[]; origins: string[]; headers?: string[] }; id?: string; exposeHeaders?: string[]; maxAgeSeconds?: number })[];
749
468
  }
750
469
 
751
470
  export const PutBucketCorsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
752
471
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
753
472
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
754
- jurisdiction: Schema.optional(
755
- Schema.Literals(["default", "eu", "fedramp"]),
756
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
757
- rules: Schema.optional(
758
- Schema.Array(
759
- Schema.Struct({
760
- allowed: Schema.Struct({
761
- methods: Schema.Array(
762
- Schema.Literals(["GET", "PUT", "POST", "DELETE", "HEAD"]),
763
- ),
764
- origins: Schema.Array(Schema.String),
765
- headers: Schema.optional(Schema.Array(Schema.String)),
766
- }),
767
- id: Schema.optional(Schema.String),
768
- exposeHeaders: Schema.optional(Schema.Array(Schema.String)),
769
- maxAgeSeconds: Schema.optional(Schema.Number),
770
- }),
771
- ),
772
- ),
773
- }).pipe(
774
- T.Http({
775
- method: "PUT",
776
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/cors",
473
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction")),
474
+ rules: Schema.optional(Schema.Array(Schema.Struct({
475
+ allowed: Schema.Struct({
476
+ methods: Schema.Array(Schema.Literals(["GET", "PUT", "POST", "DELETE", "HEAD"])),
477
+ origins: Schema.Array(Schema.String),
478
+ headers: Schema.optional(Schema.Array(Schema.String))
777
479
  }),
778
- ) as unknown as Schema.Schema<PutBucketCorsRequest>;
480
+ id: Schema.optional(Schema.String),
481
+ exposeHeaders: Schema.optional(Schema.Array(Schema.String)),
482
+ maxAgeSeconds: Schema.optional(Schema.Number)
483
+ })))
484
+ })
485
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/r2/buckets/{bucketName}/cors" })) as unknown as Schema.Schema<PutBucketCorsRequest>;
779
486
 
780
487
  export type PutBucketCorsResponse = unknown;
781
488
 
782
- export const PutBucketCorsResponse =
783
- /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
784
- T.ResponsePath("result"),
785
- ) as unknown as Schema.Schema<PutBucketCorsResponse>;
489
+ export const PutBucketCorsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<PutBucketCorsResponse>;
786
490
 
787
- export type PutBucketCorsError = DefaultErrors | NoSuchBucket | InvalidRoute;
491
+ export type PutBucketCorsError =
492
+ | DefaultErrors
493
+ | NoSuchBucket
494
+ | InvalidRoute;
788
495
 
789
496
  export const putBucketCors: API.OperationMethod<
790
497
  PutBucketCorsRequest,
@@ -805,28 +512,21 @@ export interface DeleteBucketCorsRequest {
805
512
  jurisdiction?: "default" | "eu" | "fedramp";
806
513
  }
807
514
 
808
- export const DeleteBucketCorsRequest =
809
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
810
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
811
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
812
- jurisdiction: Schema.optional(
813
- Schema.Literals(["default", "eu", "fedramp"]),
814
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
815
- }).pipe(
816
- T.Http({
817
- method: "DELETE",
818
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/cors",
819
- }),
820
- ) as unknown as Schema.Schema<DeleteBucketCorsRequest>;
515
+ export const DeleteBucketCorsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
516
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
517
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
518
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
519
+ })
520
+ .pipe(T.Http({ method: "DELETE", path: "/accounts/{account_id}/r2/buckets/{bucketName}/cors" })) as unknown as Schema.Schema<DeleteBucketCorsRequest>;
821
521
 
822
522
  export type DeleteBucketCorsResponse = unknown;
823
523
 
824
- export const DeleteBucketCorsResponse =
825
- /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
826
- T.ResponsePath("result"),
827
- ) as unknown as Schema.Schema<DeleteBucketCorsResponse>;
524
+ export const DeleteBucketCorsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<DeleteBucketCorsResponse>;
828
525
 
829
- export type DeleteBucketCorsError = DefaultErrors | NoSuchBucket | InvalidRoute;
526
+ export type DeleteBucketCorsError =
527
+ | DefaultErrors
528
+ | NoSuchBucket
529
+ | InvalidRoute;
830
530
 
831
531
  export const deleteBucketCors: API.OperationMethod<
832
532
  DeleteBucketCorsRequest,
@@ -839,6 +539,7 @@ export const deleteBucketCors: API.OperationMethod<
839
539
  errors: [NoSuchBucket, InvalidRoute],
840
540
  }));
841
541
 
542
+
842
543
  // =============================================================================
843
544
  // BucketDomainCustom
844
545
  // =============================================================================
@@ -852,42 +553,20 @@ export interface GetBucketDomainCustomRequest {
852
553
  jurisdiction?: "default" | "eu" | "fedramp";
853
554
  }
854
555
 
855
- export const GetBucketDomainCustomRequest =
856
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
857
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
858
- domain: Schema.String.pipe(T.HttpPath("domain")),
859
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
860
- jurisdiction: Schema.optional(
861
- Schema.Literals(["default", "eu", "fedramp"]),
862
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
863
- }).pipe(
864
- T.Http({
865
- method: "GET",
866
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/custom/{domain}",
867
- }),
868
- ) as unknown as Schema.Schema<GetBucketDomainCustomRequest>;
556
+ export const GetBucketDomainCustomRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
557
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
558
+ domain: Schema.String.pipe(T.HttpPath("domain")),
559
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
560
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
561
+ })
562
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/custom/{domain}" })) as unknown as Schema.Schema<GetBucketDomainCustomRequest>;
869
563
 
870
564
  export interface GetBucketDomainCustomResponse {
871
565
  /** Domain name of the custom domain to be added. */
872
566
  domain: string;
873
567
  /** Whether this bucket is publicly accessible at the specified custom domain. */
874
568
  enabled: boolean;
875
- status: {
876
- ownership:
877
- | "pending"
878
- | "active"
879
- | "deactivated"
880
- | "blocked"
881
- | "error"
882
- | "unknown";
883
- ssl:
884
- | "initializing"
885
- | "pending"
886
- | "active"
887
- | "deactivated"
888
- | "error"
889
- | "unknown";
890
- };
569
+ status: { ownership: "pending" | "active" | "deactivated" | "blocked" | "error" | "unknown"; ssl: "initializing" | "pending" | "active" | "deactivated" | "error" | "unknown" };
891
570
  /** An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
892
571
  ciphers?: string[] | null;
893
572
  /** Minimum TLS Version the custom domain will accept for incoming connections. If not set, defaults to 1.0. */
@@ -898,42 +577,18 @@ export interface GetBucketDomainCustomResponse {
898
577
  zoneName?: string | null;
899
578
  }
900
579
 
901
- export const GetBucketDomainCustomResponse =
902
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
903
- domain: Schema.String,
904
- enabled: Schema.Boolean,
905
- status: Schema.Struct({
906
- ownership: Schema.Literals([
907
- "pending",
908
- "active",
909
- "deactivated",
910
- "blocked",
911
- "error",
912
- "unknown",
913
- ]),
914
- ssl: Schema.Literals([
915
- "initializing",
916
- "pending",
917
- "active",
918
- "deactivated",
919
- "error",
920
- "unknown",
921
- ]),
922
- }),
923
- ciphers: Schema.optional(
924
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
925
- ),
926
- minTLS: Schema.optional(
927
- Schema.Union([
928
- Schema.Literals(["1.0", "1.1", "1.2", "1.3"]),
929
- Schema.Null,
930
- ]),
931
- ),
932
- zoneId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
933
- zoneName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
934
- }).pipe(
935
- T.ResponsePath("result"),
936
- ) as unknown as Schema.Schema<GetBucketDomainCustomResponse>;
580
+ export const GetBucketDomainCustomResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
581
+ domain: Schema.String,
582
+ enabled: Schema.Boolean,
583
+ status: Schema.Struct({
584
+ ownership: Schema.Literals(["pending", "active", "deactivated", "blocked", "error", "unknown"]),
585
+ ssl: Schema.Literals(["initializing", "pending", "active", "deactivated", "error", "unknown"])
586
+ }),
587
+ ciphers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
588
+ minTLS: Schema.optional(Schema.Union([Schema.Literals(["1.0", "1.1", "1.2", "1.3"]), Schema.Null])),
589
+ zoneId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
590
+ zoneName: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
591
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<GetBucketDomainCustomResponse>;
937
592
 
938
593
  export type GetBucketDomainCustomError =
939
594
  | DefaultErrors
@@ -960,87 +615,31 @@ export interface ListBucketDomainCustomsRequest {
960
615
  jurisdiction?: "default" | "eu" | "fedramp";
961
616
  }
962
617
 
963
- export const ListBucketDomainCustomsRequest =
964
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
965
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
966
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
967
- jurisdiction: Schema.optional(
968
- Schema.Literals(["default", "eu", "fedramp"]),
969
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
970
- }).pipe(
971
- T.Http({
972
- method: "GET",
973
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/custom",
974
- }),
975
- ) as unknown as Schema.Schema<ListBucketDomainCustomsRequest>;
618
+ export const ListBucketDomainCustomsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
619
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
620
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
621
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
622
+ })
623
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/custom" })) as unknown as Schema.Schema<ListBucketDomainCustomsRequest>;
976
624
 
977
625
  export interface ListBucketDomainCustomsResponse {
978
- domains: {
979
- domain: string;
980
- enabled: boolean;
981
- status: {
982
- ownership:
983
- | "pending"
984
- | "active"
985
- | "deactivated"
986
- | "blocked"
987
- | "error"
988
- | "unknown";
989
- ssl:
990
- | "initializing"
991
- | "pending"
992
- | "active"
993
- | "deactivated"
994
- | "error"
995
- | "unknown";
996
- };
997
- ciphers?: string[] | null;
998
- minTLS?: "1.0" | "1.1" | "1.2" | "1.3" | null;
999
- zoneId?: string | null;
1000
- zoneName?: string | null;
1001
- }[];
1002
- }
1003
-
1004
- export const ListBucketDomainCustomsResponse =
1005
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1006
- domains: Schema.Array(
1007
- Schema.Struct({
1008
- domain: Schema.String,
1009
- enabled: Schema.Boolean,
1010
- status: Schema.Struct({
1011
- ownership: Schema.Literals([
1012
- "pending",
1013
- "active",
1014
- "deactivated",
1015
- "blocked",
1016
- "error",
1017
- "unknown",
1018
- ]),
1019
- ssl: Schema.Literals([
1020
- "initializing",
1021
- "pending",
1022
- "active",
1023
- "deactivated",
1024
- "error",
1025
- "unknown",
1026
- ]),
1027
- }),
1028
- ciphers: Schema.optional(
1029
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
1030
- ),
1031
- minTLS: Schema.optional(
1032
- Schema.Union([
1033
- Schema.Literals(["1.0", "1.1", "1.2", "1.3"]),
1034
- Schema.Null,
1035
- ]),
1036
- ),
1037
- zoneId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1038
- zoneName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1039
- }),
1040
- ),
1041
- }).pipe(
1042
- T.ResponsePath("result"),
1043
- ) as unknown as Schema.Schema<ListBucketDomainCustomsResponse>;
626
+ domains: ({ domain: string; enabled: boolean; status: { ownership: "pending" | "active" | "deactivated" | "blocked" | "error" | "unknown"; ssl: "initializing" | "pending" | "active" | "deactivated" | "error" | "unknown" }; ciphers?: string[] | null; minTLS?: "1.0" | "1.1" | "1.2" | "1.3" | null; zoneId?: string | null; zoneName?: string | null })[];
627
+ }
628
+
629
+ export const ListBucketDomainCustomsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
630
+ domains: Schema.Array(Schema.Struct({
631
+ domain: Schema.String,
632
+ enabled: Schema.Boolean,
633
+ status: Schema.Struct({
634
+ ownership: Schema.Literals(["pending", "active", "deactivated", "blocked", "error", "unknown"]),
635
+ ssl: Schema.Literals(["initializing", "pending", "active", "deactivated", "error", "unknown"])
636
+ }),
637
+ ciphers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
638
+ minTLS: Schema.optional(Schema.Union([Schema.Literals(["1.0", "1.1", "1.2", "1.3"]), Schema.Null])),
639
+ zoneId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
640
+ zoneName: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
641
+ }))
642
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<ListBucketDomainCustomsResponse>;
1044
643
 
1045
644
  export type ListBucketDomainCustomsError =
1046
645
  | DefaultErrors
@@ -1076,24 +675,17 @@ export interface CreateBucketDomainCustomRequest {
1076
675
  minTLS?: "1.0" | "1.1" | "1.2" | "1.3";
1077
676
  }
1078
677
 
1079
- export const CreateBucketDomainCustomRequest =
1080
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1081
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1082
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
1083
- jurisdiction: Schema.optional(
1084
- Schema.Literals(["default", "eu", "fedramp"]),
1085
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1086
- domain: Schema.String,
1087
- enabled: Schema.Boolean,
1088
- zoneId: Schema.String,
1089
- ciphers: Schema.optional(Schema.Array(Schema.String)),
1090
- minTLS: Schema.optional(Schema.Literals(["1.0", "1.1", "1.2", "1.3"])),
1091
- }).pipe(
1092
- T.Http({
1093
- method: "POST",
1094
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/custom",
1095
- }),
1096
- ) as unknown as Schema.Schema<CreateBucketDomainCustomRequest>;
678
+ export const CreateBucketDomainCustomRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
679
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
680
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
681
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction")),
682
+ domain: Schema.String,
683
+ enabled: Schema.Boolean,
684
+ zoneId: Schema.String,
685
+ ciphers: Schema.optional(Schema.Array(Schema.String)),
686
+ minTLS: Schema.optional(Schema.Literals(["1.0", "1.1", "1.2", "1.3"]))
687
+ })
688
+ .pipe(T.Http({ method: "POST", path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/custom" })) as unknown as Schema.Schema<CreateBucketDomainCustomRequest>;
1097
689
 
1098
690
  export interface CreateBucketDomainCustomResponse {
1099
691
  /** Domain name of the affected custom domain. */
@@ -1106,22 +698,12 @@ export interface CreateBucketDomainCustomResponse {
1106
698
  minTLS?: "1.0" | "1.1" | "1.2" | "1.3" | null;
1107
699
  }
1108
700
 
1109
- export const CreateBucketDomainCustomResponse =
1110
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1111
- domain: Schema.String,
1112
- enabled: Schema.Boolean,
1113
- ciphers: Schema.optional(
1114
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
1115
- ),
1116
- minTLS: Schema.optional(
1117
- Schema.Union([
1118
- Schema.Literals(["1.0", "1.1", "1.2", "1.3"]),
1119
- Schema.Null,
1120
- ]),
1121
- ),
1122
- }).pipe(
1123
- T.ResponsePath("result"),
1124
- ) as unknown as Schema.Schema<CreateBucketDomainCustomResponse>;
701
+ export const CreateBucketDomainCustomResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
702
+ domain: Schema.String,
703
+ enabled: Schema.Boolean,
704
+ ciphers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
705
+ minTLS: Schema.optional(Schema.Union([Schema.Literals(["1.0", "1.1", "1.2", "1.3"]), Schema.Null]))
706
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<CreateBucketDomainCustomResponse>;
1125
707
 
1126
708
  export type CreateBucketDomainCustomError =
1127
709
  | DefaultErrors
@@ -1154,23 +736,16 @@ export interface UpdateBucketDomainCustomRequest {
1154
736
  minTLS?: "1.0" | "1.1" | "1.2" | "1.3";
1155
737
  }
1156
738
 
1157
- export const UpdateBucketDomainCustomRequest =
1158
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1159
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1160
- domain: Schema.String.pipe(T.HttpPath("domain")),
1161
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
1162
- jurisdiction: Schema.optional(
1163
- Schema.Literals(["default", "eu", "fedramp"]),
1164
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1165
- ciphers: Schema.optional(Schema.Array(Schema.String)),
1166
- enabled: Schema.optional(Schema.Boolean),
1167
- minTLS: Schema.optional(Schema.Literals(["1.0", "1.1", "1.2", "1.3"])),
1168
- }).pipe(
1169
- T.Http({
1170
- method: "PUT",
1171
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/custom/{domain}",
1172
- }),
1173
- ) as unknown as Schema.Schema<UpdateBucketDomainCustomRequest>;
739
+ export const UpdateBucketDomainCustomRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
740
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
741
+ domain: Schema.String.pipe(T.HttpPath("domain")),
742
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
743
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction")),
744
+ ciphers: Schema.optional(Schema.Array(Schema.String)),
745
+ enabled: Schema.optional(Schema.Boolean),
746
+ minTLS: Schema.optional(Schema.Literals(["1.0", "1.1", "1.2", "1.3"]))
747
+ })
748
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/custom/{domain}" })) as unknown as Schema.Schema<UpdateBucketDomainCustomRequest>;
1174
749
 
1175
750
  export interface UpdateBucketDomainCustomResponse {
1176
751
  /** Domain name of the affected custom domain. */
@@ -1183,24 +758,15 @@ export interface UpdateBucketDomainCustomResponse {
1183
758
  minTLS?: "1.0" | "1.1" | "1.2" | "1.3" | null;
1184
759
  }
1185
760
 
1186
- export const UpdateBucketDomainCustomResponse =
1187
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1188
- domain: Schema.String,
1189
- ciphers: Schema.optional(
1190
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
1191
- ),
1192
- enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
1193
- minTLS: Schema.optional(
1194
- Schema.Union([
1195
- Schema.Literals(["1.0", "1.1", "1.2", "1.3"]),
1196
- Schema.Null,
1197
- ]),
1198
- ),
1199
- }).pipe(
1200
- T.ResponsePath("result"),
1201
- ) as unknown as Schema.Schema<UpdateBucketDomainCustomResponse>;
1202
-
1203
- export type UpdateBucketDomainCustomError = DefaultErrors;
761
+ export const UpdateBucketDomainCustomResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
762
+ domain: Schema.String,
763
+ ciphers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
764
+ enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
765
+ minTLS: Schema.optional(Schema.Union([Schema.Literals(["1.0", "1.1", "1.2", "1.3"]), Schema.Null]))
766
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<UpdateBucketDomainCustomResponse>;
767
+
768
+ export type UpdateBucketDomainCustomError =
769
+ | DefaultErrors;
1204
770
 
1205
771
  export const updateBucketDomainCustom: API.OperationMethod<
1206
772
  UpdateBucketDomainCustomRequest,
@@ -1222,34 +788,25 @@ export interface DeleteBucketDomainCustomRequest {
1222
788
  jurisdiction?: "default" | "eu" | "fedramp";
1223
789
  }
1224
790
 
1225
- export const DeleteBucketDomainCustomRequest =
1226
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1227
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1228
- domain: Schema.String.pipe(T.HttpPath("domain")),
1229
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
1230
- jurisdiction: Schema.optional(
1231
- Schema.Literals(["default", "eu", "fedramp"]),
1232
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1233
- }).pipe(
1234
- T.Http({
1235
- method: "DELETE",
1236
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/custom/{domain}",
1237
- }),
1238
- ) as unknown as Schema.Schema<DeleteBucketDomainCustomRequest>;
791
+ export const DeleteBucketDomainCustomRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
792
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
793
+ domain: Schema.String.pipe(T.HttpPath("domain")),
794
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
795
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
796
+ })
797
+ .pipe(T.Http({ method: "DELETE", path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/custom/{domain}" })) as unknown as Schema.Schema<DeleteBucketDomainCustomRequest>;
1239
798
 
1240
799
  export interface DeleteBucketDomainCustomResponse {
1241
800
  /** Name of the removed custom domain. */
1242
801
  domain: string;
1243
802
  }
1244
803
 
1245
- export const DeleteBucketDomainCustomResponse =
1246
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1247
- domain: Schema.String,
1248
- }).pipe(
1249
- T.ResponsePath("result"),
1250
- ) as unknown as Schema.Schema<DeleteBucketDomainCustomResponse>;
804
+ export const DeleteBucketDomainCustomResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
805
+ domain: Schema.String
806
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<DeleteBucketDomainCustomResponse>;
1251
807
 
1252
- export type DeleteBucketDomainCustomError = DefaultErrors;
808
+ export type DeleteBucketDomainCustomError =
809
+ | DefaultErrors;
1253
810
 
1254
811
  export const deleteBucketDomainCustom: API.OperationMethod<
1255
812
  DeleteBucketDomainCustomRequest,
@@ -1262,6 +819,7 @@ export const deleteBucketDomainCustom: API.OperationMethod<
1262
819
  errors: [],
1263
820
  }));
1264
821
 
822
+
1265
823
  // =============================================================================
1266
824
  // BucketDomainManaged
1267
825
  // =============================================================================
@@ -1274,19 +832,12 @@ export interface ListBucketDomainManagedsRequest {
1274
832
  jurisdiction?: "default" | "eu" | "fedramp";
1275
833
  }
1276
834
 
1277
- export const ListBucketDomainManagedsRequest =
1278
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1279
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1280
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
1281
- jurisdiction: Schema.optional(
1282
- Schema.Literals(["default", "eu", "fedramp"]),
1283
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1284
- }).pipe(
1285
- T.Http({
1286
- method: "GET",
1287
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/managed",
1288
- }),
1289
- ) as unknown as Schema.Schema<ListBucketDomainManagedsRequest>;
835
+ export const ListBucketDomainManagedsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
836
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
837
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
838
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
839
+ })
840
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/managed" })) as unknown as Schema.Schema<ListBucketDomainManagedsRequest>;
1290
841
 
1291
842
  export interface ListBucketDomainManagedsResponse {
1292
843
  /** Bucket ID. */
@@ -1297,14 +848,11 @@ export interface ListBucketDomainManagedsResponse {
1297
848
  enabled: boolean;
1298
849
  }
1299
850
 
1300
- export const ListBucketDomainManagedsResponse =
1301
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1302
- bucketId: Schema.String,
1303
- domain: Schema.String,
1304
- enabled: Schema.Boolean,
1305
- }).pipe(
1306
- T.ResponsePath("result"),
1307
- ) as unknown as Schema.Schema<ListBucketDomainManagedsResponse>;
851
+ export const ListBucketDomainManagedsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
852
+ bucketId: Schema.String,
853
+ domain: Schema.String,
854
+ enabled: Schema.Boolean
855
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<ListBucketDomainManagedsResponse>;
1308
856
 
1309
857
  export type ListBucketDomainManagedsError =
1310
858
  | DefaultErrors
@@ -1332,20 +880,13 @@ export interface PutBucketDomainManagedRequest {
1332
880
  enabled: boolean;
1333
881
  }
1334
882
 
1335
- export const PutBucketDomainManagedRequest =
1336
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1337
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1338
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
1339
- jurisdiction: Schema.optional(
1340
- Schema.Literals(["default", "eu", "fedramp"]),
1341
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1342
- enabled: Schema.Boolean,
1343
- }).pipe(
1344
- T.Http({
1345
- method: "PUT",
1346
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/managed",
1347
- }),
1348
- ) as unknown as Schema.Schema<PutBucketDomainManagedRequest>;
883
+ export const PutBucketDomainManagedRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
884
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
885
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
886
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction")),
887
+ enabled: Schema.Boolean
888
+ })
889
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/r2/buckets/{bucketName}/domains/managed" })) as unknown as Schema.Schema<PutBucketDomainManagedRequest>;
1349
890
 
1350
891
  export interface PutBucketDomainManagedResponse {
1351
892
  /** Bucket ID. */
@@ -1356,14 +897,11 @@ export interface PutBucketDomainManagedResponse {
1356
897
  enabled: boolean;
1357
898
  }
1358
899
 
1359
- export const PutBucketDomainManagedResponse =
1360
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1361
- bucketId: Schema.String,
1362
- domain: Schema.String,
1363
- enabled: Schema.Boolean,
1364
- }).pipe(
1365
- T.ResponsePath("result"),
1366
- ) as unknown as Schema.Schema<PutBucketDomainManagedResponse>;
900
+ export const PutBucketDomainManagedResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
901
+ bucketId: Schema.String,
902
+ domain: Schema.String,
903
+ enabled: Schema.Boolean
904
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<PutBucketDomainManagedResponse>;
1367
905
 
1368
906
  export type PutBucketDomainManagedError =
1369
907
  | DefaultErrors
@@ -1381,6 +919,7 @@ export const putBucketDomainManaged: API.OperationMethod<
1381
919
  errors: [NoSuchBucket, InvalidRoute],
1382
920
  }));
1383
921
 
922
+
1384
923
  // =============================================================================
1385
924
  // BucketEventNotification
1386
925
  // =============================================================================
@@ -1394,83 +933,40 @@ export interface GetBucketEventNotificationRequest {
1394
933
  jurisdiction?: "default" | "eu" | "fedramp";
1395
934
  }
1396
935
 
1397
- export const GetBucketEventNotificationRequest =
1398
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1399
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1400
- queueId: Schema.String.pipe(T.HttpPath("queueId")),
1401
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
1402
- jurisdiction: Schema.optional(
1403
- Schema.Literals(["default", "eu", "fedramp"]),
1404
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1405
- }).pipe(
1406
- T.Http({
1407
- method: "GET",
1408
- path: "/accounts/{account_id}/event_notifications/r2/{bucketName}/configuration/queues/{queueId}",
1409
- }),
1410
- ) as unknown as Schema.Schema<GetBucketEventNotificationRequest>;
936
+ export const GetBucketEventNotificationRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
937
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
938
+ queueId: Schema.String.pipe(T.HttpPath("queueId")),
939
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
940
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
941
+ })
942
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/event_notifications/r2/{bucketName}/configuration/queues/{queueId}" })) as unknown as Schema.Schema<GetBucketEventNotificationRequest>;
1411
943
 
1412
944
  export interface GetBucketEventNotificationResponse {
1413
945
  /** Queue ID. */
1414
946
  queueId?: string | null;
1415
947
  /** Name of the queue. */
1416
948
  queueName?: string | null;
1417
- rules?:
1418
- | {
1419
- actions: (
1420
- | "PutObject"
1421
- | "CopyObject"
1422
- | "DeleteObject"
1423
- | "CompleteMultipartUpload"
1424
- | "LifecycleDeletion"
1425
- )[];
1426
- createdAt?: string | null;
1427
- description?: string | null;
1428
- prefix?: string | null;
1429
- ruleId?: string | null;
1430
- suffix?: string | null;
1431
- }[]
1432
- | null;
1433
- }
1434
-
1435
- export const GetBucketEventNotificationResponse =
1436
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1437
- queueId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1438
- queueName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1439
- rules: Schema.optional(
1440
- Schema.Union([
1441
- Schema.Array(
1442
- Schema.Struct({
1443
- actions: Schema.Array(
1444
- Schema.Literals([
1445
- "PutObject",
1446
- "CopyObject",
1447
- "DeleteObject",
1448
- "CompleteMultipartUpload",
1449
- "LifecycleDeletion",
1450
- ]),
1451
- ),
1452
- createdAt: Schema.optional(
1453
- Schema.Union([Schema.String, Schema.Null]),
1454
- ),
1455
- description: Schema.optional(
1456
- Schema.Union([Schema.String, Schema.Null]),
1457
- ),
1458
- prefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1459
- ruleId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1460
- suffix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1461
- }),
1462
- ),
1463
- Schema.Null,
1464
- ]),
1465
- ),
1466
- }).pipe(
1467
- T.ResponsePath("result"),
1468
- ) as unknown as Schema.Schema<GetBucketEventNotificationResponse>;
949
+ rules?: ({ actions: ("PutObject" | "CopyObject" | "DeleteObject" | "CompleteMultipartUpload" | "LifecycleDeletion")[]; createdAt?: string | null; description?: string | null; prefix?: string | null; ruleId?: string | null; suffix?: string | null })[] | null;
950
+ }
951
+
952
+ export const GetBucketEventNotificationResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
953
+ queueId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
954
+ queueName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
955
+ rules: Schema.optional(Schema.Union([Schema.Array(Schema.Struct({
956
+ actions: Schema.Array(Schema.Literals(["PutObject", "CopyObject", "DeleteObject", "CompleteMultipartUpload", "LifecycleDeletion"])),
957
+ createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
958
+ description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
959
+ prefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
960
+ ruleId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
961
+ suffix: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
962
+ })), Schema.Null]))
963
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<GetBucketEventNotificationResponse>;
1469
964
 
1470
965
  export type GetBucketEventNotificationError =
1471
966
  | DefaultErrors
1472
967
  | BucketNotFound
1473
968
  | NoEventNotificationConfig
969
+ | EventNotificationConfigNotFound
1474
970
  | QueueNotFound
1475
971
  | InvalidRoute;
1476
972
 
@@ -1482,12 +978,7 @@ export const getBucketEventNotification: API.OperationMethod<
1482
978
  > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
1483
979
  input: GetBucketEventNotificationRequest,
1484
980
  output: GetBucketEventNotificationResponse,
1485
- errors: [
1486
- BucketNotFound,
1487
- NoEventNotificationConfig,
1488
- QueueNotFound,
1489
- InvalidRoute,
1490
- ],
981
+ errors: [BucketNotFound, NoEventNotificationConfig, EventNotificationConfigNotFound, QueueNotFound, InvalidRoute],
1491
982
  }));
1492
983
 
1493
984
  export interface ListBucketEventNotificationsRequest {
@@ -1498,102 +989,35 @@ export interface ListBucketEventNotificationsRequest {
1498
989
  jurisdiction?: "default" | "eu" | "fedramp";
1499
990
  }
1500
991
 
1501
- export const ListBucketEventNotificationsRequest =
1502
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1503
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1504
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
1505
- jurisdiction: Schema.optional(
1506
- Schema.Literals(["default", "eu", "fedramp"]),
1507
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1508
- }).pipe(
1509
- T.Http({
1510
- method: "GET",
1511
- path: "/accounts/{account_id}/event_notifications/r2/{bucketName}/configuration",
1512
- }),
1513
- ) as unknown as Schema.Schema<ListBucketEventNotificationsRequest>;
992
+ export const ListBucketEventNotificationsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
993
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
994
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
995
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
996
+ })
997
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/event_notifications/r2/{bucketName}/configuration" })) as unknown as Schema.Schema<ListBucketEventNotificationsRequest>;
1514
998
 
1515
999
  export interface ListBucketEventNotificationsResponse {
1516
1000
  /** Name of the bucket. */
1517
1001
  bucketName?: string | null;
1518
1002
  /** List of queues associated with the bucket. */
1519
- queues?:
1520
- | {
1521
- queueId?: string | null;
1522
- queueName?: string | null;
1523
- rules?:
1524
- | {
1525
- actions: (
1526
- | "PutObject"
1527
- | "CopyObject"
1528
- | "DeleteObject"
1529
- | "CompleteMultipartUpload"
1530
- | "LifecycleDeletion"
1531
- )[];
1532
- createdAt?: string | null;
1533
- description?: string | null;
1534
- prefix?: string | null;
1535
- ruleId?: string | null;
1536
- suffix?: string | null;
1537
- }[]
1538
- | null;
1539
- }[]
1540
- | null;
1541
- }
1542
-
1543
- export const ListBucketEventNotificationsResponse =
1544
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1545
- bucketName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1546
- queues: Schema.optional(
1547
- Schema.Union([
1548
- Schema.Array(
1549
- Schema.Struct({
1550
- queueId: Schema.optional(
1551
- Schema.Union([Schema.String, Schema.Null]),
1552
- ),
1553
- queueName: Schema.optional(
1554
- Schema.Union([Schema.String, Schema.Null]),
1555
- ),
1556
- rules: Schema.optional(
1557
- Schema.Union([
1558
- Schema.Array(
1559
- Schema.Struct({
1560
- actions: Schema.Array(
1561
- Schema.Literals([
1562
- "PutObject",
1563
- "CopyObject",
1564
- "DeleteObject",
1565
- "CompleteMultipartUpload",
1566
- "LifecycleDeletion",
1567
- ]),
1568
- ),
1569
- createdAt: Schema.optional(
1570
- Schema.Union([Schema.String, Schema.Null]),
1571
- ),
1572
- description: Schema.optional(
1573
- Schema.Union([Schema.String, Schema.Null]),
1574
- ),
1575
- prefix: Schema.optional(
1576
- Schema.Union([Schema.String, Schema.Null]),
1577
- ),
1578
- ruleId: Schema.optional(
1579
- Schema.Union([Schema.String, Schema.Null]),
1580
- ),
1581
- suffix: Schema.optional(
1582
- Schema.Union([Schema.String, Schema.Null]),
1583
- ),
1584
- }),
1585
- ),
1586
- Schema.Null,
1587
- ]),
1588
- ),
1589
- }),
1590
- ),
1591
- Schema.Null,
1592
- ]),
1593
- ),
1594
- }).pipe(
1595
- T.ResponsePath("result"),
1596
- ) as unknown as Schema.Schema<ListBucketEventNotificationsResponse>;
1003
+ queues?: ({ queueId?: string | null; queueName?: string | null; rules?: ({ actions: ("PutObject" | "CopyObject" | "DeleteObject" | "CompleteMultipartUpload" | "LifecycleDeletion")[]; createdAt?: string | null; description?: string | null; prefix?: string | null; ruleId?: string | null; suffix?: string | null })[] | null })[] | null;
1004
+ }
1005
+
1006
+ export const ListBucketEventNotificationsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1007
+ bucketName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1008
+ queues: Schema.optional(Schema.Union([Schema.Array(Schema.Struct({
1009
+ queueId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1010
+ queueName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1011
+ rules: Schema.optional(Schema.Union([Schema.Array(Schema.Struct({
1012
+ actions: Schema.Array(Schema.Literals(["PutObject", "CopyObject", "DeleteObject", "CompleteMultipartUpload", "LifecycleDeletion"])),
1013
+ createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1014
+ description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1015
+ prefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1016
+ ruleId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1017
+ suffix: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
1018
+ })), Schema.Null]))
1019
+ })), Schema.Null]))
1020
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<ListBucketEventNotificationsResponse>;
1597
1021
 
1598
1022
  export type ListBucketEventNotificationsError =
1599
1023
  | DefaultErrors
@@ -1610,12 +1034,7 @@ export const listBucketEventNotifications: API.OperationMethod<
1610
1034
  > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
1611
1035
  input: ListBucketEventNotificationsRequest,
1612
1036
  output: ListBucketEventNotificationsResponse,
1613
- errors: [
1614
- NoSuchBucket,
1615
- InvalidRoute,
1616
- NoEventNotificationConfig,
1617
- BucketNotFound,
1618
- ],
1037
+ errors: [NoSuchBucket, InvalidRoute, NoEventNotificationConfig, BucketNotFound],
1619
1038
  }));
1620
1039
 
1621
1040
  export interface PutBucketEventNotificationRequest {
@@ -1626,62 +1045,32 @@ export interface PutBucketEventNotificationRequest {
1626
1045
  /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
1627
1046
  jurisdiction?: "default" | "eu" | "fedramp";
1628
1047
  /** Body param: Array of rules to drive notifications. */
1629
- rules: {
1630
- actions: (
1631
- | "PutObject"
1632
- | "CopyObject"
1633
- | "DeleteObject"
1634
- | "CompleteMultipartUpload"
1635
- | "LifecycleDeletion"
1636
- )[];
1637
- description?: string;
1638
- prefix?: string;
1639
- suffix?: string;
1640
- }[];
1641
- }
1642
-
1643
- export const PutBucketEventNotificationRequest =
1644
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1645
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1646
- queueId: Schema.String.pipe(T.HttpPath("queueId")),
1647
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
1648
- jurisdiction: Schema.optional(
1649
- Schema.Literals(["default", "eu", "fedramp"]),
1650
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1651
- rules: Schema.Array(
1652
- Schema.Struct({
1653
- actions: Schema.Array(
1654
- Schema.Literals([
1655
- "PutObject",
1656
- "CopyObject",
1657
- "DeleteObject",
1658
- "CompleteMultipartUpload",
1659
- "LifecycleDeletion",
1660
- ]),
1661
- ),
1662
- description: Schema.optional(Schema.String),
1663
- prefix: Schema.optional(Schema.String),
1664
- suffix: Schema.optional(Schema.String),
1665
- }),
1666
- ),
1667
- }).pipe(
1668
- T.Http({
1669
- method: "PUT",
1670
- path: "/accounts/{account_id}/event_notifications/r2/{bucketName}/configuration/queues/{queueId}",
1671
- }),
1672
- ) as unknown as Schema.Schema<PutBucketEventNotificationRequest>;
1048
+ rules: ({ actions: ("PutObject" | "CopyObject" | "DeleteObject" | "CompleteMultipartUpload" | "LifecycleDeletion")[]; description?: string; prefix?: string; suffix?: string })[];
1049
+ }
1050
+
1051
+ export const PutBucketEventNotificationRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1052
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1053
+ queueId: Schema.String.pipe(T.HttpPath("queueId")),
1054
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
1055
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1056
+ rules: Schema.Array(Schema.Struct({
1057
+ actions: Schema.Array(Schema.Literals(["PutObject", "CopyObject", "DeleteObject", "CompleteMultipartUpload", "LifecycleDeletion"])),
1058
+ description: Schema.optional(Schema.String),
1059
+ prefix: Schema.optional(Schema.String),
1060
+ suffix: Schema.optional(Schema.String)
1061
+ }))
1062
+ })
1063
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/event_notifications/r2/{bucketName}/configuration/queues/{queueId}" })) as unknown as Schema.Schema<PutBucketEventNotificationRequest>;
1673
1064
 
1674
1065
  export type PutBucketEventNotificationResponse = unknown;
1675
1066
 
1676
- export const PutBucketEventNotificationResponse =
1677
- /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
1678
- T.ResponsePath("result"),
1679
- ) as unknown as Schema.Schema<PutBucketEventNotificationResponse>;
1067
+ export const PutBucketEventNotificationResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<PutBucketEventNotificationResponse>;
1680
1068
 
1681
1069
  export type PutBucketEventNotificationError =
1682
1070
  | DefaultErrors
1683
1071
  | BucketNotFound
1684
1072
  | InvalidEventNotificationConfig
1073
+ | EventNotificationRuleConflict
1685
1074
  | QueueNotFound
1686
1075
  | InvalidRoute;
1687
1076
 
@@ -1693,12 +1082,7 @@ export const putBucketEventNotification: API.OperationMethod<
1693
1082
  > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
1694
1083
  input: PutBucketEventNotificationRequest,
1695
1084
  output: PutBucketEventNotificationResponse,
1696
- errors: [
1697
- BucketNotFound,
1698
- InvalidEventNotificationConfig,
1699
- QueueNotFound,
1700
- InvalidRoute,
1701
- ],
1085
+ errors: [BucketNotFound, InvalidEventNotificationConfig, EventNotificationRuleConflict, QueueNotFound, InvalidRoute],
1702
1086
  }));
1703
1087
 
1704
1088
  export interface DeleteBucketEventNotificationRequest {
@@ -1710,31 +1094,22 @@ export interface DeleteBucketEventNotificationRequest {
1710
1094
  jurisdiction?: "default" | "eu" | "fedramp";
1711
1095
  }
1712
1096
 
1713
- export const DeleteBucketEventNotificationRequest =
1714
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1715
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1716
- queueId: Schema.String.pipe(T.HttpPath("queueId")),
1717
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
1718
- jurisdiction: Schema.optional(
1719
- Schema.Literals(["default", "eu", "fedramp"]),
1720
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1721
- }).pipe(
1722
- T.Http({
1723
- method: "DELETE",
1724
- path: "/accounts/{account_id}/event_notifications/r2/{bucketName}/configuration/queues/{queueId}",
1725
- }),
1726
- ) as unknown as Schema.Schema<DeleteBucketEventNotificationRequest>;
1097
+ export const DeleteBucketEventNotificationRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1098
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1099
+ queueId: Schema.String.pipe(T.HttpPath("queueId")),
1100
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
1101
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
1102
+ })
1103
+ .pipe(T.Http({ method: "DELETE", path: "/accounts/{account_id}/event_notifications/r2/{bucketName}/configuration/queues/{queueId}" })) as unknown as Schema.Schema<DeleteBucketEventNotificationRequest>;
1727
1104
 
1728
1105
  export type DeleteBucketEventNotificationResponse = unknown;
1729
1106
 
1730
- export const DeleteBucketEventNotificationResponse =
1731
- /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
1732
- T.ResponsePath("result"),
1733
- ) as unknown as Schema.Schema<DeleteBucketEventNotificationResponse>;
1107
+ export const DeleteBucketEventNotificationResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<DeleteBucketEventNotificationResponse>;
1734
1108
 
1735
1109
  export type DeleteBucketEventNotificationError =
1736
1110
  | DefaultErrors
1737
1111
  | BucketNotFound
1112
+ | EventNotificationConfigNotFound
1738
1113
  | QueueNotFound
1739
1114
  | InvalidRoute;
1740
1115
 
@@ -1746,9 +1121,10 @@ export const deleteBucketEventNotification: API.OperationMethod<
1746
1121
  > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
1747
1122
  input: DeleteBucketEventNotificationRequest,
1748
1123
  output: DeleteBucketEventNotificationResponse,
1749
- errors: [BucketNotFound, QueueNotFound, InvalidRoute],
1124
+ errors: [BucketNotFound, EventNotificationConfigNotFound, QueueNotFound, InvalidRoute],
1750
1125
  }));
1751
1126
 
1127
+
1752
1128
  // =============================================================================
1753
1129
  // BucketLifecycle
1754
1130
  // =============================================================================
@@ -1761,126 +1137,51 @@ export interface GetBucketLifecycleRequest {
1761
1137
  jurisdiction?: "default" | "eu" | "fedramp";
1762
1138
  }
1763
1139
 
1764
- export const GetBucketLifecycleRequest =
1765
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1766
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1767
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
1768
- jurisdiction: Schema.optional(
1769
- Schema.Literals(["default", "eu", "fedramp"]),
1770
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1771
- }).pipe(
1772
- T.Http({
1773
- method: "GET",
1774
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/lifecycle",
1775
- }),
1776
- ) as unknown as Schema.Schema<GetBucketLifecycleRequest>;
1140
+ export const GetBucketLifecycleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1141
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1142
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
1143
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
1144
+ })
1145
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/r2/buckets/{bucketName}/lifecycle" })) as unknown as Schema.Schema<GetBucketLifecycleRequest>;
1777
1146
 
1778
1147
  export interface GetBucketLifecycleResponse {
1779
- rules?:
1780
- | {
1781
- id: string;
1782
- conditions: { prefix?: string | null };
1783
- enabled: boolean;
1784
- abortMultipartUploadsTransition?: {
1785
- condition?: { maxAge: number; type: "Age" } | null;
1786
- } | null;
1787
- deleteObjectsTransition?: {
1788
- condition?:
1789
- | { maxAge: number; type: "Age" }
1790
- | { date: string; type: "Date" }
1791
- | null;
1792
- } | null;
1793
- storageClassTransitions?:
1794
- | {
1795
- condition:
1796
- | { maxAge: number; type: "Age" }
1797
- | { date: string; type: "Date" };
1798
- storageClass: "InfrequentAccess";
1799
- }[]
1800
- | null;
1801
- }[]
1802
- | null;
1803
- }
1804
-
1805
- export const GetBucketLifecycleResponse =
1806
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1807
- rules: Schema.optional(
1808
- Schema.Union([
1809
- Schema.Array(
1810
- Schema.Struct({
1811
- id: Schema.String,
1812
- conditions: Schema.Struct({
1813
- prefix: Schema.optional(
1814
- Schema.Union([Schema.String, Schema.Null]),
1815
- ),
1816
- }),
1817
- enabled: Schema.Boolean,
1818
- abortMultipartUploadsTransition: Schema.optional(
1819
- Schema.Union([
1820
- Schema.Struct({
1821
- condition: Schema.optional(
1822
- Schema.Union([
1823
- Schema.Struct({
1824
- maxAge: Schema.Number,
1825
- type: Schema.Literal("Age"),
1826
- }),
1827
- Schema.Null,
1828
- ]),
1829
- ),
1830
- }),
1831
- Schema.Null,
1832
- ]),
1833
- ),
1834
- deleteObjectsTransition: Schema.optional(
1835
- Schema.Union([
1836
- Schema.Struct({
1837
- condition: Schema.optional(
1838
- Schema.Union([
1839
- Schema.Union([
1840
- Schema.Struct({
1841
- maxAge: Schema.Number,
1842
- type: Schema.Literal("Age"),
1843
- }),
1844
- Schema.Struct({
1845
- date: Schema.String,
1846
- type: Schema.Literal("Date"),
1847
- }),
1848
- ]),
1849
- Schema.Null,
1850
- ]),
1851
- ),
1852
- }),
1853
- Schema.Null,
1854
- ]),
1855
- ),
1856
- storageClassTransitions: Schema.optional(
1857
- Schema.Union([
1858
- Schema.Array(
1859
- Schema.Struct({
1860
- condition: Schema.Union([
1861
- Schema.Struct({
1862
- maxAge: Schema.Number,
1863
- type: Schema.Literal("Age"),
1864
- }),
1865
- Schema.Struct({
1866
- date: Schema.String,
1867
- type: Schema.Literal("Date"),
1868
- }),
1869
- ]),
1870
- storageClass: Schema.Literal("InfrequentAccess"),
1871
- }),
1872
- ),
1873
- Schema.Null,
1874
- ]),
1875
- ),
1876
- }),
1877
- ),
1878
- Schema.Null,
1879
- ]),
1880
- ),
1881
- }).pipe(
1882
- T.ResponsePath("result"),
1883
- ) as unknown as Schema.Schema<GetBucketLifecycleResponse>;
1148
+ rules?: ({ id: string; conditions: { prefix?: string | null }; enabled: boolean; abortMultipartUploadsTransition?: { condition?: { maxAge: number; type: "Age" } | null } | null; deleteObjectsTransition?: { condition?: { maxAge: number; type: "Age" } | { date: string; type: "Date" } | null } | null; storageClassTransitions?: ({ condition: { maxAge: number; type: "Age" } | { date: string; type: "Date" }; storageClass: "InfrequentAccess" })[] | null })[] | null;
1149
+ }
1150
+
1151
+ export const GetBucketLifecycleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1152
+ rules: Schema.optional(Schema.Union([Schema.Array(Schema.Struct({
1153
+ id: Schema.String,
1154
+ conditions: Schema.Struct({
1155
+ prefix: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
1156
+ }),
1157
+ enabled: Schema.Boolean,
1158
+ abortMultipartUploadsTransition: Schema.optional(Schema.Union([Schema.Struct({
1159
+ condition: Schema.optional(Schema.Union([Schema.Struct({
1160
+ maxAge: Schema.Number,
1161
+ type: Schema.Literal("Age")
1162
+ }), Schema.Null]))
1163
+ }), Schema.Null])),
1164
+ deleteObjectsTransition: Schema.optional(Schema.Union([Schema.Struct({
1165
+ condition: Schema.optional(Schema.Union([Schema.Union([Schema.Struct({
1166
+ maxAge: Schema.Number,
1167
+ type: Schema.Literal("Age")
1168
+ }), Schema.Struct({
1169
+ date: Schema.String,
1170
+ type: Schema.Literal("Date")
1171
+ })]), Schema.Null]))
1172
+ }), Schema.Null])),
1173
+ storageClassTransitions: Schema.optional(Schema.Union([Schema.Array(Schema.Struct({
1174
+ condition: Schema.Union([Schema.Struct({
1175
+ maxAge: Schema.Number,
1176
+ type: Schema.Literal("Age")
1177
+ }), Schema.Struct({
1178
+ date: Schema.String,
1179
+ type: Schema.Literal("Date")
1180
+ })]),
1181
+ storageClass: Schema.Literal("InfrequentAccess")
1182
+ })), Schema.Null]))
1183
+ })), Schema.Null]))
1184
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<GetBucketLifecycleResponse>;
1884
1185
 
1885
1186
  export type GetBucketLifecycleError =
1886
1187
  | DefaultErrors
@@ -1905,101 +1206,51 @@ export interface PutBucketLifecycleRequest {
1905
1206
  /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
1906
1207
  jurisdiction?: "default" | "eu" | "fedramp";
1907
1208
  /** Body param: */
1908
- rules?: {
1909
- id: string;
1910
- conditions: { prefix: string };
1911
- enabled: boolean;
1912
- abortMultipartUploadsTransition?: {
1913
- condition?: { maxAge: number; type: "Age" };
1914
- };
1915
- deleteObjectsTransition?: {
1916
- condition?:
1917
- | { maxAge: number; type: "Age" }
1918
- | { date: string; type: "Date" };
1919
- };
1920
- storageClassTransitions?: {
1921
- condition:
1922
- | { maxAge: number; type: "Age" }
1923
- | { date: string; type: "Date" };
1924
- storageClass: "InfrequentAccess";
1925
- }[];
1926
- }[];
1927
- }
1928
-
1929
- export const PutBucketLifecycleRequest =
1930
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1931
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1932
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
1933
- jurisdiction: Schema.optional(
1934
- Schema.Literals(["default", "eu", "fedramp"]),
1935
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1936
- rules: Schema.optional(
1937
- Schema.Array(
1938
- Schema.Struct({
1939
- id: Schema.String,
1940
- conditions: Schema.Struct({
1941
- prefix: Schema.String,
1942
- }),
1943
- enabled: Schema.Boolean,
1944
- abortMultipartUploadsTransition: Schema.optional(
1945
- Schema.Struct({
1946
- condition: Schema.optional(
1947
- Schema.Struct({
1948
- maxAge: Schema.Number,
1949
- type: Schema.Literal("Age"),
1950
- }),
1951
- ),
1952
- }),
1953
- ),
1954
- deleteObjectsTransition: Schema.optional(
1955
- Schema.Struct({
1956
- condition: Schema.optional(
1957
- Schema.Union([
1958
- Schema.Struct({
1959
- maxAge: Schema.Number,
1960
- type: Schema.Literal("Age"),
1961
- }),
1962
- Schema.Struct({
1963
- date: Schema.String,
1964
- type: Schema.Literal("Date"),
1965
- }),
1966
- ]),
1967
- ),
1968
- }),
1969
- ),
1970
- storageClassTransitions: Schema.optional(
1971
- Schema.Array(
1972
- Schema.Struct({
1973
- condition: Schema.Union([
1974
- Schema.Struct({
1975
- maxAge: Schema.Number,
1976
- type: Schema.Literal("Age"),
1977
- }),
1978
- Schema.Struct({
1979
- date: Schema.String,
1980
- type: Schema.Literal("Date"),
1981
- }),
1982
- ]),
1983
- storageClass: Schema.Literal("InfrequentAccess"),
1984
- }),
1985
- ),
1986
- ),
1987
- }),
1988
- ),
1989
- ),
1990
- }).pipe(
1991
- T.Http({
1992
- method: "PUT",
1993
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/lifecycle",
1994
- }),
1995
- ) as unknown as Schema.Schema<PutBucketLifecycleRequest>;
1209
+ rules?: ({ id: string; conditions: { prefix: string }; enabled: boolean; abortMultipartUploadsTransition?: { condition?: { maxAge: number; type: "Age" } }; deleteObjectsTransition?: { condition?: { maxAge: number; type: "Age" } | { date: string; type: "Date" } }; storageClassTransitions?: ({ condition: { maxAge: number; type: "Age" } | { date: string; type: "Date" }; storageClass: "InfrequentAccess" })[] })[];
1210
+ }
1211
+
1212
+ export const PutBucketLifecycleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1213
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1214
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
1215
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1216
+ rules: Schema.optional(Schema.Array(Schema.Struct({
1217
+ id: Schema.String,
1218
+ conditions: Schema.Struct({
1219
+ prefix: Schema.String
1220
+ }),
1221
+ enabled: Schema.Boolean,
1222
+ abortMultipartUploadsTransition: Schema.optional(Schema.Struct({
1223
+ condition: Schema.optional(Schema.Struct({
1224
+ maxAge: Schema.Number,
1225
+ type: Schema.Literal("Age")
1226
+ }))
1227
+ })),
1228
+ deleteObjectsTransition: Schema.optional(Schema.Struct({
1229
+ condition: Schema.optional(Schema.Union([Schema.Struct({
1230
+ maxAge: Schema.Number,
1231
+ type: Schema.Literal("Age")
1232
+ }), Schema.Struct({
1233
+ date: Schema.String,
1234
+ type: Schema.Literal("Date")
1235
+ })]))
1236
+ })),
1237
+ storageClassTransitions: Schema.optional(Schema.Array(Schema.Struct({
1238
+ condition: Schema.Union([Schema.Struct({
1239
+ maxAge: Schema.Number,
1240
+ type: Schema.Literal("Age")
1241
+ }), Schema.Struct({
1242
+ date: Schema.String,
1243
+ type: Schema.Literal("Date")
1244
+ })]),
1245
+ storageClass: Schema.Literal("InfrequentAccess")
1246
+ })))
1247
+ })))
1248
+ })
1249
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/r2/buckets/{bucketName}/lifecycle" })) as unknown as Schema.Schema<PutBucketLifecycleRequest>;
1996
1250
 
1997
1251
  export type PutBucketLifecycleResponse = unknown;
1998
1252
 
1999
- export const PutBucketLifecycleResponse =
2000
- /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
2001
- T.ResponsePath("result"),
2002
- ) as unknown as Schema.Schema<PutBucketLifecycleResponse>;
1253
+ export const PutBucketLifecycleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<PutBucketLifecycleResponse>;
2003
1254
 
2004
1255
  export type PutBucketLifecycleError =
2005
1256
  | DefaultErrors
@@ -2017,6 +1268,7 @@ export const putBucketLifecycle: API.OperationMethod<
2017
1268
  errors: [NoSuchBucket, InvalidRoute],
2018
1269
  }));
2019
1270
 
1271
+
2020
1272
  // =============================================================================
2021
1273
  // BucketLock
2022
1274
  // =============================================================================
@@ -2032,61 +1284,35 @@ export interface GetBucketLockRequest {
2032
1284
  export const GetBucketLockRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2033
1285
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
2034
1286
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
2035
- jurisdiction: Schema.optional(
2036
- Schema.Literals(["default", "eu", "fedramp"]),
2037
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
2038
- }).pipe(
2039
- T.Http({
2040
- method: "GET",
2041
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/lock",
2042
- }),
2043
- ) as unknown as Schema.Schema<GetBucketLockRequest>;
1287
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
1288
+ })
1289
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/r2/buckets/{bucketName}/lock" })) as unknown as Schema.Schema<GetBucketLockRequest>;
2044
1290
 
2045
1291
  export interface GetBucketLockResponse {
2046
- rules?:
2047
- | {
2048
- id: string;
2049
- condition:
2050
- | { maxAgeSeconds: number; type: "Age" }
2051
- | { date: string; type: "Date" }
2052
- | { type: "Indefinite" };
2053
- enabled: boolean;
2054
- prefix?: string | null;
2055
- }[]
2056
- | null;
1292
+ rules?: ({ id: string; condition: { maxAgeSeconds: number; type: "Age" } | { date: string; type: "Date" } | { type: "Indefinite" }; enabled: boolean; prefix?: string | null })[] | null;
2057
1293
  }
2058
1294
 
2059
1295
  export const GetBucketLockResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2060
- rules: Schema.optional(
2061
- Schema.Union([
2062
- Schema.Array(
2063
- Schema.Struct({
2064
- id: Schema.String,
2065
- condition: Schema.Union([
2066
- Schema.Struct({
2067
- maxAgeSeconds: Schema.Number,
2068
- type: Schema.Literal("Age"),
2069
- }),
2070
- Schema.Struct({
2071
- date: Schema.String,
2072
- type: Schema.Literal("Date"),
2073
- }),
2074
- Schema.Struct({
2075
- type: Schema.Literal("Indefinite"),
2076
- }),
2077
- ]),
2078
- enabled: Schema.Boolean,
2079
- prefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2080
- }),
2081
- ),
2082
- Schema.Null,
2083
- ]),
2084
- ),
2085
- }).pipe(
2086
- T.ResponsePath("result"),
2087
- ) as unknown as Schema.Schema<GetBucketLockResponse>;
2088
-
2089
- export type GetBucketLockError = DefaultErrors | NoSuchBucket | InvalidRoute;
1296
+ rules: Schema.optional(Schema.Union([Schema.Array(Schema.Struct({
1297
+ id: Schema.String,
1298
+ condition: Schema.Union([Schema.Struct({
1299
+ maxAgeSeconds: Schema.Number,
1300
+ type: Schema.Literal("Age")
1301
+ }), Schema.Struct({
1302
+ date: Schema.String,
1303
+ type: Schema.Literal("Date")
1304
+ }), Schema.Struct({
1305
+ type: Schema.Literal("Indefinite")
1306
+ })]),
1307
+ enabled: Schema.Boolean,
1308
+ prefix: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
1309
+ })), Schema.Null]))
1310
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<GetBucketLockResponse>;
1311
+
1312
+ export type GetBucketLockError =
1313
+ | DefaultErrors
1314
+ | NoSuchBucket
1315
+ | InvalidRoute;
2090
1316
 
2091
1317
  export const getBucketLock: API.OperationMethod<
2092
1318
  GetBucketLockRequest,
@@ -2106,60 +1332,38 @@ export interface PutBucketLockRequest {
2106
1332
  /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
2107
1333
  jurisdiction?: "default" | "eu" | "fedramp";
2108
1334
  /** Body param: */
2109
- rules?: {
2110
- id: string;
2111
- condition:
2112
- | { maxAgeSeconds: number; type: "Age" }
2113
- | { date: string; type: "Date" }
2114
- | { type: "Indefinite" };
2115
- enabled: boolean;
2116
- prefix?: string;
2117
- }[];
1335
+ rules?: ({ id: string; condition: { maxAgeSeconds: number; type: "Age" } | { date: string; type: "Date" } | { type: "Indefinite" }; enabled: boolean; prefix?: string })[];
2118
1336
  }
2119
1337
 
2120
1338
  export const PutBucketLockRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2121
1339
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
2122
1340
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
2123
- jurisdiction: Schema.optional(
2124
- Schema.Literals(["default", "eu", "fedramp"]),
2125
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
2126
- rules: Schema.optional(
2127
- Schema.Array(
2128
- Schema.Struct({
2129
- id: Schema.String,
2130
- condition: Schema.Union([
2131
- Schema.Struct({
2132
- maxAgeSeconds: Schema.Number,
2133
- type: Schema.Literal("Age"),
2134
- }),
2135
- Schema.Struct({
2136
- date: Schema.String,
2137
- type: Schema.Literal("Date"),
2138
- }),
2139
- Schema.Struct({
2140
- type: Schema.Literal("Indefinite"),
2141
- }),
2142
- ]),
2143
- enabled: Schema.Boolean,
2144
- prefix: Schema.optional(Schema.String),
2145
- }),
2146
- ),
2147
- ),
2148
- }).pipe(
2149
- T.Http({
2150
- method: "PUT",
2151
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/lock",
2152
- }),
2153
- ) as unknown as Schema.Schema<PutBucketLockRequest>;
1341
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1342
+ rules: Schema.optional(Schema.Array(Schema.Struct({
1343
+ id: Schema.String,
1344
+ condition: Schema.Union([Schema.Struct({
1345
+ maxAgeSeconds: Schema.Number,
1346
+ type: Schema.Literal("Age")
1347
+ }), Schema.Struct({
1348
+ date: Schema.String,
1349
+ type: Schema.Literal("Date")
1350
+ }), Schema.Struct({
1351
+ type: Schema.Literal("Indefinite")
1352
+ })]),
1353
+ enabled: Schema.Boolean,
1354
+ prefix: Schema.optional(Schema.String)
1355
+ })))
1356
+ })
1357
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/r2/buckets/{bucketName}/lock" })) as unknown as Schema.Schema<PutBucketLockRequest>;
2154
1358
 
2155
1359
  export type PutBucketLockResponse = unknown;
2156
1360
 
2157
- export const PutBucketLockResponse =
2158
- /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
2159
- T.ResponsePath("result"),
2160
- ) as unknown as Schema.Schema<PutBucketLockResponse>;
1361
+ export const PutBucketLockResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<PutBucketLockResponse>;
2161
1362
 
2162
- export type PutBucketLockError = DefaultErrors | NoSuchBucket | InvalidRoute;
1363
+ export type PutBucketLockError =
1364
+ | DefaultErrors
1365
+ | NoSuchBucket
1366
+ | InvalidRoute;
2163
1367
 
2164
1368
  export const putBucketLock: API.OperationMethod<
2165
1369
  PutBucketLockRequest,
@@ -2172,6 +1376,7 @@ export const putBucketLock: API.OperationMethod<
2172
1376
  errors: [NoSuchBucket, InvalidRoute],
2173
1377
  }));
2174
1378
 
1379
+
2175
1380
  // =============================================================================
2176
1381
  // BucketMetric
2177
1382
  // =============================================================================
@@ -2181,127 +1386,48 @@ export interface ListBucketMetricsRequest {
2181
1386
  accountId: string;
2182
1387
  }
2183
1388
 
2184
- export const ListBucketMetricsRequest =
2185
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2186
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
2187
- }).pipe(
2188
- T.Http({ method: "GET", path: "/accounts/{account_id}/r2/metrics" }),
2189
- ) as unknown as Schema.Schema<ListBucketMetricsRequest>;
1389
+ export const ListBucketMetricsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1390
+ accountId: Schema.String.pipe(T.HttpPath("account_id"))
1391
+ })
1392
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/r2/metrics" })) as unknown as Schema.Schema<ListBucketMetricsRequest>;
2190
1393
 
2191
1394
  export interface ListBucketMetricsResponse {
2192
1395
  /** Metrics based on what state they are in(uploaded or published). */
2193
- infrequentAccess?: {
2194
- published?: {
2195
- metadataSize?: number | null;
2196
- objects?: number | null;
2197
- payloadSize?: number | null;
2198
- } | null;
2199
- uploaded?: {
2200
- metadataSize?: number | null;
2201
- objects?: number | null;
2202
- payloadSize?: number | null;
2203
- } | null;
2204
- } | null;
1396
+ infrequentAccess?: { published?: { metadataSize?: number | null; objects?: number | null; payloadSize?: number | null } | null; uploaded?: { metadataSize?: number | null; objects?: number | null; payloadSize?: number | null } | null } | null;
2205
1397
  /** Metrics based on what state they are in(uploaded or published). */
2206
- standard?: {
2207
- published?: {
2208
- metadataSize?: number | null;
2209
- objects?: number | null;
2210
- payloadSize?: number | null;
2211
- } | null;
2212
- uploaded?: {
2213
- metadataSize?: number | null;
2214
- objects?: number | null;
2215
- payloadSize?: number | null;
2216
- } | null;
2217
- } | null;
2218
- }
2219
-
2220
- export const ListBucketMetricsResponse =
2221
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2222
- infrequentAccess: Schema.optional(
2223
- Schema.Union([
2224
- Schema.Struct({
2225
- published: Schema.optional(
2226
- Schema.Union([
2227
- Schema.Struct({
2228
- metadataSize: Schema.optional(
2229
- Schema.Union([Schema.Number, Schema.Null]),
2230
- ),
2231
- objects: Schema.optional(
2232
- Schema.Union([Schema.Number, Schema.Null]),
2233
- ),
2234
- payloadSize: Schema.optional(
2235
- Schema.Union([Schema.Number, Schema.Null]),
2236
- ),
2237
- }),
2238
- Schema.Null,
2239
- ]),
2240
- ),
2241
- uploaded: Schema.optional(
2242
- Schema.Union([
2243
- Schema.Struct({
2244
- metadataSize: Schema.optional(
2245
- Schema.Union([Schema.Number, Schema.Null]),
2246
- ),
2247
- objects: Schema.optional(
2248
- Schema.Union([Schema.Number, Schema.Null]),
2249
- ),
2250
- payloadSize: Schema.optional(
2251
- Schema.Union([Schema.Number, Schema.Null]),
2252
- ),
2253
- }),
2254
- Schema.Null,
2255
- ]),
2256
- ),
2257
- }),
2258
- Schema.Null,
2259
- ]),
2260
- ),
2261
- standard: Schema.optional(
2262
- Schema.Union([
2263
- Schema.Struct({
2264
- published: Schema.optional(
2265
- Schema.Union([
2266
- Schema.Struct({
2267
- metadataSize: Schema.optional(
2268
- Schema.Union([Schema.Number, Schema.Null]),
2269
- ),
2270
- objects: Schema.optional(
2271
- Schema.Union([Schema.Number, Schema.Null]),
2272
- ),
2273
- payloadSize: Schema.optional(
2274
- Schema.Union([Schema.Number, Schema.Null]),
2275
- ),
2276
- }),
2277
- Schema.Null,
2278
- ]),
2279
- ),
2280
- uploaded: Schema.optional(
2281
- Schema.Union([
2282
- Schema.Struct({
2283
- metadataSize: Schema.optional(
2284
- Schema.Union([Schema.Number, Schema.Null]),
2285
- ),
2286
- objects: Schema.optional(
2287
- Schema.Union([Schema.Number, Schema.Null]),
2288
- ),
2289
- payloadSize: Schema.optional(
2290
- Schema.Union([Schema.Number, Schema.Null]),
2291
- ),
2292
- }),
2293
- Schema.Null,
2294
- ]),
2295
- ),
2296
- }),
2297
- Schema.Null,
2298
- ]),
2299
- ),
2300
- }).pipe(
2301
- T.ResponsePath("result"),
2302
- ) as unknown as Schema.Schema<ListBucketMetricsResponse>;
2303
-
2304
- export type ListBucketMetricsError = DefaultErrors | InvalidRoute;
1398
+ standard?: { published?: { metadataSize?: number | null; objects?: number | null; payloadSize?: number | null } | null; uploaded?: { metadataSize?: number | null; objects?: number | null; payloadSize?: number | null } | null } | null;
1399
+ }
1400
+
1401
+ export const ListBucketMetricsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1402
+ infrequentAccess: Schema.optional(Schema.Union([Schema.Struct({
1403
+ published: Schema.optional(Schema.Union([Schema.Struct({
1404
+ metadataSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
1405
+ objects: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
1406
+ payloadSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null]))
1407
+ }), Schema.Null])),
1408
+ uploaded: Schema.optional(Schema.Union([Schema.Struct({
1409
+ metadataSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
1410
+ objects: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
1411
+ payloadSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null]))
1412
+ }), Schema.Null]))
1413
+ }), Schema.Null])),
1414
+ standard: Schema.optional(Schema.Union([Schema.Struct({
1415
+ published: Schema.optional(Schema.Union([Schema.Struct({
1416
+ metadataSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
1417
+ objects: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
1418
+ payloadSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null]))
1419
+ }), Schema.Null])),
1420
+ uploaded: Schema.optional(Schema.Union([Schema.Struct({
1421
+ metadataSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
1422
+ objects: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
1423
+ payloadSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null]))
1424
+ }), Schema.Null]))
1425
+ }), Schema.Null]))
1426
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<ListBucketMetricsResponse>;
1427
+
1428
+ export type ListBucketMetricsError =
1429
+ | DefaultErrors
1430
+ | InvalidRoute;
2305
1431
 
2306
1432
  export const listBucketMetrics: API.OperationMethod<
2307
1433
  ListBucketMetricsRequest,
@@ -2314,6 +1440,7 @@ export const listBucketMetrics: API.OperationMethod<
2314
1440
  errors: [InvalidRoute],
2315
1441
  }));
2316
1442
 
1443
+
2317
1444
  // =============================================================================
2318
1445
  // BucketSippy
2319
1446
  // =============================================================================
@@ -2329,74 +1456,39 @@ export interface GetBucketSippyRequest {
2329
1456
  export const GetBucketSippyRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2330
1457
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
2331
1458
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
2332
- jurisdiction: Schema.optional(
2333
- Schema.Literals(["default", "eu", "fedramp"]),
2334
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
2335
- }).pipe(
2336
- T.Http({
2337
- method: "GET",
2338
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/sippy",
2339
- }),
2340
- ) as unknown as Schema.Schema<GetBucketSippyRequest>;
1459
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
1460
+ })
1461
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/r2/buckets/{bucketName}/sippy" })) as unknown as Schema.Schema<GetBucketSippyRequest>;
2341
1462
 
2342
1463
  export interface GetBucketSippyResponse {
2343
1464
  /** Details about the configured destination bucket. */
2344
- destination?: {
2345
- accessKeyId?: string | null;
2346
- account?: string | null;
2347
- bucket?: string | null;
2348
- provider?: "r2" | null;
2349
- } | null;
1465
+ destination?: { accessKeyId?: string | null; account?: string | null; bucket?: string | null; provider?: "r2" | null } | null;
2350
1466
  /** State of Sippy for this bucket. */
2351
1467
  enabled?: boolean | null;
2352
1468
  /** Details about the configured source bucket. */
2353
- source?: {
2354
- bucket?: string | null;
2355
- bucketUrl?: string | null;
2356
- provider?: "aws" | "gcs" | "s3" | null;
2357
- region?: string | null;
2358
- } | null;
2359
- }
2360
-
2361
- export const GetBucketSippyResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
2362
- {
2363
- destination: Schema.optional(
2364
- Schema.Union([
2365
- Schema.Struct({
2366
- accessKeyId: Schema.optional(
2367
- Schema.Union([SensitiveString, Schema.Null]),
2368
- ),
2369
- account: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2370
- bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2371
- provider: Schema.optional(
2372
- Schema.Union([Schema.Literal("r2"), Schema.Null]),
2373
- ),
2374
- }),
2375
- Schema.Null,
2376
- ]),
2377
- ),
2378
- enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
2379
- source: Schema.optional(
2380
- Schema.Union([
2381
- Schema.Struct({
2382
- bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2383
- bucketUrl: Schema.optional(
2384
- Schema.Union([Schema.String, Schema.Null]),
2385
- ),
2386
- provider: Schema.optional(
2387
- Schema.Union([Schema.Literals(["aws", "gcs", "s3"]), Schema.Null]),
2388
- ),
2389
- region: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2390
- }),
2391
- Schema.Null,
2392
- ]),
2393
- ),
2394
- },
2395
- ).pipe(
2396
- T.ResponsePath("result"),
2397
- ) as unknown as Schema.Schema<GetBucketSippyResponse>;
2398
-
2399
- export type GetBucketSippyError = DefaultErrors | NoSuchBucket | InvalidRoute;
1469
+ source?: { bucket?: string | null; bucketUrl?: string | null; provider?: "aws" | "gcs" | "s3" | null; region?: string | null } | null;
1470
+ }
1471
+
1472
+ export const GetBucketSippyResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1473
+ destination: Schema.optional(Schema.Union([Schema.Struct({
1474
+ accessKeyId: Schema.optional(Schema.Union([SensitiveString, Schema.Null])),
1475
+ account: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1476
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1477
+ provider: Schema.optional(Schema.Union([Schema.Literal("r2"), Schema.Null]))
1478
+ }), Schema.Null])),
1479
+ enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
1480
+ source: Schema.optional(Schema.Union([Schema.Struct({
1481
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1482
+ bucketUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1483
+ provider: Schema.optional(Schema.Union([Schema.Literals(["aws", "gcs", "s3"]), Schema.Null])),
1484
+ region: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
1485
+ }), Schema.Null]))
1486
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<GetBucketSippyResponse>;
1487
+
1488
+ export type GetBucketSippyError =
1489
+ | DefaultErrors
1490
+ | NoSuchBucket
1491
+ | InvalidRoute;
2400
1492
 
2401
1493
  export const getBucketSippy: API.OperationMethod<
2402
1494
  GetBucketSippyRequest,
@@ -2416,106 +1508,54 @@ export interface PutBucketSippyRequest {
2416
1508
  /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
2417
1509
  jurisdiction?: "default" | "eu" | "fedramp";
2418
1510
  /** Body param: R2 bucket to copy objects to. */
2419
- destination?: {
2420
- accessKeyId?: string;
2421
- provider?: "r2";
2422
- secretAccessKey?: string;
2423
- };
1511
+ destination?: { accessKeyId?: string; provider?: "r2"; secretAccessKey?: string };
2424
1512
  /** Body param: AWS S3 bucket to copy objects from. */
2425
- source?: {
2426
- accessKeyId?: string;
2427
- bucket?: string;
2428
- provider?: "aws";
2429
- region?: string;
2430
- secretAccessKey?: string;
2431
- };
1513
+ source?: { accessKeyId?: string; bucket?: string; provider?: "aws"; region?: string; secretAccessKey?: string };
2432
1514
  }
2433
1515
 
2434
1516
  export const PutBucketSippyRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2435
1517
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
2436
1518
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
2437
- jurisdiction: Schema.optional(
2438
- Schema.Literals(["default", "eu", "fedramp"]),
2439
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
2440
- destination: Schema.optional(
2441
- Schema.Struct({
2442
- accessKeyId: Schema.optional(SensitiveString),
2443
- provider: Schema.optional(Schema.Literal("r2")),
2444
- secretAccessKey: Schema.optional(SensitiveString),
2445
- }),
2446
- ),
2447
- source: Schema.optional(
2448
- Schema.Struct({
2449
- accessKeyId: Schema.optional(SensitiveString),
2450
- bucket: Schema.optional(Schema.String),
2451
- provider: Schema.optional(Schema.Literal("aws")),
2452
- region: Schema.optional(Schema.String),
2453
- secretAccessKey: Schema.optional(SensitiveString),
2454
- }),
2455
- ),
2456
- }).pipe(
2457
- T.Http({
2458
- method: "PUT",
2459
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/sippy",
2460
- }),
2461
- ) as unknown as Schema.Schema<PutBucketSippyRequest>;
1519
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1520
+ destination: Schema.optional(Schema.Struct({
1521
+ accessKeyId: Schema.optional(SensitiveString),
1522
+ provider: Schema.optional(Schema.Literal("r2")),
1523
+ secretAccessKey: Schema.optional(SensitiveString)
1524
+ })),
1525
+ source: Schema.optional(Schema.Struct({
1526
+ accessKeyId: Schema.optional(SensitiveString),
1527
+ bucket: Schema.optional(Schema.String),
1528
+ provider: Schema.optional(Schema.Literal("aws")),
1529
+ region: Schema.optional(Schema.String),
1530
+ secretAccessKey: Schema.optional(SensitiveString)
1531
+ }))
1532
+ })
1533
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/r2/buckets/{bucketName}/sippy" })) as unknown as Schema.Schema<PutBucketSippyRequest>;
2462
1534
 
2463
1535
  export interface PutBucketSippyResponse {
2464
1536
  /** Details about the configured destination bucket. */
2465
- destination?: {
2466
- accessKeyId?: string | null;
2467
- account?: string | null;
2468
- bucket?: string | null;
2469
- provider?: "r2" | null;
2470
- } | null;
1537
+ destination?: { accessKeyId?: string | null; account?: string | null; bucket?: string | null; provider?: "r2" | null } | null;
2471
1538
  /** State of Sippy for this bucket. */
2472
1539
  enabled?: boolean | null;
2473
1540
  /** Details about the configured source bucket. */
2474
- source?: {
2475
- bucket?: string | null;
2476
- bucketUrl?: string | null;
2477
- provider?: "aws" | "gcs" | "s3" | null;
2478
- region?: string | null;
2479
- } | null;
2480
- }
2481
-
2482
- export const PutBucketSippyResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
2483
- {
2484
- destination: Schema.optional(
2485
- Schema.Union([
2486
- Schema.Struct({
2487
- accessKeyId: Schema.optional(
2488
- Schema.Union([SensitiveString, Schema.Null]),
2489
- ),
2490
- account: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2491
- bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2492
- provider: Schema.optional(
2493
- Schema.Union([Schema.Literal("r2"), Schema.Null]),
2494
- ),
2495
- }),
2496
- Schema.Null,
2497
- ]),
2498
- ),
2499
- enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
2500
- source: Schema.optional(
2501
- Schema.Union([
2502
- Schema.Struct({
2503
- bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2504
- bucketUrl: Schema.optional(
2505
- Schema.Union([Schema.String, Schema.Null]),
2506
- ),
2507
- provider: Schema.optional(
2508
- Schema.Union([Schema.Literals(["aws", "gcs", "s3"]), Schema.Null]),
2509
- ),
2510
- region: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2511
- }),
2512
- Schema.Null,
2513
- ]),
2514
- ),
2515
- },
2516
- ).pipe(
2517
- T.ResponsePath("result"),
2518
- ) as unknown as Schema.Schema<PutBucketSippyResponse>;
1541
+ source?: { bucket?: string | null; bucketUrl?: string | null; provider?: "aws" | "gcs" | "s3" | null; region?: string | null } | null;
1542
+ }
1543
+
1544
+ export const PutBucketSippyResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1545
+ destination: Schema.optional(Schema.Union([Schema.Struct({
1546
+ accessKeyId: Schema.optional(Schema.Union([SensitiveString, Schema.Null])),
1547
+ account: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1548
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1549
+ provider: Schema.optional(Schema.Union([Schema.Literal("r2"), Schema.Null]))
1550
+ }), Schema.Null])),
1551
+ enabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
1552
+ source: Schema.optional(Schema.Union([Schema.Struct({
1553
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1554
+ bucketUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1555
+ provider: Schema.optional(Schema.Union([Schema.Literals(["aws", "gcs", "s3"]), Schema.Null])),
1556
+ region: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
1557
+ }), Schema.Null]))
1558
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<PutBucketSippyResponse>;
2519
1559
 
2520
1560
  export type PutBucketSippyError =
2521
1561
  | DefaultErrors
@@ -2541,32 +1581,20 @@ export interface DeleteBucketSippyRequest {
2541
1581
  jurisdiction?: "default" | "eu" | "fedramp";
2542
1582
  }
2543
1583
 
2544
- export const DeleteBucketSippyRequest =
2545
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2546
- bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
2547
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
2548
- jurisdiction: Schema.optional(
2549
- Schema.Literals(["default", "eu", "fedramp"]),
2550
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
2551
- }).pipe(
2552
- T.Http({
2553
- method: "DELETE",
2554
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/sippy",
2555
- }),
2556
- ) as unknown as Schema.Schema<DeleteBucketSippyRequest>;
1584
+ export const DeleteBucketSippyRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1585
+ bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
1586
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
1587
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
1588
+ })
1589
+ .pipe(T.Http({ method: "DELETE", path: "/accounts/{account_id}/r2/buckets/{bucketName}/sippy" })) as unknown as Schema.Schema<DeleteBucketSippyRequest>;
2557
1590
 
2558
1591
  export interface DeleteBucketSippyResponse {
2559
1592
  enabled?: false | null;
2560
1593
  }
2561
1594
 
2562
- export const DeleteBucketSippyResponse =
2563
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2564
- enabled: Schema.optional(
2565
- Schema.Union([Schema.Literal(false), Schema.Null]),
2566
- ),
2567
- }).pipe(
2568
- T.ResponsePath("result"),
2569
- ) as unknown as Schema.Schema<DeleteBucketSippyResponse>;
1595
+ export const DeleteBucketSippyResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1596
+ enabled: Schema.optional(Schema.Union([Schema.Literal(false), Schema.Null]))
1597
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<DeleteBucketSippyResponse>;
2570
1598
 
2571
1599
  export type DeleteBucketSippyError =
2572
1600
  | DefaultErrors
@@ -2584,6 +1612,7 @@ export const deleteBucketSippy: API.OperationMethod<
2584
1612
  errors: [NoSuchBucket, InvalidRoute],
2585
1613
  }));
2586
1614
 
1615
+
2587
1616
  // =============================================================================
2588
1617
  // Object
2589
1618
  // =============================================================================
@@ -2603,22 +1632,13 @@ export const GetObjectRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2603
1632
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
2604
1633
  objectName: Schema.String.pipe(T.HttpPath("objectName")),
2605
1634
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
2606
- cfR2Jurisdiction: Schema.optional(
2607
- Schema.Literals(["default", "eu", "fedramp"]),
2608
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
2609
- }).pipe(
2610
- T.Http({
2611
- method: "GET",
2612
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/objects/{objectName}",
2613
- }),
2614
- ) as unknown as Schema.Schema<GetObjectRequest>;
1635
+ cfR2Jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
1636
+ })
1637
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/r2/buckets/{bucketName}/objects/{objectName}" })) as unknown as Schema.Schema<GetObjectRequest>;
2615
1638
 
2616
1639
  export type GetObjectResponse = File | Blob;
2617
1640
 
2618
- export const GetObjectResponse =
2619
- /*@__PURE__*/ /*#__PURE__*/ UploadableSchema.pipe(T.HttpFormDataFile()).pipe(
2620
- T.ResponsePath("result"),
2621
- ) as unknown as Schema.Schema<GetObjectResponse>;
1641
+ export const GetObjectResponse = /*@__PURE__*/ /*#__PURE__*/ UploadableSchema.pipe(T.HttpFormDataFile()).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<GetObjectResponse>;
2622
1642
 
2623
1643
  export type GetObjectError =
2624
1644
  | DefaultErrors
@@ -2669,46 +1689,22 @@ export const PutObjectRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2669
1689
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
2670
1690
  objectName: Schema.String.pipe(T.HttpPath("objectName")),
2671
1691
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
2672
- cfR2Jurisdiction: Schema.optional(
2673
- Schema.Literals(["default", "eu", "fedramp"]),
2674
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
2675
- contentType: Schema.optional(Schema.String).pipe(
2676
- T.HttpHeader("content-type"),
2677
- ),
2678
- contentDisposition: Schema.optional(Schema.String).pipe(
2679
- T.HttpHeader("content-disposition"),
2680
- ),
2681
- contentEncoding: Schema.optional(Schema.String).pipe(
2682
- T.HttpHeader("content-encoding"),
2683
- ),
2684
- contentLanguage: Schema.optional(Schema.String).pipe(
2685
- T.HttpHeader("content-language"),
2686
- ),
2687
- contentLength: Schema.optional(Schema.String).pipe(
2688
- T.HttpHeader("content-length"),
2689
- ),
2690
- cacheControl: Schema.optional(Schema.String).pipe(
2691
- T.HttpHeader("cache-control"),
2692
- ),
1692
+ cfR2Jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction")),
1693
+ contentType: Schema.optional(Schema.String).pipe(T.HttpHeader("content-type")),
1694
+ contentDisposition: Schema.optional(Schema.String).pipe(T.HttpHeader("content-disposition")),
1695
+ contentEncoding: Schema.optional(Schema.String).pipe(T.HttpHeader("content-encoding")),
1696
+ contentLanguage: Schema.optional(Schema.String).pipe(T.HttpHeader("content-language")),
1697
+ contentLength: Schema.optional(Schema.String).pipe(T.HttpHeader("content-length")),
1698
+ cacheControl: Schema.optional(Schema.String).pipe(T.HttpHeader("cache-control")),
2693
1699
  expires: Schema.optional(Schema.String).pipe(T.HttpHeader("expires")),
2694
- cfR2StorageClass: Schema.optional(
2695
- Schema.Literals(["Standard", "InfrequentAccess"]),
2696
- ).pipe(T.HttpHeader("cf-r2-storage-class")),
2697
- body: UploadableSchema.pipe(T.HttpFormDataFile()).pipe(T.HttpBody()),
2698
- }).pipe(
2699
- T.Http({
2700
- method: "PUT",
2701
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/objects/{objectName}",
2702
- contentType: "multipart",
2703
- }),
2704
- ) as unknown as Schema.Schema<PutObjectRequest>;
1700
+ cfR2StorageClass: Schema.optional(Schema.Literals(["Standard", "InfrequentAccess"])).pipe(T.HttpHeader("cf-r2-storage-class")),
1701
+ body: UploadableSchema.pipe(T.HttpFormDataFile()).pipe(T.HttpBody())
1702
+ })
1703
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/r2/buckets/{bucketName}/objects/{objectName}", contentType: "multipart" })) as unknown as Schema.Schema<PutObjectRequest>;
2705
1704
 
2706
1705
  export type PutObjectResponse = unknown;
2707
1706
 
2708
- export const PutObjectResponse =
2709
- /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
2710
- T.ResponsePath("result"),
2711
- ) as unknown as Schema.Schema<PutObjectResponse>;
1707
+ export const PutObjectResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<PutObjectResponse>;
2712
1708
 
2713
1709
  export type PutObjectError =
2714
1710
  | DefaultErrors
@@ -2742,22 +1738,13 @@ export const DeleteObjectRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2742
1738
  bucketName: Schema.String.pipe(T.HttpPath("bucketName")),
2743
1739
  objectName: Schema.String.pipe(T.HttpPath("objectName")),
2744
1740
  accountId: Schema.String.pipe(T.HttpPath("account_id")),
2745
- cfR2Jurisdiction: Schema.optional(
2746
- Schema.Literals(["default", "eu", "fedramp"]),
2747
- ).pipe(T.HttpHeader("cf-r2-jurisdiction")),
2748
- }).pipe(
2749
- T.Http({
2750
- method: "DELETE",
2751
- path: "/accounts/{account_id}/r2/buckets/{bucketName}/objects/{objectName}",
2752
- }),
2753
- ) as unknown as Schema.Schema<DeleteObjectRequest>;
1741
+ cfR2Jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])).pipe(T.HttpHeader("cf-r2-jurisdiction"))
1742
+ })
1743
+ .pipe(T.Http({ method: "DELETE", path: "/accounts/{account_id}/r2/buckets/{bucketName}/objects/{objectName}" })) as unknown as Schema.Schema<DeleteObjectRequest>;
2754
1744
 
2755
1745
  export type DeleteObjectResponse = unknown;
2756
1746
 
2757
- export const DeleteObjectResponse =
2758
- /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
2759
- T.ResponsePath("result"),
2760
- ) as unknown as Schema.Schema<DeleteObjectResponse>;
1747
+ export const DeleteObjectResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<DeleteObjectResponse>;
2761
1748
 
2762
1749
  export type DeleteObjectError =
2763
1750
  | DefaultErrors
@@ -2776,6 +1763,7 @@ export const deleteObject: API.OperationMethod<
2776
1763
  errors: [NoSuchBucket, InvalidRoute, NoRoute],
2777
1764
  }));
2778
1765
 
1766
+
2779
1767
  // =============================================================================
2780
1768
  // SuperSlurperConnectivityPrecheck
2781
1769
  // =============================================================================
@@ -2797,39 +1785,30 @@ export interface SourceSuperSlurperConnectivityPrecheckRequest {
2797
1785
  region?: string | null;
2798
1786
  }
2799
1787
 
2800
- export const SourceSuperSlurperConnectivityPrecheckRequest =
2801
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2802
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
2803
- bucket: Schema.String,
2804
- secret: Schema.Struct({
2805
- accessKeyId: SensitiveString,
2806
- secretAccessKey: SensitiveString,
2807
- }),
2808
- vendor: Schema.Literal("s3"),
2809
- endpoint: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2810
- pathPrefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2811
- region: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2812
- }).pipe(
2813
- T.Http({
2814
- method: "PUT",
2815
- path: "/accounts/{account_id}/slurper/source/connectivity-precheck",
2816
- }),
2817
- ) as unknown as Schema.Schema<SourceSuperSlurperConnectivityPrecheckRequest>;
1788
+ export const SourceSuperSlurperConnectivityPrecheckRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1789
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
1790
+ bucket: Schema.String,
1791
+ secret: Schema.Struct({
1792
+ accessKeyId: SensitiveString,
1793
+ secretAccessKey: SensitiveString
1794
+ }),
1795
+ vendor: Schema.Literal("s3"),
1796
+ endpoint: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1797
+ pathPrefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1798
+ region: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
1799
+ })
1800
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/slurper/source/connectivity-precheck" })) as unknown as Schema.Schema<SourceSuperSlurperConnectivityPrecheckRequest>;
2818
1801
 
2819
1802
  export interface SourceSuperSlurperConnectivityPrecheckResponse {
2820
1803
  connectivityStatus?: "success" | "error" | null;
2821
1804
  }
2822
1805
 
2823
- export const SourceSuperSlurperConnectivityPrecheckResponse =
2824
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2825
- connectivityStatus: Schema.optional(
2826
- Schema.Union([Schema.Literals(["success", "error"]), Schema.Null]),
2827
- ),
2828
- }).pipe(
2829
- T.ResponsePath("result"),
2830
- ) as unknown as Schema.Schema<SourceSuperSlurperConnectivityPrecheckResponse>;
1806
+ export const SourceSuperSlurperConnectivityPrecheckResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1807
+ connectivityStatus: Schema.optional(Schema.Union([Schema.Literals(["success", "error"]), Schema.Null]))
1808
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<SourceSuperSlurperConnectivityPrecheckResponse>;
2831
1809
 
2832
- export type SourceSuperSlurperConnectivityPrecheckError = DefaultErrors;
1810
+ export type SourceSuperSlurperConnectivityPrecheckError =
1811
+ | DefaultErrors;
2833
1812
 
2834
1813
  export const sourceSuperSlurperConnectivityPrecheck: API.OperationMethod<
2835
1814
  SourceSuperSlurperConnectivityPrecheckRequest,
@@ -2855,39 +1834,28 @@ export interface TargetSuperSlurperConnectivityPrecheckRequest {
2855
1834
  jurisdiction?: "default" | "eu" | "fedramp";
2856
1835
  }
2857
1836
 
2858
- export const TargetSuperSlurperConnectivityPrecheckRequest =
2859
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2860
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
2861
- bucket: Schema.String,
2862
- secret: Schema.Struct({
2863
- accessKeyId: SensitiveString,
2864
- secretAccessKey: SensitiveString,
2865
- }),
2866
- vendor: Schema.Literal("r2"),
2867
- jurisdiction: Schema.optional(
2868
- Schema.Literals(["default", "eu", "fedramp"]),
2869
- ),
2870
- }).pipe(
2871
- T.Http({
2872
- method: "PUT",
2873
- path: "/accounts/{account_id}/slurper/target/connectivity-precheck",
2874
- }),
2875
- ) as unknown as Schema.Schema<TargetSuperSlurperConnectivityPrecheckRequest>;
1837
+ export const TargetSuperSlurperConnectivityPrecheckRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1838
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
1839
+ bucket: Schema.String,
1840
+ secret: Schema.Struct({
1841
+ accessKeyId: SensitiveString,
1842
+ secretAccessKey: SensitiveString
1843
+ }),
1844
+ vendor: Schema.Literal("r2"),
1845
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"]))
1846
+ })
1847
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/slurper/target/connectivity-precheck" })) as unknown as Schema.Schema<TargetSuperSlurperConnectivityPrecheckRequest>;
2876
1848
 
2877
1849
  export interface TargetSuperSlurperConnectivityPrecheckResponse {
2878
1850
  connectivityStatus?: "success" | "error" | null;
2879
1851
  }
2880
1852
 
2881
- export const TargetSuperSlurperConnectivityPrecheckResponse =
2882
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2883
- connectivityStatus: Schema.optional(
2884
- Schema.Union([Schema.Literals(["success", "error"]), Schema.Null]),
2885
- ),
2886
- }).pipe(
2887
- T.ResponsePath("result"),
2888
- ) as unknown as Schema.Schema<TargetSuperSlurperConnectivityPrecheckResponse>;
1853
+ export const TargetSuperSlurperConnectivityPrecheckResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1854
+ connectivityStatus: Schema.optional(Schema.Union([Schema.Literals(["success", "error"]), Schema.Null]))
1855
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<TargetSuperSlurperConnectivityPrecheckResponse>;
2889
1856
 
2890
- export type TargetSuperSlurperConnectivityPrecheckError = DefaultErrors;
1857
+ export type TargetSuperSlurperConnectivityPrecheckError =
1858
+ | DefaultErrors;
2891
1859
 
2892
1860
  export const targetSuperSlurperConnectivityPrecheck: API.OperationMethod<
2893
1861
  TargetSuperSlurperConnectivityPrecheckRequest,
@@ -2900,6 +1868,7 @@ export const targetSuperSlurperConnectivityPrecheck: API.OperationMethod<
2900
1868
  errors: [],
2901
1869
  }));
2902
1870
 
1871
+
2903
1872
  // =============================================================================
2904
1873
  // SuperSlurperJob
2905
1874
  // =============================================================================
@@ -2909,138 +1878,55 @@ export interface GetSuperSlurperJobRequest {
2909
1878
  accountId: string;
2910
1879
  }
2911
1880
 
2912
- export const GetSuperSlurperJobRequest =
2913
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2914
- jobId: Schema.String.pipe(T.HttpPath("jobId")),
2915
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
2916
- }).pipe(
2917
- T.Http({
2918
- method: "GET",
2919
- path: "/accounts/{account_id}/slurper/jobs/{jobId}",
2920
- }),
2921
- ) as unknown as Schema.Schema<GetSuperSlurperJobRequest>;
1881
+ export const GetSuperSlurperJobRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1882
+ jobId: Schema.String.pipe(T.HttpPath("jobId")),
1883
+ accountId: Schema.String.pipe(T.HttpPath("account_id"))
1884
+ })
1885
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/slurper/jobs/{jobId}" })) as unknown as Schema.Schema<GetSuperSlurperJobRequest>;
2922
1886
 
2923
1887
  export interface GetSuperSlurperJobResponse {
2924
1888
  id?: string | null;
2925
1889
  createdAt?: string | null;
2926
1890
  finishedAt?: string | null;
2927
1891
  overwrite?: boolean | null;
2928
- source?:
2929
- | {
2930
- bucket?: string | null;
2931
- endpoint?: string | null;
2932
- keys?: string[] | null;
2933
- pathPrefix?: string | null;
2934
- vendor?: "s3" | null;
2935
- }
2936
- | {
2937
- bucket?: string | null;
2938
- keys?: string[] | null;
2939
- pathPrefix?: string | null;
2940
- vendor?: "gcs" | null;
2941
- }
2942
- | {
2943
- bucket?: string | null;
2944
- jurisdiction?: "default" | "eu" | "fedramp" | null;
2945
- keys?: string[] | null;
2946
- pathPrefix?: string | null;
2947
- vendor?: "r2" | null;
2948
- }
2949
- | null;
1892
+ source?: { bucket?: string | null; endpoint?: string | null; keys?: string[] | null; pathPrefix?: string | null; vendor?: "s3" | null } | { bucket?: string | null; keys?: string[] | null; pathPrefix?: string | null; vendor?: "gcs" | null } | { bucket?: string | null; jurisdiction?: "default" | "eu" | "fedramp" | null; keys?: string[] | null; pathPrefix?: string | null; vendor?: "r2" | null } | null;
2950
1893
  status?: "running" | "paused" | "aborted" | "completed" | null;
2951
- target?: {
2952
- bucket?: string | null;
2953
- jurisdiction?: "default" | "eu" | "fedramp" | null;
2954
- vendor?: "r2" | null;
2955
- } | null;
2956
- }
2957
-
2958
- export const GetSuperSlurperJobResponse =
2959
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2960
- id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2961
- createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2962
- finishedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2963
- overwrite: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
2964
- source: Schema.optional(
2965
- Schema.Union([
2966
- Schema.Union([
2967
- Schema.Struct({
2968
- bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2969
- endpoint: Schema.optional(
2970
- Schema.Union([Schema.String, Schema.Null]),
2971
- ),
2972
- keys: Schema.optional(
2973
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
2974
- ),
2975
- pathPrefix: Schema.optional(
2976
- Schema.Union([Schema.String, Schema.Null]),
2977
- ),
2978
- vendor: Schema.optional(
2979
- Schema.Union([Schema.Literal("s3"), Schema.Null]),
2980
- ),
2981
- }),
2982
- Schema.Struct({
2983
- bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2984
- keys: Schema.optional(
2985
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
2986
- ),
2987
- pathPrefix: Schema.optional(
2988
- Schema.Union([Schema.String, Schema.Null]),
2989
- ),
2990
- vendor: Schema.optional(
2991
- Schema.Union([Schema.Literal("gcs"), Schema.Null]),
2992
- ),
2993
- }),
2994
- Schema.Struct({
2995
- bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2996
- jurisdiction: Schema.optional(
2997
- Schema.Union([
2998
- Schema.Literals(["default", "eu", "fedramp"]),
2999
- Schema.Null,
3000
- ]),
3001
- ),
3002
- keys: Schema.optional(
3003
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
3004
- ),
3005
- pathPrefix: Schema.optional(
3006
- Schema.Union([Schema.String, Schema.Null]),
3007
- ),
3008
- vendor: Schema.optional(
3009
- Schema.Union([Schema.Literal("r2"), Schema.Null]),
3010
- ),
3011
- }),
3012
- ]),
3013
- Schema.Null,
3014
- ]),
3015
- ),
3016
- status: Schema.optional(
3017
- Schema.Union([
3018
- Schema.Literals(["running", "paused", "aborted", "completed"]),
3019
- Schema.Null,
3020
- ]),
3021
- ),
3022
- target: Schema.optional(
3023
- Schema.Union([
3024
- Schema.Struct({
3025
- bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3026
- jurisdiction: Schema.optional(
3027
- Schema.Union([
3028
- Schema.Literals(["default", "eu", "fedramp"]),
3029
- Schema.Null,
3030
- ]),
3031
- ),
3032
- vendor: Schema.optional(
3033
- Schema.Union([Schema.Literal("r2"), Schema.Null]),
3034
- ),
3035
- }),
3036
- Schema.Null,
3037
- ]),
3038
- ),
3039
- }).pipe(
3040
- T.ResponsePath("result"),
3041
- ) as unknown as Schema.Schema<GetSuperSlurperJobResponse>;
3042
-
3043
- export type GetSuperSlurperJobError = DefaultErrors;
1894
+ target?: { bucket?: string | null; jurisdiction?: "default" | "eu" | "fedramp" | null; vendor?: "r2" | null } | null;
1895
+ }
1896
+
1897
+ export const GetSuperSlurperJobResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1898
+ id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1899
+ createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1900
+ finishedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1901
+ overwrite: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
1902
+ source: Schema.optional(Schema.Union([Schema.Union([Schema.Struct({
1903
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1904
+ endpoint: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1905
+ keys: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
1906
+ pathPrefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1907
+ vendor: Schema.optional(Schema.Union([Schema.Literal("s3"), Schema.Null]))
1908
+ }), Schema.Struct({
1909
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1910
+ keys: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
1911
+ pathPrefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1912
+ vendor: Schema.optional(Schema.Union([Schema.Literal("gcs"), Schema.Null]))
1913
+ }), Schema.Struct({
1914
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1915
+ jurisdiction: Schema.optional(Schema.Union([Schema.Literals(["default", "eu", "fedramp"]), Schema.Null])),
1916
+ keys: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
1917
+ pathPrefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1918
+ vendor: Schema.optional(Schema.Union([Schema.Literal("r2"), Schema.Null]))
1919
+ })]), Schema.Null])),
1920
+ status: Schema.optional(Schema.Union([Schema.Literals(["running", "paused", "aborted", "completed"]), Schema.Null])),
1921
+ target: Schema.optional(Schema.Union([Schema.Struct({
1922
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1923
+ jurisdiction: Schema.optional(Schema.Union([Schema.Literals(["default", "eu", "fedramp"]), Schema.Null])),
1924
+ vendor: Schema.optional(Schema.Union([Schema.Literal("r2"), Schema.Null]))
1925
+ }), Schema.Null]))
1926
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<GetSuperSlurperJobResponse>;
1927
+
1928
+ export type GetSuperSlurperJobError =
1929
+ | DefaultErrors;
3044
1930
 
3045
1931
  export const getSuperSlurperJob: API.OperationMethod<
3046
1932
  GetSuperSlurperJobRequest,
@@ -3062,148 +1948,52 @@ export interface ListSuperSlurperJobsRequest {
3062
1948
  offset?: number;
3063
1949
  }
3064
1950
 
3065
- export const ListSuperSlurperJobsRequest =
3066
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3067
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
3068
- limit: Schema.optional(Schema.Number).pipe(T.HttpQuery("limit")),
3069
- offset: Schema.optional(Schema.Number).pipe(T.HttpQuery("offset")),
3070
- }).pipe(
3071
- T.Http({ method: "GET", path: "/accounts/{account_id}/slurper/jobs" }),
3072
- ) as unknown as Schema.Schema<ListSuperSlurperJobsRequest>;
1951
+ export const ListSuperSlurperJobsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1952
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
1953
+ limit: Schema.optional(Schema.Number).pipe(T.HttpQuery("limit")),
1954
+ offset: Schema.optional(Schema.Number).pipe(T.HttpQuery("offset"))
1955
+ })
1956
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/slurper/jobs" })) as unknown as Schema.Schema<ListSuperSlurperJobsRequest>;
3073
1957
 
3074
1958
  export interface ListSuperSlurperJobsResponse {
3075
- result: {
3076
- id?: string | null;
3077
- createdAt?: string | null;
3078
- finishedAt?: string | null;
3079
- overwrite?: boolean | null;
3080
- source?:
3081
- | {
3082
- bucket?: string | null;
3083
- endpoint?: string | null;
3084
- keys?: string[] | null;
3085
- pathPrefix?: string | null;
3086
- vendor?: "s3" | null;
3087
- }
3088
- | {
3089
- bucket?: string | null;
3090
- keys?: string[] | null;
3091
- pathPrefix?: string | null;
3092
- vendor?: "gcs" | null;
3093
- }
3094
- | {
3095
- bucket?: string | null;
3096
- jurisdiction?: "default" | "eu" | "fedramp" | null;
3097
- keys?: string[] | null;
3098
- pathPrefix?: string | null;
3099
- vendor?: "r2" | null;
3100
- }
3101
- | null;
3102
- status?: "running" | "paused" | "aborted" | "completed" | null;
3103
- target?: {
3104
- bucket?: string | null;
3105
- jurisdiction?: "default" | "eu" | "fedramp" | null;
3106
- vendor?: "r2" | null;
3107
- } | null;
3108
- }[];
3109
- }
3110
-
3111
- export const ListSuperSlurperJobsResponse =
3112
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3113
- result: Schema.Array(
3114
- Schema.Struct({
3115
- id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3116
- createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3117
- finishedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3118
- overwrite: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
3119
- source: Schema.optional(
3120
- Schema.Union([
3121
- Schema.Union([
3122
- Schema.Struct({
3123
- bucket: Schema.optional(
3124
- Schema.Union([Schema.String, Schema.Null]),
3125
- ),
3126
- endpoint: Schema.optional(
3127
- Schema.Union([Schema.String, Schema.Null]),
3128
- ),
3129
- keys: Schema.optional(
3130
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
3131
- ),
3132
- pathPrefix: Schema.optional(
3133
- Schema.Union([Schema.String, Schema.Null]),
3134
- ),
3135
- vendor: Schema.optional(
3136
- Schema.Union([Schema.Literal("s3"), Schema.Null]),
3137
- ),
3138
- }),
3139
- Schema.Struct({
3140
- bucket: Schema.optional(
3141
- Schema.Union([Schema.String, Schema.Null]),
3142
- ),
3143
- keys: Schema.optional(
3144
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
3145
- ),
3146
- pathPrefix: Schema.optional(
3147
- Schema.Union([Schema.String, Schema.Null]),
3148
- ),
3149
- vendor: Schema.optional(
3150
- Schema.Union([Schema.Literal("gcs"), Schema.Null]),
3151
- ),
3152
- }),
3153
- Schema.Struct({
3154
- bucket: Schema.optional(
3155
- Schema.Union([Schema.String, Schema.Null]),
3156
- ),
3157
- jurisdiction: Schema.optional(
3158
- Schema.Union([
3159
- Schema.Literals(["default", "eu", "fedramp"]),
3160
- Schema.Null,
3161
- ]),
3162
- ),
3163
- keys: Schema.optional(
3164
- Schema.Union([Schema.Array(Schema.String), Schema.Null]),
3165
- ),
3166
- pathPrefix: Schema.optional(
3167
- Schema.Union([Schema.String, Schema.Null]),
3168
- ),
3169
- vendor: Schema.optional(
3170
- Schema.Union([Schema.Literal("r2"), Schema.Null]),
3171
- ),
3172
- }),
3173
- ]),
3174
- Schema.Null,
3175
- ]),
3176
- ),
3177
- status: Schema.optional(
3178
- Schema.Union([
3179
- Schema.Literals(["running", "paused", "aborted", "completed"]),
3180
- Schema.Null,
3181
- ]),
3182
- ),
3183
- target: Schema.optional(
3184
- Schema.Union([
3185
- Schema.Struct({
3186
- bucket: Schema.optional(
3187
- Schema.Union([Schema.String, Schema.Null]),
3188
- ),
3189
- jurisdiction: Schema.optional(
3190
- Schema.Union([
3191
- Schema.Literals(["default", "eu", "fedramp"]),
3192
- Schema.Null,
3193
- ]),
3194
- ),
3195
- vendor: Schema.optional(
3196
- Schema.Union([Schema.Literal("r2"), Schema.Null]),
3197
- ),
3198
- }),
3199
- Schema.Null,
3200
- ]),
3201
- ),
3202
- }),
3203
- ),
3204
- }) as unknown as Schema.Schema<ListSuperSlurperJobsResponse>;
3205
-
3206
- export type ListSuperSlurperJobsError = DefaultErrors;
1959
+ result: ({ id?: string | null; createdAt?: string | null; finishedAt?: string | null; overwrite?: boolean | null; source?: { bucket?: string | null; endpoint?: string | null; keys?: string[] | null; pathPrefix?: string | null; vendor?: "s3" | null } | { bucket?: string | null; keys?: string[] | null; pathPrefix?: string | null; vendor?: "gcs" | null } | { bucket?: string | null; jurisdiction?: "default" | "eu" | "fedramp" | null; keys?: string[] | null; pathPrefix?: string | null; vendor?: "r2" | null } | null; status?: "running" | "paused" | "aborted" | "completed" | null; target?: { bucket?: string | null; jurisdiction?: "default" | "eu" | "fedramp" | null; vendor?: "r2" | null } | null })[];
1960
+ }
1961
+
1962
+ export const ListSuperSlurperJobsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
1963
+ result: Schema.Array(Schema.Struct({
1964
+ id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1965
+ createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1966
+ finishedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1967
+ overwrite: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
1968
+ source: Schema.optional(Schema.Union([Schema.Union([Schema.Struct({
1969
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1970
+ endpoint: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1971
+ keys: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
1972
+ pathPrefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1973
+ vendor: Schema.optional(Schema.Union([Schema.Literal("s3"), Schema.Null]))
1974
+ }), Schema.Struct({
1975
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1976
+ keys: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
1977
+ pathPrefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1978
+ vendor: Schema.optional(Schema.Union([Schema.Literal("gcs"), Schema.Null]))
1979
+ }), Schema.Struct({
1980
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1981
+ jurisdiction: Schema.optional(Schema.Union([Schema.Literals(["default", "eu", "fedramp"]), Schema.Null])),
1982
+ keys: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
1983
+ pathPrefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1984
+ vendor: Schema.optional(Schema.Union([Schema.Literal("r2"), Schema.Null]))
1985
+ })]), Schema.Null])),
1986
+ status: Schema.optional(Schema.Union([Schema.Literals(["running", "paused", "aborted", "completed"]), Schema.Null])),
1987
+ target: Schema.optional(Schema.Union([Schema.Struct({
1988
+ bucket: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
1989
+ jurisdiction: Schema.optional(Schema.Union([Schema.Literals(["default", "eu", "fedramp"]), Schema.Null])),
1990
+ vendor: Schema.optional(Schema.Union([Schema.Literal("r2"), Schema.Null]))
1991
+ }), Schema.Null]))
1992
+ }))
1993
+ }) as unknown as Schema.Schema<ListSuperSlurperJobsResponse>;
1994
+
1995
+ export type ListSuperSlurperJobsError =
1996
+ | DefaultErrors;
3207
1997
 
3208
1998
  export const listSuperSlurperJobs: API.PaginatedOperationMethod<
3209
1999
  ListSuperSlurperJobsRequest,
@@ -3226,112 +2016,64 @@ export interface CreateSuperSlurperJobRequest {
3226
2016
  /** Body param: */
3227
2017
  overwrite?: boolean;
3228
2018
  /** Body param: */
3229
- source?:
3230
- | {
3231
- bucket: string;
3232
- secret: { accessKeyId: string; secretAccessKey: string };
3233
- vendor: "s3";
3234
- endpoint?: string | null;
3235
- pathPrefix?: string | null;
3236
- region?: string | null;
3237
- }
3238
- | {
3239
- bucket: string;
3240
- secret: { clientEmail: string; privateKey: string };
3241
- vendor: "gcs";
3242
- pathPrefix?: string | null;
3243
- }
3244
- | {
3245
- bucket: string;
3246
- secret: { accessKeyId: string; secretAccessKey: string };
3247
- vendor: "r2";
3248
- jurisdiction?: "default" | "eu" | "fedramp";
3249
- pathPrefix?: string | null;
3250
- };
2019
+ source?: { bucket: string; secret: { accessKeyId: string; secretAccessKey: string }; vendor: "s3"; endpoint?: string | null; pathPrefix?: string | null; region?: string | null } | { bucket: string; secret: { clientEmail: string; privateKey: string }; vendor: "gcs"; pathPrefix?: string | null } | { bucket: string; secret: { accessKeyId: string; secretAccessKey: string }; vendor: "r2"; jurisdiction?: "default" | "eu" | "fedramp"; pathPrefix?: string | null };
3251
2020
  /** Body param: */
3252
- target?: {
3253
- bucket: string;
3254
- secret: { accessKeyId: string; secretAccessKey: string };
3255
- vendor: "r2";
3256
- jurisdiction?: "default" | "eu" | "fedramp";
3257
- };
3258
- }
3259
-
3260
- export const CreateSuperSlurperJobRequest =
3261
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3262
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
3263
- overwrite: Schema.optional(Schema.Boolean),
3264
- source: Schema.optional(
3265
- Schema.Union([
3266
- Schema.Struct({
3267
- bucket: Schema.String,
3268
- secret: Schema.Struct({
3269
- accessKeyId: SensitiveString,
3270
- secretAccessKey: SensitiveString,
3271
- }),
3272
- vendor: Schema.Literal("s3"),
3273
- endpoint: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3274
- pathPrefix: Schema.optional(
3275
- Schema.Union([Schema.String, Schema.Null]),
3276
- ),
3277
- region: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3278
- }),
3279
- Schema.Struct({
3280
- bucket: Schema.String,
3281
- secret: Schema.Struct({
3282
- clientEmail: Schema.String,
3283
- privateKey: SensitiveString,
3284
- }),
3285
- vendor: Schema.Literal("gcs"),
3286
- pathPrefix: Schema.optional(
3287
- Schema.Union([Schema.String, Schema.Null]),
3288
- ),
3289
- }),
3290
- Schema.Struct({
3291
- bucket: Schema.String,
3292
- secret: Schema.Struct({
3293
- accessKeyId: SensitiveString,
3294
- secretAccessKey: SensitiveString,
3295
- }),
3296
- vendor: Schema.Literal("r2"),
3297
- jurisdiction: Schema.optional(
3298
- Schema.Literals(["default", "eu", "fedramp"]),
3299
- ),
3300
- pathPrefix: Schema.optional(
3301
- Schema.Union([Schema.String, Schema.Null]),
3302
- ),
3303
- }),
3304
- ]),
3305
- ),
3306
- target: Schema.optional(
3307
- Schema.Struct({
3308
- bucket: Schema.String,
3309
- secret: Schema.Struct({
3310
- accessKeyId: SensitiveString,
3311
- secretAccessKey: SensitiveString,
3312
- }),
3313
- vendor: Schema.Literal("r2"),
3314
- jurisdiction: Schema.optional(
3315
- Schema.Literals(["default", "eu", "fedramp"]),
3316
- ),
3317
- }),
3318
- ),
3319
- }).pipe(
3320
- T.Http({ method: "POST", path: "/accounts/{account_id}/slurper/jobs" }),
3321
- ) as unknown as Schema.Schema<CreateSuperSlurperJobRequest>;
2021
+ target?: { bucket: string; secret: { accessKeyId: string; secretAccessKey: string }; vendor: "r2"; jurisdiction?: "default" | "eu" | "fedramp" };
2022
+ }
2023
+
2024
+ export const CreateSuperSlurperJobRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2025
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
2026
+ overwrite: Schema.optional(Schema.Boolean),
2027
+ source: Schema.optional(Schema.Union([Schema.Struct({
2028
+ bucket: Schema.String,
2029
+ secret: Schema.Struct({
2030
+ accessKeyId: SensitiveString,
2031
+ secretAccessKey: SensitiveString
2032
+ }),
2033
+ vendor: Schema.Literal("s3"),
2034
+ endpoint: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2035
+ pathPrefix: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2036
+ region: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
2037
+ }), Schema.Struct({
2038
+ bucket: Schema.String,
2039
+ secret: Schema.Struct({
2040
+ clientEmail: Schema.String,
2041
+ privateKey: SensitiveString
2042
+ }),
2043
+ vendor: Schema.Literal("gcs"),
2044
+ pathPrefix: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
2045
+ }), Schema.Struct({
2046
+ bucket: Schema.String,
2047
+ secret: Schema.Struct({
2048
+ accessKeyId: SensitiveString,
2049
+ secretAccessKey: SensitiveString
2050
+ }),
2051
+ vendor: Schema.Literal("r2"),
2052
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"])),
2053
+ pathPrefix: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
2054
+ })])),
2055
+ target: Schema.optional(Schema.Struct({
2056
+ bucket: Schema.String,
2057
+ secret: Schema.Struct({
2058
+ accessKeyId: SensitiveString,
2059
+ secretAccessKey: SensitiveString
2060
+ }),
2061
+ vendor: Schema.Literal("r2"),
2062
+ jurisdiction: Schema.optional(Schema.Literals(["default", "eu", "fedramp"]))
2063
+ }))
2064
+ })
2065
+ .pipe(T.Http({ method: "POST", path: "/accounts/{account_id}/slurper/jobs" })) as unknown as Schema.Schema<CreateSuperSlurperJobRequest>;
3322
2066
 
3323
2067
  export interface CreateSuperSlurperJobResponse {
3324
2068
  id?: string | null;
3325
2069
  }
3326
2070
 
3327
- export const CreateSuperSlurperJobResponse =
3328
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3329
- id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3330
- }).pipe(
3331
- T.ResponsePath("result"),
3332
- ) as unknown as Schema.Schema<CreateSuperSlurperJobResponse>;
2071
+ export const CreateSuperSlurperJobResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2072
+ id: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
2073
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<CreateSuperSlurperJobResponse>;
3333
2074
 
3334
- export type CreateSuperSlurperJobError = DefaultErrors;
2075
+ export type CreateSuperSlurperJobError =
2076
+ | DefaultErrors;
3335
2077
 
3336
2078
  export const createSuperSlurperJob: API.OperationMethod<
3337
2079
  CreateSuperSlurperJobRequest,
@@ -3349,25 +2091,18 @@ export interface AbortSuperSlurperJobRequest {
3349
2091
  accountId: string;
3350
2092
  }
3351
2093
 
3352
- export const AbortSuperSlurperJobRequest =
3353
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3354
- jobId: Schema.String.pipe(T.HttpPath("jobId")),
3355
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
3356
- }).pipe(
3357
- T.Http({
3358
- method: "PUT",
3359
- path: "/accounts/{account_id}/slurper/jobs/{jobId}/abort",
3360
- }),
3361
- ) as unknown as Schema.Schema<AbortSuperSlurperJobRequest>;
2094
+ export const AbortSuperSlurperJobRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2095
+ jobId: Schema.String.pipe(T.HttpPath("jobId")),
2096
+ accountId: Schema.String.pipe(T.HttpPath("account_id"))
2097
+ })
2098
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/slurper/jobs/{jobId}/abort" })) as unknown as Schema.Schema<AbortSuperSlurperJobRequest>;
3362
2099
 
3363
2100
  export type AbortSuperSlurperJobResponse = string;
3364
2101
 
3365
- export const AbortSuperSlurperJobResponse =
3366
- /*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(
3367
- T.ResponsePath("result"),
3368
- ) as unknown as Schema.Schema<AbortSuperSlurperJobResponse>;
2102
+ export const AbortSuperSlurperJobResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<AbortSuperSlurperJobResponse>;
3369
2103
 
3370
- export type AbortSuperSlurperJobError = DefaultErrors;
2104
+ export type AbortSuperSlurperJobError =
2105
+ | DefaultErrors;
3371
2106
 
3372
2107
  export const abortSuperSlurperJob: API.OperationMethod<
3373
2108
  AbortSuperSlurperJobRequest,
@@ -3385,25 +2120,18 @@ export interface PauseSuperSlurperJobRequest {
3385
2120
  accountId: string;
3386
2121
  }
3387
2122
 
3388
- export const PauseSuperSlurperJobRequest =
3389
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3390
- jobId: Schema.String.pipe(T.HttpPath("jobId")),
3391
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
3392
- }).pipe(
3393
- T.Http({
3394
- method: "PUT",
3395
- path: "/accounts/{account_id}/slurper/jobs/{jobId}/pause",
3396
- }),
3397
- ) as unknown as Schema.Schema<PauseSuperSlurperJobRequest>;
2123
+ export const PauseSuperSlurperJobRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2124
+ jobId: Schema.String.pipe(T.HttpPath("jobId")),
2125
+ accountId: Schema.String.pipe(T.HttpPath("account_id"))
2126
+ })
2127
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/slurper/jobs/{jobId}/pause" })) as unknown as Schema.Schema<PauseSuperSlurperJobRequest>;
3398
2128
 
3399
2129
  export type PauseSuperSlurperJobResponse = string;
3400
2130
 
3401
- export const PauseSuperSlurperJobResponse =
3402
- /*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(
3403
- T.ResponsePath("result"),
3404
- ) as unknown as Schema.Schema<PauseSuperSlurperJobResponse>;
2131
+ export const PauseSuperSlurperJobResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<PauseSuperSlurperJobResponse>;
3405
2132
 
3406
- export type PauseSuperSlurperJobError = DefaultErrors;
2133
+ export type PauseSuperSlurperJobError =
2134
+ | DefaultErrors;
3407
2135
 
3408
2136
  export const pauseSuperSlurperJob: API.OperationMethod<
3409
2137
  PauseSuperSlurperJobRequest,
@@ -3421,16 +2149,11 @@ export interface ProgressSuperSlurperJobRequest {
3421
2149
  accountId: string;
3422
2150
  }
3423
2151
 
3424
- export const ProgressSuperSlurperJobRequest =
3425
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3426
- jobId: Schema.String.pipe(T.HttpPath("jobId")),
3427
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
3428
- }).pipe(
3429
- T.Http({
3430
- method: "GET",
3431
- path: "/accounts/{account_id}/slurper/jobs/{jobId}/progress",
3432
- }),
3433
- ) as unknown as Schema.Schema<ProgressSuperSlurperJobRequest>;
2152
+ export const ProgressSuperSlurperJobRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2153
+ jobId: Schema.String.pipe(T.HttpPath("jobId")),
2154
+ accountId: Schema.String.pipe(T.HttpPath("account_id"))
2155
+ })
2156
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/slurper/jobs/{jobId}/progress" })) as unknown as Schema.Schema<ProgressSuperSlurperJobRequest>;
3434
2157
 
3435
2158
  export interface ProgressSuperSlurperJobResponse {
3436
2159
  id?: string | null;
@@ -3442,27 +2165,18 @@ export interface ProgressSuperSlurperJobResponse {
3442
2165
  transferredObjects?: number | null;
3443
2166
  }
3444
2167
 
3445
- export const ProgressSuperSlurperJobResponse =
3446
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3447
- id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3448
- createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3449
- failedObjects: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
3450
- objects: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
3451
- skippedObjects: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
3452
- status: Schema.optional(
3453
- Schema.Union([
3454
- Schema.Literals(["running", "paused", "aborted", "completed"]),
3455
- Schema.Null,
3456
- ]),
3457
- ),
3458
- transferredObjects: Schema.optional(
3459
- Schema.Union([Schema.Number, Schema.Null]),
3460
- ),
3461
- }).pipe(
3462
- T.ResponsePath("result"),
3463
- ) as unknown as Schema.Schema<ProgressSuperSlurperJobResponse>;
3464
-
3465
- export type ProgressSuperSlurperJobError = DefaultErrors;
2168
+ export const ProgressSuperSlurperJobResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2169
+ id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2170
+ createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2171
+ failedObjects: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
2172
+ objects: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
2173
+ skippedObjects: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
2174
+ status: Schema.optional(Schema.Union([Schema.Literals(["running", "paused", "aborted", "completed"]), Schema.Null])),
2175
+ transferredObjects: Schema.optional(Schema.Union([Schema.Number, Schema.Null]))
2176
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<ProgressSuperSlurperJobResponse>;
2177
+
2178
+ export type ProgressSuperSlurperJobError =
2179
+ | DefaultErrors;
3466
2180
 
3467
2181
  export const progressSuperSlurperJob: API.OperationMethod<
3468
2182
  ProgressSuperSlurperJobRequest,
@@ -3480,25 +2194,18 @@ export interface ResumeSuperSlurperJobRequest {
3480
2194
  accountId: string;
3481
2195
  }
3482
2196
 
3483
- export const ResumeSuperSlurperJobRequest =
3484
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3485
- jobId: Schema.String.pipe(T.HttpPath("jobId")),
3486
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
3487
- }).pipe(
3488
- T.Http({
3489
- method: "PUT",
3490
- path: "/accounts/{account_id}/slurper/jobs/{jobId}/resume",
3491
- }),
3492
- ) as unknown as Schema.Schema<ResumeSuperSlurperJobRequest>;
2197
+ export const ResumeSuperSlurperJobRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2198
+ jobId: Schema.String.pipe(T.HttpPath("jobId")),
2199
+ accountId: Schema.String.pipe(T.HttpPath("account_id"))
2200
+ })
2201
+ .pipe(T.Http({ method: "PUT", path: "/accounts/{account_id}/slurper/jobs/{jobId}/resume" })) as unknown as Schema.Schema<ResumeSuperSlurperJobRequest>;
3493
2202
 
3494
2203
  export type ResumeSuperSlurperJobResponse = string;
3495
2204
 
3496
- export const ResumeSuperSlurperJobResponse =
3497
- /*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(
3498
- T.ResponsePath("result"),
3499
- ) as unknown as Schema.Schema<ResumeSuperSlurperJobResponse>;
2205
+ export const ResumeSuperSlurperJobResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(T.ResponsePath("result")) as unknown as Schema.Schema<ResumeSuperSlurperJobResponse>;
3500
2206
 
3501
- export type ResumeSuperSlurperJobError = DefaultErrors;
2207
+ export type ResumeSuperSlurperJobError =
2208
+ | DefaultErrors;
3502
2209
 
3503
2210
  export const resumeSuperSlurperJob: API.OperationMethod<
3504
2211
  ResumeSuperSlurperJobRequest,
@@ -3511,6 +2218,7 @@ export const resumeSuperSlurperJob: API.OperationMethod<
3511
2218
  errors: [],
3512
2219
  }));
3513
2220
 
2221
+
3514
2222
  // =============================================================================
3515
2223
  // SuperSlurperJobLog
3516
2224
  // =============================================================================
@@ -3525,80 +2233,30 @@ export interface ListSuperSlurperJobLogsRequest {
3525
2233
  offset?: number;
3526
2234
  }
3527
2235
 
3528
- export const ListSuperSlurperJobLogsRequest =
3529
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3530
- jobId: Schema.String.pipe(T.HttpPath("jobId")),
3531
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
3532
- limit: Schema.optional(Schema.Number).pipe(T.HttpQuery("limit")),
3533
- offset: Schema.optional(Schema.Number).pipe(T.HttpQuery("offset")),
3534
- }).pipe(
3535
- T.Http({
3536
- method: "GET",
3537
- path: "/accounts/{account_id}/slurper/jobs/{jobId}/logs",
3538
- }),
3539
- ) as unknown as Schema.Schema<ListSuperSlurperJobLogsRequest>;
2236
+ export const ListSuperSlurperJobLogsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2237
+ jobId: Schema.String.pipe(T.HttpPath("jobId")),
2238
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
2239
+ limit: Schema.optional(Schema.Number).pipe(T.HttpQuery("limit")),
2240
+ offset: Schema.optional(Schema.Number).pipe(T.HttpQuery("offset"))
2241
+ })
2242
+ .pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/slurper/jobs/{jobId}/logs" })) as unknown as Schema.Schema<ListSuperSlurperJobLogsRequest>;
3540
2243
 
3541
2244
  export interface ListSuperSlurperJobLogsResponse {
3542
- result: {
3543
- createdAt?: string | null;
3544
- job?: string | null;
3545
- logType?:
3546
- | "migrationStart"
3547
- | "migrationComplete"
3548
- | "migrationAbort"
3549
- | "migrationError"
3550
- | "migrationPause"
3551
- | "migrationResume"
3552
- | "migrationErrorFailedContinuation"
3553
- | "importErrorRetryExhaustion"
3554
- | "importSkippedStorageClass"
3555
- | "importSkippedOversized"
3556
- | "importSkippedEmptyObject"
3557
- | "importSkippedUnsupportedContentType"
3558
- | "importSkippedExcludedContentType"
3559
- | "importSkippedInvalidMedia"
3560
- | "importSkippedRequiresRetrieval"
3561
- | null;
3562
- message?: string | null;
3563
- objectKey?: string | null;
3564
- }[];
3565
- }
3566
-
3567
- export const ListSuperSlurperJobLogsResponse =
3568
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3569
- result: Schema.Array(
3570
- Schema.Struct({
3571
- createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3572
- job: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3573
- logType: Schema.optional(
3574
- Schema.Union([
3575
- Schema.Literals([
3576
- "migrationStart",
3577
- "migrationComplete",
3578
- "migrationAbort",
3579
- "migrationError",
3580
- "migrationPause",
3581
- "migrationResume",
3582
- "migrationErrorFailedContinuation",
3583
- "importErrorRetryExhaustion",
3584
- "importSkippedStorageClass",
3585
- "importSkippedOversized",
3586
- "importSkippedEmptyObject",
3587
- "importSkippedUnsupportedContentType",
3588
- "importSkippedExcludedContentType",
3589
- "importSkippedInvalidMedia",
3590
- "importSkippedRequiresRetrieval",
3591
- ]),
3592
- Schema.Null,
3593
- ]),
3594
- ),
3595
- message: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3596
- objectKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3597
- }),
3598
- ),
3599
- }) as unknown as Schema.Schema<ListSuperSlurperJobLogsResponse>;
3600
-
3601
- export type ListSuperSlurperJobLogsError = DefaultErrors;
2245
+ result: ({ createdAt?: string | null; job?: string | null; logType?: "migrationStart" | "migrationComplete" | "migrationAbort" | "migrationError" | "migrationPause" | "migrationResume" | "migrationErrorFailedContinuation" | "importErrorRetryExhaustion" | "importSkippedStorageClass" | "importSkippedOversized" | "importSkippedEmptyObject" | "importSkippedUnsupportedContentType" | "importSkippedExcludedContentType" | "importSkippedInvalidMedia" | "importSkippedRequiresRetrieval" | null; message?: string | null; objectKey?: string | null })[];
2246
+ }
2247
+
2248
+ export const ListSuperSlurperJobLogsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2249
+ result: Schema.Array(Schema.Struct({
2250
+ createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2251
+ job: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2252
+ logType: Schema.optional(Schema.Union([Schema.Literals(["migrationStart", "migrationComplete", "migrationAbort", "migrationError", "migrationPause", "migrationResume", "migrationErrorFailedContinuation", "importErrorRetryExhaustion", "importSkippedStorageClass", "importSkippedOversized", "importSkippedEmptyObject", "importSkippedUnsupportedContentType", "importSkippedExcludedContentType", "importSkippedInvalidMedia", "importSkippedRequiresRetrieval"]), Schema.Null])),
2253
+ message: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2254
+ objectKey: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
2255
+ }))
2256
+ }) as unknown as Schema.Schema<ListSuperSlurperJobLogsResponse>;
2257
+
2258
+ export type ListSuperSlurperJobLogsError =
2259
+ | DefaultErrors;
3602
2260
 
3603
2261
  export const listSuperSlurperJobLogs: API.PaginatedOperationMethod<
3604
2262
  ListSuperSlurperJobLogsRequest,
@@ -3615,6 +2273,7 @@ export const listSuperSlurperJobLogs: API.PaginatedOperationMethod<
3615
2273
  } as const,
3616
2274
  }));
3617
2275
 
2276
+
3618
2277
  // =============================================================================
3619
2278
  // TemporaryCredential
3620
2279
  // =============================================================================
@@ -3627,11 +2286,7 @@ export interface CreateTemporaryCredentialRequest {
3627
2286
  /** Body param: The parent access key id to use for signing. */
3628
2287
  parentAccessKeyId: string;
3629
2288
  /** Body param: Permissions allowed on the credentials. */
3630
- permission:
3631
- | "admin-read-write"
3632
- | "admin-read-only"
3633
- | "object-read-write"
3634
- | "object-read-only";
2289
+ permission: "admin-read-write" | "admin-read-only" | "object-read-write" | "object-read-only";
3635
2290
  /** Body param: How long the credentials will live for in seconds. */
3636
2291
  ttlSeconds: number;
3637
2292
  /** Body param: Optional object paths to scope the credentials to. */
@@ -3640,26 +2295,16 @@ export interface CreateTemporaryCredentialRequest {
3640
2295
  prefixes?: string[];
3641
2296
  }
3642
2297
 
3643
- export const CreateTemporaryCredentialRequest =
3644
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3645
- accountId: Schema.String.pipe(T.HttpPath("account_id")),
3646
- bucket: Schema.String,
3647
- parentAccessKeyId: Schema.String,
3648
- permission: Schema.Literals([
3649
- "admin-read-write",
3650
- "admin-read-only",
3651
- "object-read-write",
3652
- "object-read-only",
3653
- ]),
3654
- ttlSeconds: Schema.Number,
3655
- objects: Schema.optional(Schema.Array(Schema.String)),
3656
- prefixes: Schema.optional(Schema.Array(Schema.String)),
3657
- }).pipe(
3658
- T.Http({
3659
- method: "POST",
3660
- path: "/accounts/{account_id}/r2/temp-access-credentials",
3661
- }),
3662
- ) as unknown as Schema.Schema<CreateTemporaryCredentialRequest>;
2298
+ export const CreateTemporaryCredentialRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2299
+ accountId: Schema.String.pipe(T.HttpPath("account_id")),
2300
+ bucket: Schema.String,
2301
+ parentAccessKeyId: Schema.String,
2302
+ permission: Schema.Literals(["admin-read-write", "admin-read-only", "object-read-write", "object-read-only"]),
2303
+ ttlSeconds: Schema.Number,
2304
+ objects: Schema.optional(Schema.Array(Schema.String)),
2305
+ prefixes: Schema.optional(Schema.Array(Schema.String))
2306
+ })
2307
+ .pipe(T.Http({ method: "POST", path: "/accounts/{account_id}/r2/temp-access-credentials" })) as unknown as Schema.Schema<CreateTemporaryCredentialRequest>;
3663
2308
 
3664
2309
  export interface CreateTemporaryCredentialResponse {
3665
2310
  /** ID for new access key. */
@@ -3670,18 +2315,14 @@ export interface CreateTemporaryCredentialResponse {
3670
2315
  sessionToken?: string | null;
3671
2316
  }
3672
2317
 
3673
- export const CreateTemporaryCredentialResponse =
3674
- /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
3675
- accessKeyId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3676
- secretAccessKey: Schema.optional(
3677
- Schema.Union([Schema.String, Schema.Null]),
3678
- ),
3679
- sessionToken: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
3680
- }).pipe(
3681
- T.ResponsePath("result"),
3682
- ) as unknown as Schema.Schema<CreateTemporaryCredentialResponse>;
2318
+ export const CreateTemporaryCredentialResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
2319
+ accessKeyId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2320
+ secretAccessKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
2321
+ sessionToken: Schema.optional(Schema.Union([Schema.String, Schema.Null]))
2322
+ }).pipe(T.ResponsePath("result")) as unknown as Schema.Schema<CreateTemporaryCredentialResponse>;
3683
2323
 
3684
- export type CreateTemporaryCredentialError = DefaultErrors;
2324
+ export type CreateTemporaryCredentialError =
2325
+ | DefaultErrors;
3685
2326
 
3686
2327
  export const createTemporaryCredential: API.OperationMethod<
3687
2328
  CreateTemporaryCredentialRequest,