@distilled.cloud/cloudflare 0.0.0 → 0.2.0-alpha

package/src/services/registrar.ts

@@ -0,0 +1,295 @@
+/**
+ * Cloudflare REGISTRAR API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service registrar
+ */
+
+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";
+import type { Credentials } from "../credentials";
+import { type DefaultErrors } from "../errors";
+
+// =============================================================================
+// 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 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 type ListDomainsResponse = {
+  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.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.OperationMethod<
+  ListDomainsRequest,
+  ListDomainsResponse,
+  ListDomainsError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: ListDomainsRequest,
+  output: ListDomainsResponse,
+  errors: [],
+}));
+
+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 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,158 @@
+/**
+ * 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";
+import type { Credentials } from "../credentials";
+import { type DefaultErrors } from "../errors";
+
+// =============================================================================
+// 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(Schema.String),
+    }).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" }),
+) 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: [],
+}));