@distilled.cloud/cloudflare 0.0.0-john

package/src/services/registrar.ts

@@ -0,0 +1,390 @@
+/**
+ * Cloudflare REGISTRAR API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service registrar
+ */
+
+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";
+import * as T from "../traits.ts";
+import type { Credentials } from "../credentials.ts";
+import { type DefaultErrors } from "../errors.ts";
+
+// =============================================================================
+// Domain
+// =============================================================================
+
+export interface GetDomainRequest {
+  domainName: string;
+  /** Identifier */
+  accountId: string;
+}
+
+export const GetDomainRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  domainName: Schema.String.pipe(T.HttpPath("domainName")),
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(
+  T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/registrar/domains/{domainName}",
+  }),
+) as unknown as Schema.Schema<GetDomainRequest>;
+
+export type GetDomainResponse = unknown;
+
+export const GetDomainResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<GetDomainResponse>;
+
+export type GetDomainError = DefaultErrors;
+
+export const getDomain: API.OperationMethod<
+  GetDomainRequest,
+  GetDomainResponse,
+  GetDomainError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: GetDomainRequest,
+  output: GetDomainResponse,
+  errors: [],
+}));
+
+export interface ListDomainsRequest {
+  /** Identifier */
+  accountId: string;
+}
+
+export const ListDomainsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(
+  T.Http({ method: "GET", path: "/accounts/{account_id}/registrar/domains" }),
+) as unknown as Schema.Schema<ListDomainsRequest>;
+
+export interface ListDomainsResponse {
+  result: {
+    id?: string | null;
+    available?: boolean | null;
+    canRegister?: boolean | null;
+    createdAt?: string | null;
+    currentRegistrar?: string | null;
+    expiresAt?: string | null;
+    locked?: boolean | null;
+    registrantContact?: {
+      address: string;
+      city: string;
+      country: string | null;
+      firstName: string | null;
+      lastName: string | null;
+      organization: string;
+      phone: string | null;
+      state: string;
+      zip: string | null;
+      id?: string | null;
+      address2?: string | null;
+      email?: string | null;
+      fax?: string | null;
+    } | null;
+    registryStatuses?: string | null;
+    supportedTld?: boolean | null;
+    transferIn?: {
+      acceptFoa?: "needed" | "ok" | null;
+      approveTransfer?:
+        | "needed"
+        | "ok"
+        | "pending"
+        | "trying"
+        | "rejected"
+        | "unknown"
+        | null;
+      canCancelTransfer?: boolean | null;
+      disablePrivacy?: "needed" | "ok" | "unknown" | null;
+      enterAuthCode?:
+        | "needed"
+        | "ok"
+        | "pending"
+        | "trying"
+        | "rejected"
+        | null;
+      unlockDomain?: "needed" | "ok" | "pending" | "trying" | "unknown" | null;
+    } | null;
+    updatedAt?: string | null;
+  }[];
+}
+
+export const ListDomainsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  result: Schema.Array(
+    Schema.Struct({
+      id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      available: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+      canRegister: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+      createdAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      currentRegistrar: Schema.optional(
+        Schema.Union([Schema.String, Schema.Null]),
+      ),
+      expiresAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      locked: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+      registrantContact: Schema.optional(
+        Schema.Union([
+          Schema.Struct({
+            address: Schema.String,
+            city: Schema.String,
+            country: Schema.Union([Schema.String, Schema.Null]),
+            firstName: Schema.Union([Schema.String, Schema.Null]),
+            lastName: Schema.Union([Schema.String, Schema.Null]),
+            organization: Schema.String,
+            phone: Schema.Union([Schema.String, Schema.Null]),
+            state: Schema.String,
+            zip: Schema.Union([Schema.String, Schema.Null]),
+            id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            address2: Schema.optional(
+              Schema.Union([Schema.String, Schema.Null]),
+            ),
+            email: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            fax: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+          }).pipe(
+            Schema.encodeKeys({
+              address: "address",
+              city: "city",
+              country: "country",
+              firstName: "first_name",
+              lastName: "last_name",
+              organization: "organization",
+              phone: "phone",
+              state: "state",
+              zip: "zip",
+              id: "id",
+              address2: "address2",
+              email: "email",
+              fax: "fax",
+            }),
+          ),
+          Schema.Null,
+        ]),
+      ),
+      registryStatuses: Schema.optional(
+        Schema.Union([Schema.String, Schema.Null]),
+      ),
+      supportedTld: Schema.optional(
+        Schema.Union([Schema.Boolean, Schema.Null]),
+      ),
+      transferIn: Schema.optional(
+        Schema.Union([
+          Schema.Struct({
+            acceptFoa: Schema.optional(
+              Schema.Union([Schema.Literals(["needed", "ok"]), Schema.Null]),
+            ),
+            approveTransfer: Schema.optional(
+              Schema.Union([
+                Schema.Literals([
+                  "needed",
+                  "ok",
+                  "pending",
+                  "trying",
+                  "rejected",
+                  "unknown",
+                ]),
+                Schema.Null,
+              ]),
+            ),
+            canCancelTransfer: Schema.optional(
+              Schema.Union([Schema.Boolean, Schema.Null]),
+            ),
+            disablePrivacy: Schema.optional(
+              Schema.Union([
+                Schema.Literals(["needed", "ok", "unknown"]),
+                Schema.Null,
+              ]),
+            ),
+            enterAuthCode: Schema.optional(
+              Schema.Union([
+                Schema.Literals([
+                  "needed",
+                  "ok",
+                  "pending",
+                  "trying",
+                  "rejected",
+                ]),
+                Schema.Null,
+              ]),
+            ),
+            unlockDomain: Schema.optional(
+              Schema.Union([
+                Schema.Literals([
+                  "needed",
+                  "ok",
+                  "pending",
+                  "trying",
+                  "unknown",
+                ]),
+                Schema.Null,
+              ]),
+            ),
+          }).pipe(
+            Schema.encodeKeys({
+              acceptFoa: "accept_foa",
+              approveTransfer: "approve_transfer",
+              canCancelTransfer: "can_cancel_transfer",
+              disablePrivacy: "disable_privacy",
+              enterAuthCode: "enter_auth_code",
+              unlockDomain: "unlock_domain",
+            }),
+          ),
+          Schema.Null,
+        ]),
+      ),
+      updatedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(
+      Schema.encodeKeys({
+        id: "id",
+        available: "available",
+        canRegister: "can_register",
+        createdAt: "created_at",
+        currentRegistrar: "current_registrar",
+        expiresAt: "expires_at",
+        locked: "locked",
+        registrantContact: "registrant_contact",
+        registryStatuses: "registry_statuses",
+        supportedTld: "supported_tld",
+        transferIn: "transfer_in",
+        updatedAt: "updated_at",
+      }),
+    ),
+  ),
+}) as unknown as Schema.Schema<ListDomainsResponse>;
+
+export type ListDomainsError = DefaultErrors;
+
+export const listDomains: API.PaginatedOperationMethod<
+  ListDomainsRequest,
+  ListDomainsResponse,
+  ListDomainsError,
+  Credentials | HttpClient.HttpClient
+> & {
+  pages: (
+    input: ListDomainsRequest,
+  ) => stream.Stream<
+    ListDomainsResponse,
+    ListDomainsError,
+    Credentials | HttpClient.HttpClient
+  >;
+  items: (input: ListDomainsRequest) => stream.Stream<
+    {
+      id?: string | null;
+      available?: boolean | null;
+      canRegister?: boolean | null;
+      createdAt?: string | null;
+      currentRegistrar?: string | null;
+      expiresAt?: string | null;
+      locked?: boolean | null;
+      registrantContact?: {
+        address: string;
+        city: string;
+        country: string | null;
+        firstName: string | null;
+        lastName: string | null;
+        organization: string;
+        phone: string | null;
+        state: string;
+        zip: string | null;
+        id?: string | null;
+        address2?: string | null;
+        email?: string | null;
+        fax?: string | null;
+      } | null;
+      registryStatuses?: string | null;
+      supportedTld?: boolean | null;
+      transferIn?: {
+        acceptFoa?: "needed" | "ok" | null;
+        approveTransfer?:
+          | "needed"
+          | "ok"
+          | "pending"
+          | "trying"
+          | "rejected"
+          | "unknown"
+          | null;
+        canCancelTransfer?: boolean | null;
+        disablePrivacy?: "needed" | "ok" | "unknown" | null;
+        enterAuthCode?:
+          | "needed"
+          | "ok"
+          | "pending"
+          | "trying"
+          | "rejected"
+          | null;
+        unlockDomain?:
+          | "needed"
+          | "ok"
+          | "pending"
+          | "trying"
+          | "unknown"
+          | null;
+      } | null;
+      updatedAt?: string | null;
+    },
+    ListDomainsError,
+    Credentials | HttpClient.HttpClient
+  >;
+} = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
+  input: ListDomainsRequest,
+  output: ListDomainsResponse,
+  errors: [],
+  pagination: {
+    mode: "single",
+    items: "result",
+  } as const,
+}));
+
+export interface PutDomainRequest {
+  domainName: string;
+  /** Path param: Identifier */
+  accountId: string;
+  /** Body param: Auto-renew controls whether subscription is automatically renewed upon domain expiration. */
+  autoRenew?: boolean;
+  /** Body param: Shows whether a registrar lock is in place for a domain. */
+  locked?: boolean;
+  /** Body param: Privacy option controls redacting WHOIS information. */
+  privacy?: boolean;
+}
+
+export const PutDomainRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  domainName: Schema.String.pipe(T.HttpPath("domainName")),
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  autoRenew: Schema.optional(Schema.Boolean),
+  locked: Schema.optional(Schema.Boolean),
+  privacy: Schema.optional(Schema.Boolean),
+}).pipe(
+  Schema.encodeKeys({
+    autoRenew: "auto_renew",
+    locked: "locked",
+    privacy: "privacy",
+  }),
+  T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/registrar/domains/{domainName}",
+  }),
+) as unknown as Schema.Schema<PutDomainRequest>;
+
+export type PutDomainResponse = unknown;
+
+export const PutDomainResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<PutDomainResponse>;
+
+export type PutDomainError = DefaultErrors;
+
+export const putDomain: API.OperationMethod<
+  PutDomainRequest,
+  PutDomainResponse,
+  PutDomainError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: PutDomainRequest,
+  output: PutDomainResponse,
+  errors: [],
+}));

package/src/services/request-tracers.ts

@@ -0,0 +1,161 @@
+/**
+ * Cloudflare REQUEST-TRACERS API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service request-tracers
+ */
+
+import * as Schema from "effect/Schema";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import * as API from "../client/api.ts";
+import * as T from "../traits.ts";
+import type { Credentials } from "../credentials.ts";
+import { type DefaultErrors } from "../errors.ts";
+import { SensitiveString } from "../sensitive.ts";
+
+// =============================================================================
+// Trace
+// =============================================================================
+
+export interface CreateTraceRequest {
+  /** Path param: Identifier. */
+  accountId: string;
+  /** Body param: HTTP Method of tracing request */
+  method: string;
+  /** Body param: URL to which perform tracing request */
+  url: string;
+  /** Body param: */
+  body?: { base64?: string; json?: unknown; plainText?: string };
+  /** Body param: Additional request parameters */
+  context?: {
+    botScore?: number;
+    geoloc?: {
+      city?: string;
+      continent?: string;
+      isEuCountry?: boolean;
+      isoCode?: string;
+      latitude?: number;
+      longitude?: number;
+      postalCode?: string;
+      regionCode?: string;
+      subdivision_2IsoCode?: string;
+      timezone?: string;
+    };
+    skipChallenge?: boolean;
+    threatScore?: number;
+  };
+  /** Body param: Cookies added to tracing request */
+  cookies?: Record<string, unknown>;
+  /** Body param: Headers added to tracing request */
+  headers?: Record<string, unknown>;
+  /** Body param: HTTP Protocol of tracing request */
+  protocol?: string;
+  /** Body param: Skip sending the request to the Origin server after all rules evaluation */
+  skipResponse?: boolean;
+}
+
+export const CreateTraceRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  method: Schema.String,
+  url: Schema.String,
+  body: Schema.optional(
+    Schema.Struct({
+      base64: Schema.optional(Schema.String),
+      json: Schema.optional(Schema.Unknown),
+      plainText: Schema.optional(SensitiveString),
+    }).pipe(
+      Schema.encodeKeys({
+        base64: "base64",
+        json: "json",
+        plainText: "plain_text",
+      }),
+    ),
+  ).pipe(T.HttpBody()),
+  context: Schema.optional(
+    Schema.Struct({
+      botScore: Schema.optional(Schema.Number),
+      geoloc: Schema.optional(
+        Schema.Struct({
+          city: Schema.optional(Schema.String),
+          continent: Schema.optional(Schema.String),
+          isEuCountry: Schema.optional(Schema.Boolean),
+          isoCode: Schema.optional(Schema.String),
+          latitude: Schema.optional(Schema.Number),
+          longitude: Schema.optional(Schema.Number),
+          postalCode: Schema.optional(Schema.String),
+          regionCode: Schema.optional(Schema.String),
+          subdivision_2IsoCode: Schema.optional(Schema.String),
+          timezone: Schema.optional(Schema.String),
+        }).pipe(
+          Schema.encodeKeys({
+            city: "city",
+            continent: "continent",
+            isEuCountry: "is_eu_country",
+            isoCode: "iso_code",
+            latitude: "latitude",
+            longitude: "longitude",
+            postalCode: "postal_code",
+            regionCode: "region_code",
+            subdivision_2IsoCode: "subdivision_2_iso_code",
+            timezone: "timezone",
+          }),
+        ),
+      ),
+      skipChallenge: Schema.optional(Schema.Boolean),
+      threatScore: Schema.optional(Schema.Number),
+    }).pipe(
+      Schema.encodeKeys({
+        botScore: "bot_score",
+        geoloc: "geoloc",
+        skipChallenge: "skip_challenge",
+        threatScore: "threat_score",
+      }),
+    ),
+  ),
+  cookies: Schema.optional(Schema.Struct({})),
+  headers: Schema.optional(Schema.Struct({})),
+  protocol: Schema.optional(Schema.String),
+  skipResponse: Schema.optional(Schema.Boolean),
+}).pipe(
+  Schema.encodeKeys({
+    method: "method",
+    url: "url",
+    context: "context",
+    cookies: "cookies",
+    headers: "headers",
+    protocol: "protocol",
+    skipResponse: "skip_response",
+  }),
+  T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/request-tracer/trace",
+  }),
+) as unknown as Schema.Schema<CreateTraceRequest>;
+
+export interface CreateTraceResponse {
+  /** HTTP Status code of zone response */
+  statusCode?: number | null;
+  trace?: unknown | null;
+}
+
+export const CreateTraceResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  statusCode: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+  trace: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+})
+  .pipe(Schema.encodeKeys({ statusCode: "status_code", trace: "trace" }))
+  .pipe(
+    T.ResponsePath("result"),
+  ) as unknown as Schema.Schema<CreateTraceResponse>;
+
+export type CreateTraceError = DefaultErrors;
+
+export const createTrace: API.OperationMethod<
+  CreateTraceRequest,
+  CreateTraceResponse,
+  CreateTraceError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: CreateTraceRequest,
+  output: CreateTraceResponse,
+  errors: [],
+}));