@distilled.cloud/cloudflare 0.29.0 → 0.30.0

package/src/services/d1.ts

@@ -103,29 +103,28 @@ interface ListDatabasesResponseResult {
   uuid?: string | null;
   version?: string | null;
 }
-const ListDatabasesResponseResult = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      jurisdiction: Schema.optional(
-        Schema.Union([
-          Schema.Literal("eu"),
-          Schema.Literal("fedramp"),
-          Schema.Null,
-        ]),
-      ),
-      name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      uuid: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    }).pipe(
-      Schema.encodeKeys({
-        createdAt: "created_at",
-        jurisdiction: "jurisdiction",
-        name: "name",
-        uuid: "uuid",
-        version: "version",
-      }),
+const ListDatabasesResponseResult = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    jurisdiction: Schema.optional(
+      Schema.Union([
+        Schema.Literal("eu"),
+        Schema.Literal("fedramp"),
+        Schema.Null,
+      ]),
     ),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    uuid: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  }).pipe(
+    Schema.encodeKeys({
+      createdAt: "created_at",
+      jurisdiction: "jurisdiction",
+      name: "name",
+      uuid: "uuid",
+      version: "version",
+    }),
+  ),
 ) as unknown as Schema.Codec<ListDatabasesResponseResult>;
 
 interface ListDatabasesResponseResultInfo {
@@ -135,7 +134,7 @@ interface ListDatabasesResponseResultInfo {
   totalCount?: number | null;
 }
 const ListDatabasesResponseResultInfo =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+  /*@__PURE__*/ Schema.suspend(() =>
     Schema.Struct({
       count: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
       page: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
@@ -155,7 +154,7 @@ interface ReadReplication {
   /** The read replication mode for the database. Mode 'auto' denotes that D1 creates replicas and automatically places them around the world. Mode 'disabled' denotes that no database replicas are used. */
   mode: "auto" | "disabled" | (string & {});
 }
-const ReadReplication = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+const ReadReplication = /*@__PURE__*/ Schema.suspend(() =>
   Schema.Struct({
     mode: Schema.Union([Schema.Literals(["auto", "disabled"]), Schema.String]),
   }),
@@ -169,7 +168,7 @@ interface DumpOptions {
   /** Filter the export to just one or more tables. Passing an empty array is the same as not passing anything and means: export all tables. */
   tables?: string[] | null;
 }
-const DumpOptions = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+const DumpOptions = /*@__PURE__*/ Schema.suspend(() =>
   Schema.Struct({
     noData: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
     noSchema: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
@@ -191,7 +190,7 @@ interface Result {
   /** The URL to download the exported SQL. Available for one hour. */
   signedUrl?: string | null;
 }
-const Result = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+const Result = /*@__PURE__*/ Schema.suspend(() =>
   Schema.Struct({
     filename: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     signedUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
@@ -202,7 +201,7 @@ interface Timings {
   /** The duration of the SQL query execution inside the database. Does not include any network communication. */
   sqlDurationMs?: number | null;
 }
-const Timings = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+const Timings = /*@__PURE__*/ Schema.suspend(() =>
   Schema.Struct({
     sqlDurationMs: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
   }).pipe(Schema.encodeKeys({ sqlDurationMs: "sql_duration_ms" })),
@@ -240,7 +239,7 @@ interface Meta {
   /** Various durations for the query. */
   timings?: { sqlDurationMs?: number | null } | null;
 }
-const Meta = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+const Meta = /*@__PURE__*/ Schema.suspend(() =>
   Schema.Struct({
     changedDb: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
     changes: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
@@ -307,7 +306,7 @@ interface Result2 {
   /** The total number of queries that were executed during the import. */
   numQueries?: number | null;
 }
-const Result2 = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+const Result2 = /*@__PURE__*/ Schema.suspend(() =>
   Schema.Struct({
     finalBookmark: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     meta: Schema.optional(Schema.Union([Meta, Schema.Null])),
@@ -324,13 +323,23 @@ const Result2 = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
 interface Batch {
   /** Your SQL query. Supports multiple statements, joined by semicolons, which will be executed as a batch. */
   sql: string;
-  params?: string[] | null;
+  params?: (string | number | null | number[])[] | null;
 }
-const Batch = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+const Batch = /*@__PURE__*/ Schema.suspend(() =>
   Schema.Struct({
     sql: Schema.String,
     params: Schema.optional(
-      Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+      Schema.Union([
+        Schema.Array(
+          Schema.Union([
+            Schema.String,
+            Schema.Number,
+            Schema.Null,
+            Schema.Array(Schema.Number),
+          ]),
+        ),
+        Schema.Null,
+      ]),
     ),
   }),
 ) as unknown as Schema.Codec<Batch>;
@@ -360,22 +369,21 @@ interface QueryDatabaseResponseResult {
   results?: unknown[] | null;
   success?: boolean | null;
 }
-const QueryDatabaseResponseResult = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      meta: Schema.optional(Schema.Union([Meta, Schema.Null])),
-      results: Schema.optional(
-        Schema.Union([Schema.Array(Schema.Unknown), Schema.Null]),
-      ),
-      success: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-    }),
+const QueryDatabaseResponseResult = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    meta: Schema.optional(Schema.Union([Meta, Schema.Null])),
+    results: Schema.optional(
+      Schema.Union([Schema.Array(Schema.Unknown), Schema.Null]),
+    ),
+    success: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+  }),
 ) as unknown as Schema.Codec<QueryDatabaseResponseResult>;
 
 interface Results {
   columns?: string[] | null;
   rows?: unknown[][] | null;
 }
-const Results = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+const Results = /*@__PURE__*/ Schema.suspend(() =>
   Schema.Struct({
     columns: Schema.optional(
       Schema.Union([Schema.Array(Schema.String), Schema.Null]),
@@ -411,13 +419,12 @@ interface RawDatabaseResponseResult {
   results?: { columns?: string[] | null; rows?: unknown[][] | null } | null;
   success?: boolean | null;
 }
-const RawDatabaseResponseResult = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      meta: Schema.optional(Schema.Union([Meta, Schema.Null])),
-      results: Schema.optional(Schema.Union([Results, Schema.Null])),
-      success: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
-    }),
+const RawDatabaseResponseResult = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    meta: Schema.optional(Schema.Union([Meta, Schema.Null])),
+    results: Schema.optional(Schema.Union([Results, Schema.Null])),
+    success: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+  }),
 ) as unknown as Schema.Codec<RawDatabaseResponseResult>;
 
 // =============================================================================
@@ -433,7 +440,7 @@ export interface GetBookmarkDatabaseTimeTravelRequest {
 }
 
 export const GetBookmarkDatabaseTimeTravelRequest =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+  /*@__PURE__*/ Schema.suspend(() =>
     Schema.Struct({
       databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
       accountId: Schema.String.pipe(T.HttpPath("account_id")),
@@ -452,7 +459,7 @@ export interface GetBookmarkDatabaseTimeTravelResponse {
 }
 
 export const GetBookmarkDatabaseTimeTravelResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+  /*@__PURE__*/ Schema.suspend(() =>
     Schema.Struct({
       bookmark: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     }).pipe(T.ResponsePath("result")),
@@ -470,7 +477,7 @@ export const getBookmarkDatabaseTimeTravel: API.OperationMethod<
   GetBookmarkDatabaseTimeTravelResponse,
   GetBookmarkDatabaseTimeTravelError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> = /*@__PURE__*/ API.make(() => ({
   input: GetBookmarkDatabaseTimeTravelRequest,
   output: GetBookmarkDatabaseTimeTravelResponse,
   errors: [
@@ -494,16 +501,15 @@ export interface ListDatabasesRequest {
   name?: string;
 }
 
-export const ListDatabasesRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      accountId: Schema.String.pipe(T.HttpPath("account_id")),
-      page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
-      perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
-      name: Schema.optional(Schema.String).pipe(T.HttpQuery("name")),
-    }).pipe(
-      T.Http({ method: "GET", path: "/accounts/{account_id}/d1/database" }),
-    ),
+export const ListDatabasesRequest = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+    perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
+    name: Schema.optional(Schema.String).pipe(T.HttpQuery("name")),
+  }).pipe(
+    T.Http({ method: "GET", path: "/accounts/{account_id}/d1/database" }),
+  ),
 ) as unknown as Schema.Codec<ListDatabasesRequest>;
 
 export interface ListDatabasesResponse {
@@ -522,14 +528,13 @@ export interface ListDatabasesResponse {
   } | null;
 }
 
-export const ListDatabasesResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      result: Schema.Array(ListDatabasesResponseResult),
-      resultInfo: Schema.optional(
-        Schema.Union([ListDatabasesResponseResultInfo, Schema.Null]),
-      ),
-    }).pipe(Schema.encodeKeys({ result: "result", resultInfo: "result_info" })),
+export const ListDatabasesResponse = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    result: Schema.Array(ListDatabasesResponseResult),
+    resultInfo: Schema.optional(
+      Schema.Union([ListDatabasesResponseResultInfo, Schema.Null]),
+    ),
+  }).pipe(Schema.encodeKeys({ result: "result", resultInfo: "result_info" })),
 ) as unknown as Schema.Codec<ListDatabasesResponse>;
 
 export type ListDatabasesError = DefaultErrors;
@@ -539,7 +544,7 @@ export const listDatabases: API.PaginatedOperationMethod<
   ListDatabasesResponse,
   ListDatabasesError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
+> = /*@__PURE__*/ API.makePaginated(() => ({
   input: ListDatabasesRequest,
   output: ListDatabasesResponse,
   errors: [],
@@ -575,35 +580,34 @@ export interface GetDatabaseRequest {
   )[];
 }
 
-export const GetDatabaseRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
-      accountId: Schema.String.pipe(T.HttpPath("account_id")),
-      fields: Schema.optional(
-        Schema.Array(
-          Schema.Union([
-            Schema.Literals([
-              "uuid",
-              "name",
-              "created_at",
-              "version",
-              "jurisdiction",
-              "num_tables",
-              "file_size",
-              "running_in_region",
-              "read_replication",
-            ]),
-            Schema.String,
+export const GetDatabaseRequest = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    fields: Schema.optional(
+      Schema.Array(
+        Schema.Union([
+          Schema.Literals([
+            "uuid",
+            "name",
+            "created_at",
+            "version",
+            "jurisdiction",
+            "num_tables",
+            "file_size",
+            "running_in_region",
+            "read_replication",
           ]),
-        ),
-      ).pipe(T.HttpQuery("fields")),
-    }).pipe(
-      T.Http({
-        method: "GET",
-        path: "/accounts/{account_id}/d1/database/{databaseId}",
-      }),
-    ),
+          Schema.String,
+        ]),
+      ),
+    ).pipe(T.HttpQuery("fields")),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/accounts/{account_id}/d1/database/{databaseId}",
+    }),
+  ),
 ) as unknown as Schema.Codec<GetDatabaseRequest>;
 
 export interface GetDatabaseResponse {
@@ -623,39 +627,38 @@ export interface GetDatabaseResponse {
   version?: string | null;
 }
 
-export const GetDatabaseResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      fileSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-      jurisdiction: Schema.optional(
-        Schema.Union([
-          Schema.Literal("eu"),
-          Schema.Literal("fedramp"),
-          Schema.Null,
-        ]),
-      ),
-      name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      numTables: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-      readReplication: Schema.optional(
-        Schema.Union([ReadReplication, Schema.Null]),
-      ),
-      uuid: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    })
-      .pipe(
-        Schema.encodeKeys({
-          createdAt: "created_at",
-          fileSize: "file_size",
-          jurisdiction: "jurisdiction",
-          name: "name",
-          numTables: "num_tables",
-          readReplication: "read_replication",
-          uuid: "uuid",
-          version: "version",
-        }),
-      )
-      .pipe(T.ResponsePath("result")),
+export const GetDatabaseResponse = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    fileSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    jurisdiction: Schema.optional(
+      Schema.Union([
+        Schema.Literal("eu"),
+        Schema.Literal("fedramp"),
+        Schema.Null,
+      ]),
+    ),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    numTables: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    readReplication: Schema.optional(
+      Schema.Union([ReadReplication, Schema.Null]),
+    ),
+    uuid: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  })
+    .pipe(
+      Schema.encodeKeys({
+        createdAt: "created_at",
+        fileSize: "file_size",
+        jurisdiction: "jurisdiction",
+        name: "name",
+        numTables: "num_tables",
+        readReplication: "read_replication",
+        uuid: "uuid",
+        version: "version",
+      }),
+    )
+    .pipe(T.ResponsePath("result")),
 ) as unknown as Schema.Codec<GetDatabaseResponse>;
 
 export type GetDatabaseError =
@@ -669,7 +672,7 @@ export const getDatabase: API.OperationMethod<
   GetDatabaseResponse,
   GetDatabaseError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> = /*@__PURE__*/ API.make(() => ({
   input: GetDatabaseRequest,
   output: GetDatabaseResponse,
   errors: [InvalidObjectIdentifier, DatabaseNotFound, UnknownError],
@@ -695,30 +698,29 @@ export interface CreateDatabaseRequest {
   readReplication?: { mode: "auto" | "disabled" | (string & {}) };
 }
 
-export const CreateDatabaseRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      accountId: Schema.String.pipe(T.HttpPath("account_id")),
-      name: Schema.String,
-      jurisdiction: Schema.optional(
-        Schema.Union([Schema.Literals(["eu", "fedramp"]), Schema.String]),
-      ),
-      primaryLocationHint: Schema.optional(
-        Schema.Union([
-          Schema.Literals(["wnam", "enam", "weur", "eeur", "apac", "oc"]),
-          Schema.String,
-        ]),
-      ),
-      readReplication: Schema.optional(ReadReplication),
-    }).pipe(
-      Schema.encodeKeys({
-        name: "name",
-        jurisdiction: "jurisdiction",
-        primaryLocationHint: "primary_location_hint",
-        readReplication: "read_replication",
-      }),
-      T.Http({ method: "POST", path: "/accounts/{account_id}/d1/database" }),
+export const CreateDatabaseRequest = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    name: Schema.String,
+    jurisdiction: Schema.optional(
+      Schema.Union([Schema.Literals(["eu", "fedramp"]), Schema.String]),
     ),
+    primaryLocationHint: Schema.optional(
+      Schema.Union([
+        Schema.Literals(["wnam", "enam", "weur", "eeur", "apac", "oc"]),
+        Schema.String,
+      ]),
+    ),
+    readReplication: Schema.optional(ReadReplication),
+  }).pipe(
+    Schema.encodeKeys({
+      name: "name",
+      jurisdiction: "jurisdiction",
+      primaryLocationHint: "primary_location_hint",
+      readReplication: "read_replication",
+    }),
+    T.Http({ method: "POST", path: "/accounts/{account_id}/d1/database" }),
+  ),
 ) as unknown as Schema.Codec<CreateDatabaseRequest>;
 
 export interface CreateDatabaseResponse {
@@ -739,7 +741,7 @@ export interface CreateDatabaseResponse {
 }
 
 export const CreateDatabaseResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+  /*@__PURE__*/ Schema.suspend(() =>
     Schema.Struct({
       createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
       fileSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
@@ -784,7 +786,7 @@ export const createDatabase: API.OperationMethod<
   CreateDatabaseResponse,
   CreateDatabaseError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> = /*@__PURE__*/ API.make(() => ({
   input: CreateDatabaseRequest,
   output: CreateDatabaseResponse,
   errors: [InvalidObjectIdentifier, InvalidProperty, DatabaseAlreadyExists],
@@ -798,19 +800,18 @@ export interface UpdateDatabaseRequest {
   readReplication: { mode: "auto" | "disabled" | (string & {}) };
 }
 
-export const UpdateDatabaseRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
-      accountId: Schema.String.pipe(T.HttpPath("account_id")),
-      readReplication: ReadReplication,
-    }).pipe(
-      Schema.encodeKeys({ readReplication: "read_replication" }),
-      T.Http({
-        method: "PUT",
-        path: "/accounts/{account_id}/d1/database/{databaseId}",
-      }),
-    ),
+export const UpdateDatabaseRequest = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    readReplication: ReadReplication,
+  }).pipe(
+    Schema.encodeKeys({ readReplication: "read_replication" }),
+    T.Http({
+      method: "PUT",
+      path: "/accounts/{account_id}/d1/database/{databaseId}",
+    }),
+  ),
 ) as unknown as Schema.Codec<UpdateDatabaseRequest>;
 
 export interface UpdateDatabaseResponse {
@@ -831,7 +832,7 @@ export interface UpdateDatabaseResponse {
 }
 
 export const UpdateDatabaseResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+  /*@__PURE__*/ Schema.suspend(() =>
     Schema.Struct({
       createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
       fileSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
@@ -876,7 +877,7 @@ export const updateDatabase: API.OperationMethod<
   UpdateDatabaseResponse,
   UpdateDatabaseError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> = /*@__PURE__*/ API.make(() => ({
   input: UpdateDatabaseRequest,
   output: UpdateDatabaseResponse,
   errors: [InvalidObjectIdentifier, InternalError, DatabaseNotFound],
@@ -890,19 +891,18 @@ export interface PatchDatabaseRequest {
   readReplication?: { mode: "auto" | "disabled" | (string & {}) };
 }
 
-export const PatchDatabaseRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
-      accountId: Schema.String.pipe(T.HttpPath("account_id")),
-      readReplication: Schema.optional(ReadReplication),
-    }).pipe(
-      Schema.encodeKeys({ readReplication: "read_replication" }),
-      T.Http({
-        method: "PATCH",
-        path: "/accounts/{account_id}/d1/database/{databaseId}",
-      }),
-    ),
+export const PatchDatabaseRequest = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    readReplication: Schema.optional(ReadReplication),
+  }).pipe(
+    Schema.encodeKeys({ readReplication: "read_replication" }),
+    T.Http({
+      method: "PATCH",
+      path: "/accounts/{account_id}/d1/database/{databaseId}",
+    }),
+  ),
 ) as unknown as Schema.Codec<PatchDatabaseRequest>;
 
 export interface PatchDatabaseResponse {
@@ -922,39 +922,38 @@ export interface PatchDatabaseResponse {
   version?: string | null;
 }
 
-export const PatchDatabaseResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      fileSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-      jurisdiction: Schema.optional(
-        Schema.Union([
-          Schema.Literal("eu"),
-          Schema.Literal("fedramp"),
-          Schema.Null,
-        ]),
-      ),
-      name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      numTables: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-      readReplication: Schema.optional(
-        Schema.Union([ReadReplication, Schema.Null]),
-      ),
-      uuid: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    })
-      .pipe(
-        Schema.encodeKeys({
-          createdAt: "created_at",
-          fileSize: "file_size",
-          jurisdiction: "jurisdiction",
-          name: "name",
-          numTables: "num_tables",
-          readReplication: "read_replication",
-          uuid: "uuid",
-          version: "version",
-        }),
-      )
-      .pipe(T.ResponsePath("result")),
+export const PatchDatabaseResponse = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    fileSize: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    jurisdiction: Schema.optional(
+      Schema.Union([
+        Schema.Literal("eu"),
+        Schema.Literal("fedramp"),
+        Schema.Null,
+      ]),
+    ),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    numTables: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    readReplication: Schema.optional(
+      Schema.Union([ReadReplication, Schema.Null]),
+    ),
+    uuid: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    version: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  })
+    .pipe(
+      Schema.encodeKeys({
+        createdAt: "created_at",
+        fileSize: "file_size",
+        jurisdiction: "jurisdiction",
+        name: "name",
+        numTables: "num_tables",
+        readReplication: "read_replication",
+        uuid: "uuid",
+        version: "version",
+      }),
+    )
+    .pipe(T.ResponsePath("result")),
 ) as unknown as Schema.Codec<PatchDatabaseResponse>;
 
 export type PatchDatabaseError =
@@ -968,7 +967,7 @@ export const patchDatabase: API.OperationMethod<
   PatchDatabaseResponse,
   PatchDatabaseError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> = /*@__PURE__*/ API.make(() => ({
   input: PatchDatabaseRequest,
   output: PatchDatabaseResponse,
   errors: [InvalidObjectIdentifier, InternalError, DatabaseNotFound],
@@ -980,23 +979,22 @@ export interface DeleteDatabaseRequest {
   accountId: string;
 }
 
-export const DeleteDatabaseRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
-      accountId: Schema.String.pipe(T.HttpPath("account_id")),
-    }).pipe(
-      T.Http({
-        method: "DELETE",
-        path: "/accounts/{account_id}/d1/database/{databaseId}",
-      }),
-    ),
+export const DeleteDatabaseRequest = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      path: "/accounts/{account_id}/d1/database/{databaseId}",
+    }),
+  ),
 ) as unknown as Schema.Codec<DeleteDatabaseRequest>;
 
 export type DeleteDatabaseResponse = unknown;
 
 export const DeleteDatabaseResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+  /*@__PURE__*/ Schema.suspend(() =>
     Schema.Unknown.pipe(T.ResponsePath("result")),
   ) as unknown as Schema.Codec<DeleteDatabaseResponse>;
 
@@ -1011,7 +1009,7 @@ export const deleteDatabase: API.OperationMethod<
   DeleteDatabaseResponse,
   DeleteDatabaseError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> = /*@__PURE__*/ API.make(() => ({
   input: DeleteDatabaseRequest,
   output: DeleteDatabaseResponse,
   errors: [InvalidObjectIdentifier, DatabaseNotFound, UnknownError],
@@ -1029,25 +1027,24 @@ export interface ExportDatabaseRequest {
   dumpOptions?: { noData?: boolean; noSchema?: boolean; tables?: string[] };
 }
 
-export const ExportDatabaseRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
-      accountId: Schema.String.pipe(T.HttpPath("account_id")),
-      outputFormat: Schema.Literal("polling"),
-      currentBookmark: Schema.optional(Schema.String),
-      dumpOptions: Schema.optional(DumpOptions),
-    }).pipe(
-      Schema.encodeKeys({
-        outputFormat: "output_format",
-        currentBookmark: "current_bookmark",
-        dumpOptions: "dump_options",
-      }),
-      T.Http({
-        method: "POST",
-        path: "/accounts/{account_id}/d1/database/{databaseId}/export",
-      }),
-    ),
+export const ExportDatabaseRequest = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    outputFormat: Schema.Literal("polling"),
+    currentBookmark: Schema.optional(Schema.String),
+    dumpOptions: Schema.optional(DumpOptions),
+  }).pipe(
+    Schema.encodeKeys({
+      outputFormat: "output_format",
+      currentBookmark: "current_bookmark",
+      dumpOptions: "dump_options",
+    }),
+    T.Http({
+      method: "POST",
+      path: "/accounts/{account_id}/d1/database/{databaseId}/export",
+    }),
+  ),
 ) as unknown as Schema.Codec<ExportDatabaseRequest>;
 
 export interface ExportDatabaseResponse {
@@ -1065,7 +1062,7 @@ export interface ExportDatabaseResponse {
 }
 
 export const ExportDatabaseResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+  /*@__PURE__*/ Schema.suspend(() =>
     Schema.Struct({
       atBookmark: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
       error: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
@@ -1112,7 +1109,7 @@ export const exportDatabase: API.OperationMethod<
   ExportDatabaseResponse,
   ExportDatabaseError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> = /*@__PURE__*/ API.make(() => ({
   input: ExportDatabaseRequest,
   output: ExportDatabaseResponse,
   errors: [InvalidObjectIdentifier, InvalidRequest, DatabaseNotFound],
@@ -1132,30 +1129,29 @@ export interface ImportDatabaseRequest {
   currentBookmark?: string;
 }
 
-export const ImportDatabaseRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
-      accountId: Schema.String.pipe(T.HttpPath("account_id")),
-      action: Schema.Union([
-        Schema.Literals(["init", "ingest", "poll"]),
-        Schema.String,
-      ]),
-      etag: Schema.optional(Schema.String),
-      filename: Schema.optional(Schema.String),
-      currentBookmark: Schema.optional(Schema.String),
-    }).pipe(
-      Schema.encodeKeys({
-        action: "action",
-        etag: "etag",
-        filename: "filename",
-        currentBookmark: "current_bookmark",
-      }),
-      T.Http({
-        method: "POST",
-        path: "/accounts/{account_id}/d1/database/{databaseId}/import",
-      }),
-    ),
+export const ImportDatabaseRequest = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    action: Schema.Union([
+      Schema.Literals(["init", "ingest", "poll"]),
+      Schema.String,
+    ]),
+    etag: Schema.optional(Schema.String),
+    filename: Schema.optional(Schema.String),
+    currentBookmark: Schema.optional(Schema.String),
+  }).pipe(
+    Schema.encodeKeys({
+      action: "action",
+      etag: "etag",
+      filename: "filename",
+      currentBookmark: "current_bookmark",
+    }),
+    T.Http({
+      method: "POST",
+      path: "/accounts/{account_id}/d1/database/{databaseId}/import",
+    }),
+  ),
 ) as unknown as Schema.Codec<ImportDatabaseRequest>;
 
 export interface ImportDatabaseResponse {
@@ -1201,7 +1197,7 @@ export interface ImportDatabaseResponse {
 }
 
 export const ImportDatabaseResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+  /*@__PURE__*/ Schema.suspend(() =>
     Schema.Struct({
       atBookmark: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
       error: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
@@ -1245,7 +1241,7 @@ export const importDatabase: API.OperationMethod<
   ImportDatabaseResponse,
   ImportDatabaseError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> = /*@__PURE__*/ API.make(() => ({
   input: ImportDatabaseRequest,
   output: ImportDatabaseResponse,
   errors: [InvalidObjectIdentifier],
@@ -1258,25 +1254,33 @@ export interface QueryDatabaseRequest {
   /** Body param: Your SQL query. Supports multiple statements, joined by semicolons, which will be executed as a batch. */
   sql?: string;
   /** Body param */
-  params?: string[];
+  params?: (string | number | null | number[])[];
   /** Body param */
-  batch?: { sql: string; params?: string[] }[];
+  batch?: { sql: string; params?: (string | number | null | number[])[] }[];
 }
 
-export const QueryDatabaseRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
-      accountId: Schema.String.pipe(T.HttpPath("account_id")),
-      sql: Schema.optional(Schema.String),
-      params: Schema.optional(Schema.Array(Schema.String)),
-      batch: Schema.optional(Schema.Array(Batch)),
-    }).pipe(
-      T.Http({
-        method: "POST",
-        path: "/accounts/{account_id}/d1/database/{databaseId}/query",
-      }),
+export const QueryDatabaseRequest = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    sql: Schema.optional(Schema.String),
+    params: Schema.optional(
+      Schema.Array(
+        Schema.Union([
+          Schema.String,
+          Schema.Number,
+          Schema.Null,
+          Schema.Array(Schema.Number),
+        ]),
+      ),
     ),
+    batch: Schema.optional(Schema.Array(Batch)),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/accounts/{account_id}/d1/database/{databaseId}/query",
+    }),
+  ),
 ) as unknown as Schema.Codec<QueryDatabaseRequest>;
 
 export interface QueryDatabaseResponse {
@@ -1307,11 +1311,10 @@ export interface QueryDatabaseResponse {
   }[];
 }
 
-export const QueryDatabaseResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      result: Schema.Array(QueryDatabaseResponseResult),
-    }),
+export const QueryDatabaseResponse = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    result: Schema.Array(QueryDatabaseResponseResult),
+  }),
 ) as unknown as Schema.Codec<QueryDatabaseResponse>;
 
 export type QueryDatabaseError = DefaultErrors;
@@ -1321,7 +1324,7 @@ export const queryDatabase: API.PaginatedOperationMethod<
   QueryDatabaseResponse,
   QueryDatabaseError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
+> = /*@__PURE__*/ API.makePaginated(() => ({
   input: QueryDatabaseRequest,
   output: QueryDatabaseResponse,
   errors: [],
@@ -1338,25 +1341,33 @@ export interface RawDatabaseRequest {
   /** Body param: Your SQL query. Supports multiple statements, joined by semicolons, which will be executed as a batch. */
   sql?: string;
   /** Body param */
-  params?: string[];
+  params?: (string | number | null | number[])[];
   /** Body param */
-  batch?: { sql: string; params?: string[] }[];
+  batch?: { sql: string; params?: (string | number | null | number[])[] }[];
 }
 
-export const RawDatabaseRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
-      accountId: Schema.String.pipe(T.HttpPath("account_id")),
-      sql: Schema.optional(Schema.String),
-      params: Schema.optional(Schema.Array(Schema.String)),
-      batch: Schema.optional(Schema.Array(Batch)),
-    }).pipe(
-      T.Http({
-        method: "POST",
-        path: "/accounts/{account_id}/d1/database/{databaseId}/raw",
-      }),
+export const RawDatabaseRequest = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    sql: Schema.optional(Schema.String),
+    params: Schema.optional(
+      Schema.Array(
+        Schema.Union([
+          Schema.String,
+          Schema.Number,
+          Schema.Null,
+          Schema.Array(Schema.Number),
+        ]),
+      ),
     ),
+    batch: Schema.optional(Schema.Array(Batch)),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/accounts/{account_id}/d1/database/{databaseId}/raw",
+    }),
+  ),
 ) as unknown as Schema.Codec<RawDatabaseRequest>;
 
 export interface RawDatabaseResponse {
@@ -1387,11 +1398,10 @@ export interface RawDatabaseResponse {
   }[];
 }
 
-export const RawDatabaseResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
-  () =>
-    Schema.Struct({
-      result: Schema.Array(RawDatabaseResponseResult),
-    }),
+export const RawDatabaseResponse = /*@__PURE__*/ Schema.suspend(() =>
+  Schema.Struct({
+    result: Schema.Array(RawDatabaseResponseResult),
+  }),
 ) as unknown as Schema.Codec<RawDatabaseResponse>;
 
 export type RawDatabaseError = DefaultErrors;
@@ -1401,7 +1411,7 @@ export const rawDatabase: API.PaginatedOperationMethod<
   RawDatabaseResponse,
   RawDatabaseError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
+> = /*@__PURE__*/ API.makePaginated(() => ({
   input: RawDatabaseRequest,
   output: RawDatabaseResponse,
   errors: [],
@@ -1426,7 +1436,7 @@ export interface RestoreDatabaseTimeTravelRequest {
 }
 
 export const RestoreDatabaseTimeTravelRequest =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+  /*@__PURE__*/ Schema.suspend(() =>
     Schema.Struct({
       databaseId: Schema.String.pipe(T.HttpPath("databaseId")),
       accountId: Schema.String.pipe(T.HttpPath("account_id")),
@@ -1450,7 +1460,7 @@ export interface RestoreDatabaseTimeTravelResponse {
 }
 
 export const RestoreDatabaseTimeTravelResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(() =>
+  /*@__PURE__*/ Schema.suspend(() =>
     Schema.Struct({
       bookmark: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
       message: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
@@ -1480,7 +1490,7 @@ export const restoreDatabaseTimeTravel: API.OperationMethod<
   RestoreDatabaseTimeTravelResponse,
   RestoreDatabaseTimeTravelError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> = /*@__PURE__*/ API.make(() => ({
   input: RestoreDatabaseTimeTravelRequest,
   output: RestoreDatabaseTimeTravelResponse,
   errors: [