@distilled.cloud/cloudflare 0.2.5-alpha2 → 0.3.0-alpha

package/src/services/organizations.ts

@@ -5,6 +5,7 @@
  * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service organizations
  */
 
+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";
@@ -109,16 +110,20 @@ export const GetOrganizationResponse =
         Schema.Null,
       ]),
     ),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      createTime: "create_time",
-      meta: "meta",
-      name: "name",
-      parent: "parent",
-      profile: "profile",
-    }),
-  ) as unknown as Schema.Schema<GetOrganizationResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        id: "id",
+        createTime: "create_time",
+        meta: "meta",
+        name: "name",
+        parent: "parent",
+        profile: "profile",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<GetOrganizationResponse>;
 
 export type GetOrganizationError = DefaultErrors;
 
@@ -140,111 +145,156 @@ export const ListOrganizationsRequest =
     T.Http({ method: "GET", path: "/organizations" }),
   ) as unknown as Schema.Schema<ListOrganizationsRequest>;
 
-export type ListOrganizationsResponse = {
-  id: string;
-  createTime: string;
-  meta: {
-    flags?: {
-      accountCreation: string;
-      accountDeletion: string;
-      accountMigration: string;
-      accountMobility: string;
-      subOrgCreation: string;
+export interface ListOrganizationsResponse {
+  result: {
+    id: string;
+    createTime: string;
+    meta: {
+      flags?: {
+        accountCreation: string;
+        accountDeletion: string;
+        accountMigration: string;
+        accountMobility: string;
+        subOrgCreation: string;
+      } | null;
+      managedBy?: string | null;
+    };
+    name: string;
+    parent?: { id: string; name: string } | null;
+    profile?: {
+      businessAddress: string;
+      businessEmail: string;
+      businessName: string;
+      businessPhone: string;
+      externalMetadata: string;
     } | null;
-    managedBy?: string | null;
-  };
-  name: string;
-  parent?: { id: string; name: string } | null;
-  profile?: {
-    businessAddress: string;
-    businessEmail: string;
-    businessName: string;
-    businessPhone: string;
-    externalMetadata: string;
-  } | null;
-}[];
+  }[];
+}
 
 export const ListOrganizationsResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-    Schema.Struct({
-      id: Schema.String,
-      createTime: Schema.String,
-      meta: Schema.Struct({
-        flags: Schema.optional(
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(
+      Schema.Struct({
+        id: Schema.String,
+        createTime: Schema.String,
+        meta: Schema.Struct({
+          flags: Schema.optional(
+            Schema.Union([
+              Schema.Struct({
+                accountCreation: Schema.String,
+                accountDeletion: Schema.String,
+                accountMigration: Schema.String,
+                accountMobility: Schema.String,
+                subOrgCreation: Schema.String,
+              }).pipe(
+                Schema.encodeKeys({
+                  accountCreation: "account_creation",
+                  accountDeletion: "account_deletion",
+                  accountMigration: "account_migration",
+                  accountMobility: "account_mobility",
+                  subOrgCreation: "sub_org_creation",
+                }),
+              ),
+              Schema.Null,
+            ]),
+          ),
+          managedBy: Schema.optional(
+            Schema.Union([Schema.String, Schema.Null]),
+          ),
+        }).pipe(Schema.encodeKeys({ flags: "flags", managedBy: "managed_by" })),
+        name: Schema.String,
+        parent: Schema.optional(
           Schema.Union([
             Schema.Struct({
-              accountCreation: Schema.String,
-              accountDeletion: Schema.String,
-              accountMigration: Schema.String,
-              accountMobility: Schema.String,
-              subOrgCreation: Schema.String,
+              id: Schema.String,
+              name: Schema.String,
+            }),
+            Schema.Null,
+          ]),
+        ),
+        profile: Schema.optional(
+          Schema.Union([
+            Schema.Struct({
+              businessAddress: Schema.String,
+              businessEmail: Schema.String,
+              businessName: Schema.String,
+              businessPhone: Schema.String,
+              externalMetadata: Schema.String,
             }).pipe(
               Schema.encodeKeys({
-                accountCreation: "account_creation",
-                accountDeletion: "account_deletion",
-                accountMigration: "account_migration",
-                accountMobility: "account_mobility",
-                subOrgCreation: "sub_org_creation",
+                businessAddress: "business_address",
+                businessEmail: "business_email",
+                businessName: "business_name",
+                businessPhone: "business_phone",
+                externalMetadata: "external_metadata",
               }),
             ),
             Schema.Null,
           ]),
         ),
-        managedBy: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      }).pipe(Schema.encodeKeys({ flags: "flags", managedBy: "managed_by" })),
-      name: Schema.String,
-      parent: Schema.optional(
-        Schema.Union([
-          Schema.Struct({
-            id: Schema.String,
-            name: Schema.String,
-          }),
-          Schema.Null,
-        ]),
-      ),
-      profile: Schema.optional(
-        Schema.Union([
-          Schema.Struct({
-            businessAddress: Schema.String,
-            businessEmail: Schema.String,
-            businessName: Schema.String,
-            businessPhone: Schema.String,
-            externalMetadata: Schema.String,
-          }).pipe(
-            Schema.encodeKeys({
-              businessAddress: "business_address",
-              businessEmail: "business_email",
-              businessName: "business_name",
-              businessPhone: "business_phone",
-              externalMetadata: "external_metadata",
-            }),
-          ),
-          Schema.Null,
-        ]),
+      }).pipe(
+        Schema.encodeKeys({
+          id: "id",
+          createTime: "create_time",
+          meta: "meta",
+          name: "name",
+          parent: "parent",
+          profile: "profile",
+        }),
       ),
-    }).pipe(
-      Schema.encodeKeys({
-        id: "id",
-        createTime: "create_time",
-        meta: "meta",
-        name: "name",
-        parent: "parent",
-        profile: "profile",
-      }),
     ),
-  ) as unknown as Schema.Schema<ListOrganizationsResponse>;
+  }) as unknown as Schema.Schema<ListOrganizationsResponse>;
 
 export type ListOrganizationsError = DefaultErrors;
 
-export const listOrganizations: API.OperationMethod<
+export const listOrganizations: API.PaginatedOperationMethod<
   ListOrganizationsRequest,
   ListOrganizationsResponse,
   ListOrganizationsError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: ListOrganizationsRequest,
+  ) => stream.Stream<
+    ListOrganizationsResponse,
+    ListOrganizationsError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: ListOrganizationsRequest) => stream.Stream<
+    {
+      id: string;
+      createTime: string;
+      meta: {
+        flags?: {
+          accountCreation: string;
+          accountDeletion: string;
+          accountMigration: string;
+          accountMobility: string;
+          subOrgCreation: string;
+        } | null;
+        managedBy?: string | null;
+      };
+      name: string;
+      parent?: { id: string; name: string } | null;
+      profile?: {
+        businessAddress: string;
+        businessEmail: string;
+        businessName: string;
+        businessPhone: string;
+        externalMetadata: string;
+      } | null;
+    },
+    ListOrganizationsError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: ListOrganizationsRequest,
   output: ListOrganizationsResponse,
   errors: [],
+  pagination: {
+    mode: "single",
+    items: "result",
+  } as const,
 }));
 
 export interface CreateOrganizationRequest {
@@ -369,16 +419,20 @@ export const CreateOrganizationResponse =
         Schema.Null,
       ]),
     ),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      createTime: "create_time",
-      meta: "meta",
-      name: "name",
-      parent: "parent",
-      profile: "profile",
-    }),
-  ) as unknown as Schema.Schema<CreateOrganizationResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        id: "id",
+        createTime: "create_time",
+        meta: "meta",
+        name: "name",
+        parent: "parent",
+        profile: "profile",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<CreateOrganizationResponse>;
 
 export type CreateOrganizationError = DefaultErrors;
 
@@ -517,16 +571,20 @@ export const UpdateOrganizationResponse =
         Schema.Null,
       ]),
     ),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      createTime: "create_time",
-      meta: "meta",
-      name: "name",
-      parent: "parent",
-      profile: "profile",
-    }),
-  ) as unknown as Schema.Schema<UpdateOrganizationResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        id: "id",
+        createTime: "create_time",
+        meta: "meta",
+        name: "name",
+        parent: "parent",
+        profile: "profile",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<UpdateOrganizationResponse>;
 
 export type UpdateOrganizationError = DefaultErrors;
 
@@ -559,7 +617,9 @@ export interface DeleteOrganizationResponse {
 export const DeleteOrganizationResponse =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String,
-  }) as unknown as Schema.Schema<DeleteOrganizationResponse>;
+  }).pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<DeleteOrganizationResponse>;
 
 export type DeleteOrganizationError = DefaultErrors;
 
@@ -604,15 +664,19 @@ export const GetOrganizationProfileResponse =
     businessName: Schema.String,
     businessPhone: Schema.String,
     externalMetadata: Schema.String,
-  }).pipe(
-    Schema.encodeKeys({
-      businessAddress: "business_address",
-      businessEmail: "business_email",
-      businessName: "business_name",
-      businessPhone: "business_phone",
-      externalMetadata: "external_metadata",
-    }),
-  ) as unknown as Schema.Schema<GetOrganizationProfileResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        businessAddress: "business_address",
+        businessEmail: "business_email",
+        businessName: "business_name",
+        businessPhone: "business_phone",
+        externalMetadata: "external_metadata",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<GetOrganizationProfileResponse>;
 
 export type GetOrganizationProfileError = DefaultErrors;
 

package/src/services/origin-ca-certificates.ts

@@ -5,6 +5,7 @@
  * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service origin-ca-certificates
  */
 
+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";
@@ -65,17 +66,21 @@ export const GetOriginCACertificateResponse =
     id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     certificate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     expiresOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      csr: "csr",
-      hostnames: "hostnames",
-      requestType: "request_type",
-      requestedValidity: "requested_validity",
-      id: "id",
-      certificate: "certificate",
-      expiresOn: "expires_on",
-    }),
-  ) as unknown as Schema.Schema<GetOriginCACertificateResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        csr: "csr",
+        hostnames: "hostnames",
+        requestType: "request_type",
+        requestedValidity: "requested_validity",
+        id: "id",
+        certificate: "certificate",
+        expiresOn: "expires_on",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<GetOriginCACertificateResponse>;
 
 export type GetOriginCACertificateError = DefaultErrors;
 
@@ -109,62 +114,117 @@ export const ListOriginCACertificatesRequest =
     T.Http({ method: "GET", path: "/certificates" }),
   ) as unknown as Schema.Schema<ListOriginCACertificatesRequest>;
 
-export type ListOriginCACertificatesResponse = {
-  csr: string;
-  hostnames: string[];
-  requestType: "origin-rsa" | "origin-ecc" | "keyless-certificate";
-  requestedValidity: "7" | "30" | "90" | "365" | "730" | "1095" | "5475";
-  id?: string | null;
-  certificate?: string | null;
-  expiresOn?: string | null;
-}[];
+export interface ListOriginCACertificatesResponse {
+  result: {
+    csr: string;
+    hostnames: string[];
+    requestType: "origin-rsa" | "origin-ecc" | "keyless-certificate";
+    requestedValidity: "7" | "30" | "90" | "365" | "730" | "1095" | "5475";
+    id?: string | null;
+    certificate?: string | null;
+    expiresOn?: string | null;
+  }[];
+  resultInfo: {
+    count?: number | null;
+    page?: number | null;
+    perPage?: number | null;
+    totalCount?: number | null;
+  };
+}
 
 export const ListOriginCACertificatesResponse =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
-    Schema.Struct({
-      csr: Schema.String,
-      hostnames: Schema.Array(Schema.String),
-      requestType: Schema.Literals([
-        "origin-rsa",
-        "origin-ecc",
-        "keyless-certificate",
-      ]),
-      requestedValidity: Schema.Literals([
-        "7",
-        "30",
-        "90",
-        "365",
-        "730",
-        "1095",
-        "5475",
-      ]),
-      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      certificate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      expiresOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(
+      Schema.Struct({
+        csr: Schema.String,
+        hostnames: Schema.Array(Schema.String),
+        requestType: Schema.Literals([
+          "origin-rsa",
+          "origin-ecc",
+          "keyless-certificate",
+        ]),
+        requestedValidity: Schema.Literals([
+          "7",
+          "30",
+          "90",
+          "365",
+          "730",
+          "1095",
+          "5475",
+        ]),
+        id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        certificate: Schema.optional(
+          Schema.Union([Schema.String, Schema.Null]),
+        ),
+        expiresOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      }).pipe(
+        Schema.encodeKeys({
+          csr: "csr",
+          hostnames: "hostnames",
+          requestType: "request_type",
+          requestedValidity: "requested_validity",
+          id: "id",
+          certificate: "certificate",
+          expiresOn: "expires_on",
+        }),
+      ),
+    ),
+    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({
-        csr: "csr",
-        hostnames: "hostnames",
-        requestType: "request_type",
-        requestedValidity: "requested_validity",
-        id: "id",
-        certificate: "certificate",
-        expiresOn: "expires_on",
+        count: "count",
+        page: "page",
+        perPage: "per_page",
+        totalCount: "total_count",
       }),
     ),
+  }).pipe(
+    Schema.encodeKeys({ result: "result", resultInfo: "result_info" }),
   ) as unknown as Schema.Schema<ListOriginCACertificatesResponse>;
 
 export type ListOriginCACertificatesError = DefaultErrors;
 
-export const listOriginCACertificates: API.OperationMethod<
+export const listOriginCACertificates: API.PaginatedOperationMethod<
   ListOriginCACertificatesRequest,
   ListOriginCACertificatesResponse,
   ListOriginCACertificatesError,
   Credentials | HttpClient.HttpClient
-> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+> & {
+  pages: (
+    input: ListOriginCACertificatesRequest,
+  ) => stream.Stream<
+    ListOriginCACertificatesResponse,
+    ListOriginCACertificatesError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: ListOriginCACertificatesRequest) => stream.Stream<
+    {
+      csr: string;
+      hostnames: string[];
+      requestType: "origin-rsa" | "origin-ecc" | "keyless-certificate";
+      requestedValidity: "7" | "30" | "90" | "365" | "730" | "1095" | "5475";
+      id?: string | null;
+      certificate?: string | null;
+      expiresOn?: string | null;
+    },
+    ListOriginCACertificatesError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: ListOriginCACertificatesRequest,
   output: ListOriginCACertificatesResponse,
   errors: [],
+  pagination: {
+    mode: "page",
+    inputToken: "page",
+    outputToken: "resultInfo.page",
+    items: "result",
+    pageSize: "perPage",
+  } as const,
 }));
 
 export interface CreateOriginCACertificateRequest {
@@ -238,17 +298,21 @@ export const CreateOriginCACertificateResponse =
     id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     certificate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     expiresOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      csr: "csr",
-      hostnames: "hostnames",
-      requestType: "request_type",
-      requestedValidity: "requested_validity",
-      id: "id",
-      certificate: "certificate",
-      expiresOn: "expires_on",
-    }),
-  ) as unknown as Schema.Schema<CreateOriginCACertificateResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        csr: "csr",
+        hostnames: "hostnames",
+        requestType: "request_type",
+        requestedValidity: "requested_validity",
+        id: "id",
+        certificate: "certificate",
+        expiresOn: "expires_on",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<CreateOriginCACertificateResponse>;
 
 export type CreateOriginCACertificateError = DefaultErrors;
 
@@ -285,9 +349,11 @@ export const DeleteOriginCACertificateResponse =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
     revokedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({ id: "id", revokedAt: "revoked_at" }),
-  ) as unknown as Schema.Schema<DeleteOriginCACertificateResponse>;
+  })
+    .pipe(Schema.encodeKeys({ id: "id", revokedAt: "revoked_at" }))
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<DeleteOriginCACertificateResponse>;
 
 export type DeleteOriginCACertificateError = DefaultErrors;
 

package/src/services/origin-post-quantum-encryption.ts

@@ -48,14 +48,18 @@ export const GetOriginPostQuantumEncryptionResponse =
     editable: Schema.Boolean,
     value: Schema.Literals(["preferred", "supported", "off"]),
     modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      editable: "editable",
-      value: "value",
-      modifiedOn: "modified_on",
-    }),
-  ) as unknown as Schema.Schema<GetOriginPostQuantumEncryptionResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        id: "id",
+        editable: "editable",
+        value: "value",
+        modifiedOn: "modified_on",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<GetOriginPostQuantumEncryptionResponse>;
 
 export type GetOriginPostQuantumEncryptionError = DefaultErrors;
 
@@ -105,14 +109,18 @@ export const PutOriginPostQuantumEncryptionResponse =
     editable: Schema.Boolean,
     value: Schema.Literals(["preferred", "supported", "off"]),
     modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }).pipe(
-    Schema.encodeKeys({
-      id: "id",
-      editable: "editable",
-      value: "value",
-      modifiedOn: "modified_on",
-    }),
-  ) as unknown as Schema.Schema<PutOriginPostQuantumEncryptionResponse>;
+  })
+    .pipe(
+      Schema.encodeKeys({
+        id: "id",
+        editable: "editable",
+        value: "value",
+        modifiedOn: "modified_on",
+      }),
+    )
+    .pipe(
+      T.ResponsePath("result"),
+    ) as unknown as Schema.Schema<PutOriginPostQuantumEncryptionResponse>;
 
 export type PutOriginPostQuantumEncryptionError = DefaultErrors;