@distilled.cloud/cloudflare 0.2.6 → 0.4.0

package/src/services/connectivity.ts

@@ -5,6 +5,7 @@
  * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service connectivity
  */
 
+import * as stream from "effect/Stream";
 import * as Schema from "effect/Schema";
 import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
@@ -99,18 +100,22 @@ export const GetDirectoryServiceResponse =
     httpsPort: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
     serviceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      host: "host",
-      name: "name",
-      type: "type",
-      createdAt: "created_at",
-      httpPort: "http_port",
-      httpsPort: "https_port",
-      serviceId: "service_id",
-      updatedAt: "updated_at",
-    }),
-  ) as unknown as Schema.Schema<GetDirectoryServiceResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        host: "host",
+        name: "name",
+        type: "type",
+        createdAt: "created_at",
+        httpPort: "http_port",
+        httpsPort: "https_port",
+        serviceId: "service_id",
+        updatedAt: "updated_at",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<GetDirectoryServiceResponse>;
 
 export type GetDirectoryServiceError = DefaultErrors;
 
@@ -145,99 +150,163 @@ export const ListDirectoryServicesRequest =
     }),
   ) as unknown as Schema.Schema<ListDirectoryServicesRequest>;
 
-export type ListDirectoryServicesResponse = {
-  host:
-    | { ipv4: string; network: { tunnelId: string } }
-    | { ipv6: string; network: { tunnelId: string } }
-    | { ipv4: string; ipv6: string; network: { tunnelId: string } }
-    | {
-        hostname: string;
-        resolverNetwork: { tunnelId: string; resolverIps?: string[] | null };
-      };
-  name: string;
-  type: "http";
-  createdAt?: string | null;
-  httpPort?: number | null;
-  httpsPort?: number | null;
-  serviceId?: string | null;
-  updatedAt?: string | null;
-}[];
+export interface ListDirectoryServicesResponse {
+  result: {
+    host:
+      | { ipv4: string; network: { tunnelId: string } }
+      | { ipv6: string; network: { tunnelId: string } }
+      | { ipv4: string; ipv6: string; network: { tunnelId: string } }
+      | {
+          hostname: string;
+          resolverNetwork: { tunnelId: string; resolverIps?: string[] | null };
+        };
+    name: string;
+    type: "http";
+    createdAt?: string | null;
+    httpPort?: number | null;
+    httpsPort?: number | null;
+    serviceId?: string | null;
+    updatedAt?: string | null;
+  }[];
+  resultInfo: {
+    count?: number | null;
+    page?: number | null;
+    perPage?: number | null;
+    totalCount?: number | null;
+  };
+}
 
 export const ListDirectoryServicesResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-    Schema.Struct({
-      host: Schema.Union([
-        Schema.Struct({
-          ipv4: Schema.String,
-          network: Schema.Struct({
-            tunnelId: Schema.String,
-          }).pipe(Schema.encodeKeys({ tunnelId: "tunnel_id" })),
-        }),
-        Schema.Struct({
-          ipv6: Schema.String,
-          network: Schema.Struct({
-            tunnelId: Schema.String,
-          }).pipe(Schema.encodeKeys({ tunnelId: "tunnel_id" })),
-        }),
-        Schema.Struct({
-          ipv4: Schema.String,
-          ipv6: Schema.String,
-          network: Schema.Struct({
-            tunnelId: Schema.String,
-          }).pipe(Schema.encodeKeys({ tunnelId: "tunnel_id" })),
-        }),
-        Schema.Struct({
-          hostname: Schema.String,
-          resolverNetwork: Schema.Struct({
-            tunnelId: Schema.String,
-            resolverIps: Schema.optional(
-              Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(
+      Schema.Struct({
+        host: Schema.Union([
+          Schema.Struct({
+            ipv4: Schema.String,
+            network: Schema.Struct({
+              tunnelId: Schema.String,
+            }).pipe(Schema.encodeKeys({ tunnelId: "tunnel_id" })),
+          }),
+          Schema.Struct({
+            ipv6: Schema.String,
+            network: Schema.Struct({
+              tunnelId: Schema.String,
+            }).pipe(Schema.encodeKeys({ tunnelId: "tunnel_id" })),
+          }),
+          Schema.Struct({
+            ipv4: Schema.String,
+            ipv6: Schema.String,
+            network: Schema.Struct({
+              tunnelId: Schema.String,
+            }).pipe(Schema.encodeKeys({ tunnelId: "tunnel_id" })),
+          }),
+          Schema.Struct({
+            hostname: Schema.String,
+            resolverNetwork: Schema.Struct({
+              tunnelId: Schema.String,
+              resolverIps: Schema.optional(
+                Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+              ),
+            }).pipe(
+              Schema.encodeKeys({
+                tunnelId: "tunnel_id",
+                resolverIps: "resolver_ips",
+              }),
             ),
           }).pipe(
             Schema.encodeKeys({
-              tunnelId: "tunnel_id",
-              resolverIps: "resolver_ips",
+              hostname: "hostname",
+              resolverNetwork: "resolver_network",
             }),
           ),
-        }).pipe(
-          Schema.encodeKeys({
-            hostname: "hostname",
-            resolverNetwork: "resolver_network",
-          }),
-        ),
-      ]),
-      name: Schema.String,
-      type: Schema.Literal("http"),
-      createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      httpPort: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-      httpsPort: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-      serviceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        ]),
+        name: Schema.String,
+        type: Schema.Literal("http"),
+        createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        httpPort: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        httpsPort: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        serviceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      }).pipe(
+        Schema.encodeKeys({
+          host: "host",
+          name: "name",
+          type: "type",
+          createdAt: "created_at",
+          httpPort: "http_port",
+          httpsPort: "https_port",
+          serviceId: "service_id",
+          updatedAt: "updated_at",
+        }),
+      ),
+    ),
+    resultInfo: Schema.Struct({
+      count: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      page: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      perPage: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+      totalCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
     }).pipe(
       Schema.encodeKeys({
-        host: "host",
-        name: "name",
-        type: "type",
-        createdAt: "created_at",
-        httpPort: "http_port",
-        httpsPort: "https_port",
-        serviceId: "service_id",
-        updatedAt: "updated_at",
+        count: "count",
+        page: "page",
+        perPage: "per_page",
+        totalCount: "total_count",
       }),
     ),
+  }).pipe(
+    Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
   ) as unknown as Schema.Schema<ListDirectoryServicesResponse>;
 
 export type ListDirectoryServicesError = DefaultErrors;
 
-export const listDirectoryServices: API.OperationMethod<
+export const listDirectoryServices: API.PaginatedOperationMethod<
   ListDirectoryServicesRequest,
   ListDirectoryServicesResponse,
   ListDirectoryServicesError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: ListDirectoryServicesRequest,
+  ) => stream.Stream<
+    ListDirectoryServicesResponse,
+    ListDirectoryServicesError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: ListDirectoryServicesRequest) => stream.Stream<
+    {
+      host:
+        | { ipv4: string; network: { tunnelId: string } }
+        | { ipv6: string; network: { tunnelId: string } }
+        | { ipv4: string; ipv6: string; network: { tunnelId: string } }
+        | {
+            hostname: string;
+            resolverNetwork: {
+              tunnelId: string;
+              resolverIps?: string[] | null;
+            };
+          };
+      name: string;
+      type: "http";
+      createdAt?: string | null;
+      httpPort?: number | null;
+      httpsPort?: number | null;
+      serviceId?: string | null;
+      updatedAt?: string | null;
+    },
+    ListDirectoryServicesError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: ListDirectoryServicesRequest,
   output: ListDirectoryServicesResponse,
   errors: [],
+  pagination: {
+    mode: "page",
+    inputToken: "page",
+    outputToken: "resultInfo.page",
+    items: "result",
+    pageSize: "perPage",
+  } as const,
 }));
 
 export interface CreateDirectoryServiceRequest {
@@ -390,18 +459,22 @@ export const CreateDirectoryServiceResponse =
     httpsPort: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
     serviceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      host: "host",
-      name: "name",
-      type: "type",
-      createdAt: "created_at",
-      httpPort: "http_port",
-      httpsPort: "https_port",
-      serviceId: "service_id",
-      updatedAt: "updated_at",
-    }),
-  ) as unknown as Schema.Schema<CreateDirectoryServiceResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        host: "host",
+        name: "name",
+        type: "type",
+        createdAt: "created_at",
+        httpPort: "http_port",
+        httpsPort: "https_port",
+        serviceId: "service_id",
+        updatedAt: "updated_at",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<CreateDirectoryServiceResponse>;
 
 export type CreateDirectoryServiceError = DefaultErrors;
 
@@ -568,18 +641,22 @@ export const UpdateDirectoryServiceResponse =
     httpsPort: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
     serviceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      host: "host",
-      name: "name",
-      type: "type",
-      createdAt: "created_at",
-      httpPort: "http_port",
-      httpsPort: "https_port",
-      serviceId: "service_id",
-      updatedAt: "updated_at",
-    }),
-  ) as unknown as Schema.Schema<UpdateDirectoryServiceResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        host: "host",
+        name: "name",
+        type: "type",
+        createdAt: "created_at",
+        httpPort: "http_port",
+        httpsPort: "https_port",
+        serviceId: "service_id",
+        updatedAt: "updated_at",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<UpdateDirectoryServiceResponse>;
 
 export type UpdateDirectoryServiceError = DefaultErrors;
 

package/src/services/content-scanning.ts

@@ -5,6 +5,7 @@
  * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service content-scanning
  */
 
+import * as stream from "effect/Stream";
 import * as Schema from "effect/Schema";
 import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
@@ -42,7 +43,9 @@ export const GetContentScanningResponse =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     modified: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     value: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }) as unknown as Schema.Schema<GetContentScanningResponse>;
+  }).pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<GetContentScanningResponse>;
 
 export type GetContentScanningError = DefaultErrors;
 
@@ -86,7 +89,9 @@ export const CreateContentScanningResponse =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     modified: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     value: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }) as unknown as Schema.Schema<CreateContentScanningResponse>;
+  }).pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<CreateContentScanningResponse>;
 
 export type CreateContentScanningError = DefaultErrors;
 
@@ -130,7 +135,9 @@ export const PutContentScanningResponse =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     modified: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     value: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }) as unknown as Schema.Schema<PutContentScanningResponse>;
+  }).pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<PutContentScanningResponse>;
 
 export type PutContentScanningError = DefaultErrors;
 
@@ -163,7 +170,9 @@ export const EnableContentScanningRequest =
 export type EnableContentScanningResponse = unknown;
 
 export const EnableContentScanningResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<EnableContentScanningResponse>;
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<EnableContentScanningResponse>;
 
 export type EnableContentScanningError = DefaultErrors;
 
@@ -196,7 +205,9 @@ export const DisableContentScanningRequest =
 export type DisableContentScanningResponse = unknown;
 
 export const DisableContentScanningResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<DisableContentScanningResponse>;
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<DisableContentScanningResponse>;
 
 export type DisableContentScanningError = DefaultErrors;
 
@@ -229,29 +240,49 @@ export const ListPayloadsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   }),
 ) as unknown as Schema.Schema<ListPayloadsRequest>;
 
-export type ListPayloadsResponse = {
-  id?: string | null;
-  payload?: string | null;
-}[];
+export interface ListPayloadsResponse {
+  result: { id?: string | null; payload?: string | null }[];
+}
 
-export const ListPayloadsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-  Schema.Struct({
-    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    payload: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }),
-) as unknown as Schema.Schema<ListPayloadsResponse>;
+export const ListPayloadsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  result: Schema.Array(
+    Schema.Struct({
+      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      payload: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }),
+  ),
+}) as unknown as Schema.Schema<ListPayloadsResponse>;
 
 export type ListPayloadsError = DefaultErrors;
 
-export const listPayloads: API.OperationMethod<
+export const listPayloads: API.PaginatedOperationMethod<
   ListPayloadsRequest,
   ListPayloadsResponse,
   ListPayloadsError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: ListPayloadsRequest,
+  ) => stream.Stream<
+    ListPayloadsResponse,
+    ListPayloadsError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (
+    input: ListPayloadsRequest,
+  ) => stream.Stream<
+    { id?: string | null; payload?: string | null },
+    ListPayloadsError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: ListPayloadsRequest,
   output: ListPayloadsResponse,
   errors: [],
+  pagination: {
+    mode: "single",
+    items: "result",
+  } as const,
 }));
 
 export interface CreatePayloadRequest {
@@ -275,29 +306,49 @@ export const CreatePayloadRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   }),
 ) as unknown as Schema.Schema<CreatePayloadRequest>;
 
-export type CreatePayloadResponse = {
-  id?: string | null;
-  payload?: string | null;
-}[];
+export interface CreatePayloadResponse {
+  result: { id?: string | null; payload?: string | null }[];
+}
 
-export const CreatePayloadResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-  Schema.Struct({
-    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    payload: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }),
-) as unknown as Schema.Schema<CreatePayloadResponse>;
+export const CreatePayloadResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  result: Schema.Array(
+    Schema.Struct({
+      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      payload: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }),
+  ),
+}) as unknown as Schema.Schema<CreatePayloadResponse>;
 
 export type CreatePayloadError = DefaultErrors;
 
-export const createPayload: API.OperationMethod<
+export const createPayload: API.PaginatedOperationMethod<
   CreatePayloadRequest,
   CreatePayloadResponse,
   CreatePayloadError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: CreatePayloadRequest,
+  ) => stream.Stream<
+    CreatePayloadResponse,
+    CreatePayloadError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (
+    input: CreatePayloadRequest,
+  ) => stream.Stream<
+    { id?: string | null; payload?: string | null },
+    CreatePayloadError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: CreatePayloadRequest,
   output: CreatePayloadResponse,
   errors: [],
+  pagination: {
+    mode: "single",
+    items: "result",
+  } as const,
 }));
 
 export interface DeletePayloadRequest {
@@ -316,29 +367,49 @@ export const DeletePayloadRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   }),
 ) as unknown as Schema.Schema<DeletePayloadRequest>;
 
-export type DeletePayloadResponse = {
-  id?: string | null;
-  payload?: string | null;
-}[];
+export interface DeletePayloadResponse {
+  result: { id?: string | null; payload?: string | null }[];
+}
 
-export const DeletePayloadResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-  Schema.Struct({
-    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-    payload: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }),
-) as unknown as Schema.Schema<DeletePayloadResponse>;
+export const DeletePayloadResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  result: Schema.Array(
+    Schema.Struct({
+      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      payload: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }),
+  ),
+}) as unknown as Schema.Schema<DeletePayloadResponse>;
 
 export type DeletePayloadError = DefaultErrors;
 
-export const deletePayload: API.OperationMethod<
+export const deletePayload: API.PaginatedOperationMethod<
   DeletePayloadRequest,
   DeletePayloadResponse,
   DeletePayloadError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: DeletePayloadRequest,
+  ) => stream.Stream<
+    DeletePayloadResponse,
+    DeletePayloadError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (
+    input: DeletePayloadRequest,
+  ) => stream.Stream<
+    { id?: string | null; payload?: string | null },
+    DeletePayloadError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: DeletePayloadRequest,
   output: DeletePayloadResponse,
   errors: [],
+  pagination: {
+    mode: "single",
+    items: "result",
+  } as const,
 }));
 
 // =============================================================================
@@ -369,7 +440,9 @@ export interface GetSettingResponse {
 export const GetSettingResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   modified: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
   value: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-}) as unknown as Schema.Schema<GetSettingResponse>;
+}).pipe(
+  T.ResponsePath("result"),
+) as unknown as Schema.Schema<GetSettingResponse>;
 
 export type GetSettingError = DefaultErrors;