6.0.6

.gitignore

@@ -15,8 +15,6 @@ node_modules/
 
 # builds
 dist/
-dist_web/
+dist_*/
-dist_serve/
-dist_ts_web/
 
 # custom

.gitlab-ci.yml

@@ -1,126 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-    - .npmci_cache/
-  key: '$CI_BUILD_STAGE'
-
-stages:
-  - security
-  - test
-  - release
-  - metadata
-
-# ====================
-# security stage
-# ====================
-mirror:
-  stage: security
-  script:
-    - npmci git mirror
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-snyk:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:snyk
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --ignore-scripts
-    - npmci command snyk test
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - lossless
-    - docker
-    - priv
-
-testBuild:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-release:
-  stage: release
-  script:
-    - npmci node install stable
-    - npmci npm publish
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  script:
-    - npmci command npm install -g tslint typescript
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install lts
-    - npmci command npm install -g @gitzone/tsdoc
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command tsdoc
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true

.vscode/launch.json

@@ -2,28 +2,10 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "current file",
+      "command": "npm test",
-      "type": "node",
+      "name": "Run npm test",
       "request": "launch",
-      "args": [
+      "type": "node-terminal"
-        "${relativeFile}"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
-    },
-    {
-      "name": "test.ts",
-      "type": "node",
-      "request": "launch",
-      "args": [
-        "test/test.ts"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
     }
   ]
 }

.vscode/settings.json

@@ -15,7 +15,7 @@
             "properties": {
               "projectType": {
                 "type": "string",
-                "enum": ["website", "element", "service", "npm"]
+                "enum": ["website", "element", "service", "npm", "wcc"]
               }
             }
           }

changelog.md

@@ -0,0 +1,219 @@
+# Changelog
+
+## 2025-03-19 - 6.0.6 - fix(core)
+Improve logging consistency, record update functionality, and API error handling in Cloudflare modules
+
+- Replaced raw console.log calls with logger.log for unified logging across modules
+- Implemented and documented the updateRecord method with proper parameters in CloudflareAccount
+- Enhanced API request error handling and added detailed documentation in request methods
+- Refactored CloudflareWorker and WorkerManager methods to improve clarity and maintainability
+- Updated ZoneManager and CloudflareZone to improve error reporting and zone manipulation
+
+## 2024-06-16 - 6.0.5 – no significant changes
+_No significant changes in this release._
+
+## 2024-06-16 - 6.0.4 – miscellaneous
+Several improvements and fixes:
+- fix(start supporting workers again): update
+- update license info
+- update readme
+- switch to official cloudflare api client while keeping class based approach
+
+## 2024-06-15 - 6.0.3 – core
+- fix(core): update
+
+## 2023-06-13 - 6.0.2 – core
+- fix(core): update
+
+## 2023-06-13 - 6.0.1 – core
+- fix(core): update
+
+## 2022-09-27 - 6.0.0 – core
+- fix(core): update
+
+## 2022-09-27 - 5.0.10 – core
+- BREAKING CHANGE(core): switch to esm
+
+## 2022-09-27 - 5.0.9 – core
+- fix(core): update
+
+## 2021-01-22 - 5.0.8 – core
+- fix(core): update
+
+## 2021-01-22 - 5.0.7 – core
+- fix(core): update
+
+## 2021-01-22 - 5.0.6 – core
+- fix(core): update
+
+## 2020-06-10 - 5.0.5 – core
+- fix(core): update
+
+## 2020-06-10 - 5.0.4 – core
+- fix(core): update
+
+## 2020-02-28 - 5.0.3 – core
+- fix(core): update
+
+## 2020-02-28 - 5.0.2 – core
+- fix(core): update
+
+## 2020-02-28 - 5.0.1 – core
+- fix(core): update
+
+## 2020-02-28 - 5.0.0 – core
+- fix(core): update
+
+## 2020-02-19 - 4.0.5 – account
+- BREAKING CHANGE(account): authorization now uses the new Account API
+
+## 2020-02-19 - 4.0.4 – core
+- fix(core): update
+
+## 2020-02-19 - 4.0.3 – core
+- fix(core): update
+
+## 2020-02-10 - 4.0.2 – core
+- fix(core): update
+
+## 2020-02-10 - 4.0.1 – core
+- fix(core): update
+
+## 2020-02-10 - 4.0.0 – core
+- fix(core): update
+
+## 2020-02-09 - 3.0.7 – API
+- BREAKING CHANGE(API): move to .convenience property
+
+## 2020-02-09 - 3.0.6 – core
+- fix(core): update
+
+## 2020-02-09 - 3.0.5 – core
+- fix(core): update
+
+## 2019-07-19 - 3.0.4 – core
+- fix(core): update
+
+## 2019-07-18 - 3.0.3 – core
+- fix(core): update
+
+## 2019-07-18 - 3.0.2 – core
+- fix(core): update
+
+## 2019-07-18 - 3.0.1 – core
+- fix(core): update
+
+## 2019-07-18 - 3.0.0 – core
+- fix(core): update
+
+## 2019-07-18 - 2.0.1 – core
+- fix(core): update
+
+## 2019-07-18 - 2.0.0 – core
+- fix(core): update
+
+## 2019-07-18 - 2.0.2 – no significant changes
+_No significant changes in this release._
+
+## 2018-08-13 - 1.0.5 – scope
+- BREAKING CHANGE(scope): change scope, tools and package name
+
+## 2017-06-11 - 1.0.4 – misc
+- now using tsclass
+
+## 2017-06-09 - 1.0.3 – misc
+- update dependencies
+
+## 2017-06-05 - 1.0.2 – misc
+- now supports purging of assets
+- improve test
+
+## 2017-06-04 - 1.0.1 – misc
+- add npmextra.json
+
+## 2017-06-04 - 1.0.0 – misc
+- add type TRecord, update ci
+
+## 2017-06-04 - 0.0.20 – no significant changes
+_No significant changes in this release._
+
+## 2017-06-04 - 0.0.19 – misc
+- go async/await
+- update brand link
+
+## 2017-02-12 - 0.0.18 – misc
+- update README
+
+## 2017-01-29 - 0.0.17 – misc
+- update README
+
+## 2017-01-29 - 0.0.16 – misc
+- fix tests to run in parallel
+
+## 2017-01-29 - 0.0.15 – misc
+- fixed bad request retry
+
+## 2017-01-29 - 0.0.14 – misc
+- fix testing timeouts
+
+## 2017-01-29 - 0.0.13 – misc
+- added random retry times
+
+## 2017-01-29 - 0.0.12 – misc
+- update to new ci
+
+## 2017-01-29 - 0.0.11 – misc
+- now using smartrequest
+
+## 2017-01-22 - 0.0.10 – misc
+- now reacting to rate limiting
+
+## 2016-07-31 - 0.0.9 – misc
+- update dependencies
+
+## 2016-06-22 - 0.0.8 to 0.0.7 – no significant changes
+_No significant changes in these releases._
+
+## 2016-06-22 - 0.0.6 – misc
+- updated dependencies
+
+## 2016-06-21 - 0.0.5 – misc
+- fix stages
+
+## 2016-06-21 - 0.0.4 – misc
+- fix stages
+
+## 2016-06-21 - 0.0.3 – misc
+Multiple improvements:
+- now works for most things
+- update to latest dependencies
+- update .gitlab.yml
+- update
+- add .gitlab-ci.yml
+
+## 2016-05-25 - 0.0.2 – misc
+Several changes:
+- improve domain string handling
+- update .getRecord
+- improve .createRecord
+- implemented .createRecord
+- compile
+- add functionality
+- start with tests
+- improved request method of cflare class
+
+## 2016-04-27 - 0.0.1 – misc
+- now returning promises
+- add lossless badge
+
+## 2016-04-27 - 0.0.0 – misc
+- added travis and improved README
+
+## 2016-04-10 - 0.0.0 – misc
+- add package.json and README
+
+## 2016-04-10 - unknown – misc
+- Initial commit
+
+---
+_Note: Versions that only contained version bump commits or minor housekeeping (6.0.5; 2.0.2; 0.0.20; 0.0.8 to 0.0.7) have been omitted from detailed entries and are summarized above._

license

@@ -1,6 +1,4 @@
-The MIT License (MIT)
+Copyright (c) 2014 Task Venture Capital GmbH (hello@task.vc)
-
-Copyright (c) 2016 Lossless GmbH
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

npmextra.json

@@ -9,9 +9,21 @@
       "githost": "gitlab.com",
       "gitscope": "mojoio",
       "gitrepo": "cloudflare",
-      "shortDescription": "easy cloudflare management",
+      "description": "A TypeScript client for managing Cloudflare accounts, zones, DNS records, and workers with ease.",
-      "npmPackagename": "@mojoio/cloudflare",
+      "npmPackagename": "@apiclient.xyz/cloudflare",
-      "license": "MIT"
+      "license": "MIT",
+      "keywords": [
+        "Cloudflare",
+        "DNS management",
+        "zone management",
+        "worker management",
+        "TypeScript",
+        "API client",
+        "cloud infrastructure",
+        "automated DNS",
+        "CDN management",
+        "open source"
+      ]
     }
   }
 }

package.json

@@ -1,21 +1,32 @@
 {
-  "name": "@mojoio/cloudflare",
+  "name": "@apiclient.xyz/cloudflare",
-  "version": "3.0.7",
+  "version": "6.0.6",
   "private": false,
-  "description": "easy cloudflare management",
+  "description": "A TypeScript client for managing Cloudflare accounts, zones, DNS records, and workers with ease.",
-  "main": "dist/index.js",
+  "main": "dist_ts/index.js",
-  "typings": "dist/index.d.ts",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild)"
+    "build": "(tsbuild --web --allowimplicitany)",
+    "buildDocs": "tsdoc",
+    "updateOpenapi": "openapi-typescript https://raw.githubusercontent.com/cloudflare/api-schemas/main/openapi.yaml --output ts/openapi.spec.ts"
   },
   "repository": {
     "type": "git",
     "url": "git+https://gitlab.com/pushrocks/cflare.git"
   },
   "keywords": [
-    "Push.Rocks",
+    "Cloudflare",
-    "cloudflare"
+    "DNS management",
+    "zone management",
+    "worker management",
+    "TypeScript",
+    "API client",
+    "cloud infrastructure",
+    "automated DNS",
+    "CDN management",
+    "open source"
   ],
   "author": "Lossless GmbH",
   "license": "MIT",
@@ -24,32 +35,36 @@
   },
   "homepage": "https://gitlab.com/pushrocks/cflare#readme",
   "dependencies": {
-    "@pushrocks/smartdelay": "^2.0.6",
+    "@push.rocks/smartdelay": "^3.0.1",
-    "@pushrocks/smartlog": "^2.0.21",
+    "@push.rocks/smartlog": "^3.0.2",
-    "@pushrocks/smartpromise": "^3.0.6",
+    "@push.rocks/smartpromise": "^4.0.2",
-    "@pushrocks/smartrequest": "^1.1.47",
+    "@push.rocks/smartrequest": "^2.0.15",
-    "@pushrocks/smartstring": "^3.0.18",
+    "@push.rocks/smartstring": "^4.0.5",
-    "@tsclass/tsclass": "^3.0.4"
+    "@tsclass/tsclass": "^4.0.58",
+    "cloudflare": "^3.2.0"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.17",
+    "@git.zone/tsbuild": "^2.1.66",
-    "@gitzone/tsrun": "^1.2.8",
+    "@git.zone/tsrun": "^1.2.42",
-    "@gitzone/tstest": "^1.0.28",
+    "@git.zone/tstest": "^1.0.74",
-    "@pushrocks/qenv": "^4.0.6",
+    "@push.rocks/qenv": "^6.0.5",
-    "@pushrocks/tapbundle": "^3.2.0",
+    "@push.rocks/tapbundle": "^5.0.4",
-    "@types/node": "^13.7.0",
+    "@types/node": "^20.3.1",
-    "tslint": "^6.0.0",
+    "openapi-typescript": "^6.7.6"
-    "tslint-config-prettier": "^1.18.0"
   },
   "files": [
     "ts/**/*",
     "ts_web/**/*",
     "dist/**/*",
-    "dist_web/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
     "dist_ts_web/**/*",
     "assets/**/*",
     "cli.js",
     "npmextra.json",
     "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
   ]
 }

qenv.yml

@@ -1,3 +1,2 @@
 required:
-  - CF_EMAIL
   - CF_KEY

readme.hints.md

@@ -0,0 +1 @@
+- unofficial TypeScript cloudflare api client coming with a lot of convenience.

readme.md

@@ -1,49 +1,250 @@
-# @mojoio/cloudflare
+# @apiclient.xyz/cloudflare
 easy cloudflare management
 
-## Availabililty and Links
+## Install
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@mojoio/cloudflare)
+To install the `@apiclient.xyz/cloudflare` package, you can use npm. Simply run the following command:
-* [gitlab.com (source)](https://gitlab.com/mojoio/cloudflare)
-* [github.com (source mirror)](https://github.com/mojoio/cloudflare)
-* [docs (typedoc)](https://mojoio.gitlab.io/cloudflare/)
 
-## Status for master
+```bash
-[![pipeline status](https://gitlab.com/mojoio/cloudflare/badges/master/pipeline.svg)](https://gitlab.com/mojoio/cloudflare/commits/master)
+npm install @apiclient.xyz/cloudflare
-[![coverage report](https://gitlab.com/mojoio/cloudflare/badges/master/coverage.svg)](https://gitlab.com/mojoio/cloudflare/commits/master)
+```
-[![npm downloads per month](https://img.shields.io/npm/dm/@mojoio/cloudflare.svg)](https://www.npmjs.com/package/@mojoio/cloudflare)
+
-[![Known Vulnerabilities](https://snyk.io/test/npm/@mojoio/cloudflare/badge.svg)](https://snyk.io/test/npm/@mojoio/cloudflare)
+Make sure to include it in your `dependencies` in `package.json`.
-[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
 
 ## Usage
 
-Use TypeScript for best in class instellisense.
+### Initial Setup
 
-```javascript
+First, let's start by importing the required modules and setting up an instance of `CloudflareAccount` with your API token. This instance will be used to interact with the Cloudflare API.
-import * as cflare from '@mojoio/cloudflare'
 
-const myCflareAccount = new cflare.CflareAccount()
+```typescript
-testCflareAccount.auth({
+import * as cflare from '@apiclient.xyz/cloudflare';
-    email: 'someuser@example.com',
-    key: 'someLongApiKey'
-})
 
-const myAsyncCflareManagement = async () => {
+// Initialize Cloudflare Account
-    // get things
+const myCflareAccount = new cflare.CloudflareAccount('mySuperAwesomeAccountToken');
-    const myZones = await myCflareAccount.listZones() // zones are fully typed
-    const myIdForADomain = await myCflareAccount.getZoneId('example.com') // type number
-    const myRecordsForADomain = await myCflareAccount.listRecords('example.com') // records are fully typed
-}
 ```
 
-## Contribution
+### Managing Zones
 
-We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+#### List All Zones
 
-For further information read the linked docs at the top of this readme.
+To list all zones in your Cloudflare account, you can use the `listZones` method:
 
-> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+```typescript
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+const listAllZones = async () => {
+  const myZones = await myCflareAccount.convenience.listZones();
+  console.log(myZones);
+};
+```
 
-[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)
+#### Get Zone ID
+
+To get the ID of a specific zone (domain), use the `getZoneId` method:
+
+```typescript
+const getZoneId = async (domainName: string) => {
+  try {
+    const zoneId = await myCflareAccount.convenience.getZoneId(domainName);
+    console.log(`Zone ID for ${domainName}:`, zoneId);
+  } catch (error) {
+    console.error('Error getting zone ID:', error);
+  }
+};
+```
+
+#### Purge Cache for a Zone
+
+To purge all cache for a specific zone:
+
+```typescript
+const purgeZoneCache = async (domainName: string) => {
+  await myCflareAccount.convenience.purgeZone(domainName);
+  console.log(`Purged cache for ${domainName}`);
+};
+```
+
+### Managing DNS Records
+
+#### List DNS Records
+
+To list all DNS records for a specific zone:
+
+```typescript
+const listDnsRecords = async (domainName: string) => {
+  try {
+    const records = await myCflareAccount.convenience.listRecords(domainName);
+    console.log(`DNS Records for ${domainName}:`, records);
+  } catch (error) {
+    console.error('Error listing DNS records:', error);
+  }
+};
+```
+
+#### Get a Specific Record
+
+To get a specific DNS record by type (e.g., A, AAAA, CNAME, etc.):
+
+```typescript
+const getDnsRecord = async (domainName: string, recordType: string) => {
+  try {
+    const record = await myCflareAccount.convenience.getRecord(domainName, recordType);
+    console.log(`DNS Record (${recordType}) for ${domainName}:`, record);
+  } catch (error) {
+    console.error('Error getting DNS record:', error);
+  }
+};
+```
+
+#### Create a DNS Record
+
+To create a new DNS record:
+
+```typescript
+const createDnsRecord = async (domainName: string, recordType: string, content: string) => {
+  try {
+    const response = await myCflareAccount.convenience.createRecord(domainName, recordType, content, 120);
+    console.log(`Created DNS record (${recordType}) for ${domainName}:`, response);
+  } catch (error) {
+    console.error('Error creating DNS record:', error);
+  }
+};
+```
+
+#### Remove a DNS Record
+
+To remove a DNS record:
+
+```typescript
+const removeDnsRecord = async (domainName: string, recordType: string) => {
+  try {
+    await myCflareAccount.convenience.removeRecord(domainName, recordType);
+    console.log(`Removed DNS record (${recordType}) for ${domainName}`);
+  } catch (error) {
+    console.error('Error removing DNS record:', error);
+  }
+};
+```
+
+#### Clean a DNS Record
+
+To clean (remove) all records of a specific type for a domain:
+
+```typescript
+const cleanDnsRecord = async (domainName: string, recordType: string) => {
+  try {
+    await myCflareAccount.convenience.cleanRecord(domainName, recordType);
+    console.log(`Cleaned DNS records (${recordType}) for ${domainName}`);
+  } catch (error) {
+    console.error('Error cleaning DNS record:', error);
+  }
+};
+```
+
+### Managing Workers
+
+#### Create a Worker
+
+To create a new Cloudflare Worker:
+
+```typescript
+const createWorker = async (workerName: string, workerScript: string) => {
+  try {
+    const worker = await myCflareAccount.workerManager.createWorker(workerName, workerScript);
+    console.log(`Created Worker (${workerName}):`, worker);
+  } catch (error) {
+    console.error('Error creating Worker:', error);
+  }
+};
+```
+
+#### List Workers
+
+To list all workers in your Cloudflare account:
+
+```typescript
+const listWorkers = async () => {
+  try {
+    const workers = await myCflareAccount.workerManager.listWorkers();
+    console.log('Workers:', workers);
+  } catch (error) {
+    console.error('Error listing workers:', error);
+  }
+};
+```
+
+#### Set Worker Routes
+
+To set routes for a Cloudflare Worker:
+
+```typescript
+import { CloudflareWorker } from '@apiclient.xyz/cloudflare';
+
+const setWorkerRoutes = async (worker: CloudflareWorker, routes: Array<{ zoneName: string, pattern: string }>) => {
+  try {
+    await worker.setRoutes(routes);
+    console.log('Routes set successfully for Worker:', worker.id);
+  } catch (error) {
+    console.error('Error setting routes for Worker:', error);
+  }
+};
+```
+
+#### Sample Complete Workflow
+
+Below is a sample workflow that includes all the above features:
+
+```typescript
+import * as cflare from '@apiclient.xyz/cloudflare';
+
+const myCflareAccount = new cflare.CloudflareAccount('mySuperAwesomeAccountToken');
+
+const manageCloudflare = async () => {
+  try {
+    // List all zones
+    const myZones = await myCflareAccount.convenience.listZones();
+    console.log('Zones:', myZones);
+
+    // Get Zone ID for a specific domain
+    const myZoneId = await myCflareAccount.convenience.getZoneId('example.com');
+    console.log('Zone ID:', myZoneId);
+
+    // Purge cache for a zone
+    await myCflareAccount.convenience.purgeZone('example.com');
+    console.log('Cache purged for example.com');
+
+    // List DNS records for a domain
+    const myRecords = await myCflareAccount.convenience.listRecords('example.com');
+    console.log('DNS Records:', myRecords);
+
+    // Get a specific DNS record
+    const myRecord = await myCflareAccount.convenience.getRecord('sub.example.com', 'A');
+    console.log('Specific DNS Record:', myRecord);
+
+    // Create a DNS record
+    const createResponse = await myCflareAccount.convenience.createRecord('sub.example.com', 'A', '127.0.0.1');
+    console.log('Created DNS Record:', createResponse);
+
+    // Clean DNS records
+    await myCflareAccount.convenience.cleanRecord('sub.example.com', 'A');
+    console.log('Cleaned DNS Records for sub.example.com');
+
+    // Create a Cloudflare Worker
+    const myWorker = await myCflareAccount.workerManager.createWorker('myWorker', `addEventListener('fetch', event => { event.respondWith(fetch(event.request)) })`);
+    console.log('Created Worker:', myWorker);
+
+    // Set routes for the Worker
+    await myWorker.setRoutes([{ zoneName: 'example.com', pattern: 'https://*example.com/*' }]);
+    console.log('Routes set for Worker');
+
+    // List all Workers
+    const workers = await myCflareAccount.workerManager.listWorkers();
+    console.log('Workers:', workers);
+  } catch (error) {
+    console.error('Error managing Cloudflare:', error);
+  }
+};
+
+manageCloudflare();
+```
+
+This complete guide covers initialization, managing Cloudflare zones, DNS records, and Cloudflare Workers comprehensively using TypeScript for enhanced type safety and intellisense. Always ensure to keep your API keys secure and avoid hardcoding them directly in your scripts.
+undefined

test/test.ts

@@ -1,9 +1,9 @@
 // tslint:disable-next-line: no-implicit-dependencies
-import { expect, tap } from '@pushrocks/tapbundle';
+import { expect, tap } from '@push.rocks/tapbundle';
 // tslint:disable-next-line: no-implicit-dependencies
-import { Qenv } from '@pushrocks/qenv';
+import { Qenv } from '@push.rocks/qenv';
 
-import cloudflare = require('../ts/index');
+import * as cloudflare from '../ts/index.js';
 
 const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit');
 
@@ -11,61 +11,74 @@ const randomPrefix = Math.floor(Math.random() * 2000);
 let testCloudflareAccount: cloudflare.CloudflareAccount;
 
 tap.test('should create a valid instance of CloudflareAccount', async () => {
-  testCloudflareAccount = new cloudflare.CloudflareAccount({
+  testCloudflareAccount = new cloudflare.CloudflareAccount(await testQenv.getEnvVarOnDemand('CF_KEY'));
-    email: testQenv.getEnvVarOnDemand('CF_EMAIL'),
-    key: testQenv.getEnvVarOnDemand('CF_KEY')
-  });
 });
 
-tap.test('.listZones() -> should display an entire account', async tools => {
+tap.test('should preselect an account', async () => {
+  await testCloudflareAccount.preselectAccountByName('Sandbox Account');
+})
+
+tap.test('.listZones() -> should display an entire account', async (tools) => {
   tools.timeout(600000);
-  const result = await testCloudflareAccount.listZones();
+  const result = await testCloudflareAccount.convenience.listZones();
   console.log(result);
+  // await tools.delayFor(10000);
 });
 
 tap.test(
   '.getZoneId(domainName) -> should get an Cloudflare Id for a domain string',
-  async tools => {
+  async (tools) => {
     tools.timeout(600000);
-    await testCloudflareAccount.getZoneId('bleu.de');
+    const id = await testCloudflareAccount.convenience.getZoneId('bleu.de');
+    console.log(`The account id for bleu.de is: ${id}`);
   }
 );
 
 tap.test(
   '.listRecords(domainName) -> should list all records for a specific Domain Name',
-  async tools => {
+  async (tools) => {
     tools.timeout(600000);
-    await testCloudflareAccount.listRecords('bleu.de').then(async responseArg => {
+    await testCloudflareAccount.convenience.listRecords('bleu.de').then(async (responseArg) => {
       console.log(responseArg);
     });
   }
 );
 
-tap.test('should create a valid record for a subdomain', async tools => {
+tap.test('should create a valid record for a subdomain', async (tools) => {
   tools.timeout(600000);
-  await testCloudflareAccount.createRecord(`${randomPrefix}subdomain.bleu.de`, 'A', '127.0.0.1');
+  await testCloudflareAccount.convenience.createRecord(
+    `${randomPrefix}subdomain.bleu.de`,
+    'A',
+    '127.0.0.1',
+    120
+  );
 });
 
-tap.test('should get a record from Cloudflare', async tools => {
+tap.test('should get a record from Cloudflare', async (tools) => {
   tools.timeout(600000);
-  await testCloudflareAccount
+  await testCloudflareAccount.convenience
     .getRecord(`${randomPrefix}subdomain.bleu.de`, 'A')
-    .then(responseArg => {
+    .then((responseArg) => {
       console.log(responseArg);
     });
 });
 
-tap.test('should remove a subdomain record from Cloudflare', async tools => {
+tap.test('should remove a subdomain record from Cloudflare', async (tools) => {
   tools.timeout(600000);
-  await testCloudflareAccount
+  await testCloudflareAccount.convenience
     .removeRecord(`${randomPrefix}subdomain.bleu.de`, 'A')
-    .then(async responseArg => {
+    .then(async (responseArg) => {
       console.log(responseArg);
     });
 });
 
 tap.test('.purge(some.domain) -> should purge everything', async () => {
-  await testCloudflareAccount.purgeZone('bleu.de');
+  await testCloudflareAccount.convenience.purgeZone('bleu.de');
+});
+
+tap.test('should list workers', async () => {
+  const workerArray = await testCloudflareAccount.workerManager.listWorkerScripts();
+  console.log(workerArray);
 });
 
 // WORKERS
@@ -77,14 +90,14 @@ tap.test('should create a worker', async () => {
   await worker.setRoutes([
     {
       zoneName: 'bleu.de',
-      pattern: 'https://*bleu.de/hello'
+      pattern: 'https://*bleu.de/hello',
-    }
+    },
   ]);
   console.log(worker);
 });
 
-tap.test('should get workers', async () => {
+tap.test('should get workers again', async () => {
-  const workerArray = await testCloudflareAccount.workerManager.listWorkers();
+  const workerArray = await testCloudflareAccount.workerManager.listWorkerScripts();
   console.log(workerArray);
 });
 

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@apiclient.xyz/cloudflare',
+  version: '6.0.6',
+  description: 'A TypeScript client for managing Cloudflare accounts, zones, DNS records, and workers with ease.'
+}

ts/cloudflare.classes.account.ts

@@ -1,228 +1,267 @@
-import plugins = require('./cloudflare.plugins');
+import * as plugins from './cloudflare.plugins.js';
-import * as interfaces from './interfaces';
+import { logger } from './cloudflare.logger.js';
+import * as interfaces from './interfaces/index.js';
 
 // interfaces
-import { WorkerManager } from './cloudflare.classes.workermanager';
+import { WorkerManager } from './cloudflare.classes.workermanager.js';
-import { ZoneManager } from './cloudflare.classes.zonemanager';
+import { ZoneManager } from './cloudflare.classes.zonemanager.js';
 
 export class CloudflareAccount {
-  private authEmail: string;
+  private authToken: string;
-  private authKey: string;
+  public preselectedAccountId: string;
-  private accountIdentifier: string;
 
   public workerManager = new WorkerManager(this);
   public zoneManager = new ZoneManager(this);
 
+  public apiAccount: plugins.cloudflare.Cloudflare;
+
   /**
    * constructor sets auth information on the CloudflareAccountInstance
    * @param optionsArg
    */
-  constructor(optionsArg: { email: string; key: string }) {
+  constructor(authTokenArg: string) {
-    this.authEmail = optionsArg.email;
+    this.authToken = authTokenArg;
-    this.authKey = optionsArg.key;
+    this.apiAccount = new plugins.cloudflare.Cloudflare({
-  }
+      apiToken: this.authToken,
-
-  public async getAccountIdentifier() {
-    if (!this.accountIdentifier) {
-      const route = `/accounts?page=1&per_page=20&direction=desc`;
-      const response: any = await this.request('GET', route);
-      this.accountIdentifier = response.result[0].id;
-      // console.log('Account identifier is: ' + this.accountIdentifier);
-    }
-    return this.accountIdentifier;
-  }
-
-  /**
-   * gets a zone id of a domain from cloudflare
-   * @param domainName
-   */
-  public async getZoneId(domainName: string) {
-    const domain = new plugins.smartstring.Domain(domainName);
-    const zoneArray = await this.listZones(domain.zoneName);
-    const filteredResponse = zoneArray.filter(zoneArg => {
-      return zoneArg.name === domainName;
     });
-    if (filteredResponse.length >= 1) {
-      return filteredResponse[0].id;
-    } else {
-      plugins.smartlog.defaultLogger.log(
-        'error',
-        `the domain ${domainName} does not appear to be in this account!`
-      );
-      throw new Error(`the domain ${domainName} does not appear to be in this account!`);
-    }
   }
 
   /**
-   * gets a record
+   * Make a request to the Cloudflare API
-   * @param domainNameArg
+   * @param method HTTP method (GET, POST, PUT, DELETE)
-   * @param typeArg
+   * @param endpoint API endpoint path
+   * @param data Optional request body data
+   * @returns API response
    */
-  public async getRecord(
+  public async request<T = any>(
-    domainNameArg: string,
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE',
-    typeArg: plugins.tsclass.network.TDnsRecord
+    endpoint: string,
-  ): Promise<interfaces.ICflareRecord> {
+    data?: any
-    const domain = new plugins.smartstring.Domain(domainNameArg);
+  ): Promise<T> {
-    const recordArrayArg = await this.listRecords(domain.zoneName);
+    try {
-    const filteredResponse = recordArrayArg.filter(recordArg => {
+      const options: plugins.smartrequest.ISmartRequestOptions = {
-      return recordArg.type === typeArg && recordArg.name === domainNameArg;
+        method,
+        url: `https://api.cloudflare.com/client/v4${endpoint}`,
+        headers: {
+          'Authorization': `Bearer ${this.authToken}`,
+          'Content-Type': 'application/json',
+        },
+      };
+
+      if (data) {
+        options.json = data;
+      }
+
+      const response = await plugins.smartrequest.request(options);
+      return JSON.parse(response.body);
+    } catch (error) {
+      logger.log('error', `Cloudflare API request failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  public async preselectAccountByName(nameArg: string) {
+    const accounts = await this.convenience.listAccounts();
+    const account = accounts.find((accountArg) => {
+      return accountArg.name === nameArg;
     });
-    return filteredResponse[0];
+    if (account) {
-  }
+      this.preselectedAccountId = account.id;
-
-  public async createRecord(
-    domainNameArg: string,
-    typeArg: plugins.tsclass.network.TDnsRecord,
-    contentArg: string
-  ): Promise<any> {
-    const domain = new plugins.smartstring.Domain(domainNameArg);
-    const domainIdArg = await this.getZoneId(domain.zoneName);
-    const dataObject = {
-      name: domain.fullName,
-      type: typeArg,
-      content: contentArg
-    };
-    const response = await this.request(
-      'POST',
-      '/zones/' + domainIdArg + '/dns_records',
-      dataObject
-    );
-    return response;
-  }
-
-  /**
-   * removes a record from Cloudflare
-   * @param domainNameArg
-   * @param typeArg
-   */
-  public async removeRecord(
-    domainNameArg: string,
-    typeArg: plugins.tsclass.network.TDnsRecord
-  ): Promise<any> {
-    const domain = new plugins.smartstring.Domain(domainNameArg);
-    const cflareRecord = await this.getRecord(domain.fullName, typeArg);
-    if (cflareRecord) {
-      const requestRoute: string = `/zones/${cflareRecord.zone_id}/dns_records/${cflareRecord.id}`;
-      return await this.request('DELETE', requestRoute);
     } else {
-      throw new Error(`could not remove record for ${domainNameArg} with type ${typeArg}`);
+      throw new Error(`account with name ${nameArg} not found`);
     }
   }
 
-  /**
+  public convenience = {
-   * updates a record
+    /**
-   * @param domainNameArg
+     * listAccounts
-   * @param typeArg
+     */
-   * @param valueArg
+    listAccounts: async () => {
-   */
+      const accounts: plugins.ICloudflareTypes['Account'][] = [];
-  public updateRecord(domainNameArg: string, typeArg: string, valueArg) {
+      for await (const account of this.apiAccount.accounts.list()) {
-    // TODO: implement
+        accounts.push(account as interfaces.ICloudflareApiAccountObject);
-    const done = plugins.smartpromise.defer();
+      }
-    const domain = new plugins.smartstring.Domain(domainNameArg);
+      return accounts;
-    return done.promise;
+    },
-  }
+    /**
-
+     * gets a zone id of a domain from cloudflare
-  /**
+     * @param domainName
-   * list all records of a specified domain name
+     */
-   * @param domainNameArg - the domain name that you want to get the records from
+    getZoneId: async (domainName: string) => {
-   */
+      const domain = new plugins.smartstring.Domain(domainName);
-  public async listRecords(domainNameArg: string): Promise<interfaces.ICflareRecord[]> {
+      const zoneArray = await this.convenience.listZones(domain.zoneName);
-    const domain = new plugins.smartstring.Domain(domainNameArg);
+      const filteredResponse = zoneArray.filter((zoneArg) => {
-    const domainId = await this.getZoneId(domain.zoneName);
+        return zoneArg.name === domainName;
-    const responseArg: any = await this.request(
+      });
-      'GET',
+      if (filteredResponse.length >= 1) {
-      '/zones/' + domainId + '/dns_records?per_page=100'
+        return filteredResponse[0].id;
-    );
-    const result: interfaces.ICflareRecord[] = responseArg.result;
-    return result;
-  }
-
-  /**
-   * list all zones in the associated authenticated account
-   * @param domainName
-   */
-  public async listZones(domainName?: string): Promise<interfaces.ICflareZone[]> {
-    // TODO: handle pagination
-    let requestRoute = `/zones?per_page=50`;
-
-    // may be optionally filtered by domain name
-    if (domainName) {
-      requestRoute = `${requestRoute}&name=${domainName}`;
-    }
-
-    const response: any = await this.request('GET', requestRoute);
-    const result = response.result;
-    return result;
-  }
-
-  public async purgeZone(domainName: string) {
-    const domain = new plugins.smartstring.Domain(domainName);
-    const domainId = await this.getZoneId(domain.zoneName);
-    const requestUrl = `/zones/${domainId}/purge_cache`;
-    const payload = {
-      purge_everything: true
-    };
-    const respone = await this.request('DELETE', requestUrl, payload);
-  }
-
-  public request(
-    methodArg: string,
-    routeArg: string,
-    dataArg: any = {},
-    requestHeadersArg = {}
-  ): Promise<any> {
-    const done = plugins.smartpromise.defer();
-    const options: plugins.smartrequest.ISmartRequestOptions = {
-      method: methodArg,
-      headers: {
-        'Content-Type': 'application/json',
-        'X-Auth-Email': this.authEmail,
-        'X-Auth-Key': this.authKey,
-        'Content-Length': Buffer.byteLength(JSON.stringify(dataArg)),
-        ...requestHeadersArg
-      },
-      requestBody: dataArg
-    };
-
-    // console.log(options);
-
-    let retryCount = 0; // count the amount of retries
-
-    const makeRequest = async () => {
-      const response: any = await plugins.smartrequest.request(
-        `https://api.cloudflare.com/client/v4${routeArg}`,
-        options
-      );
-      if (response.statusCode === 200) {
-        done.resolve(response.body);
-      } else if (response.statusCode === 429) {
-        console.log('rate limited! Waiting for retry!');
-        retryRequest();
-      } else if (response.statusCode === 400) {
-        console.log(`bad request for route ${routeArg}! Going to retry!`);
-        console.log(response.body);
       } else {
-        console.log(response.statusCode);
+        logger.log('error', `the domain ${domainName} does not appear to be in this account!`);
-        done.reject(new Error('request failed'));
+        throw new Error(`the domain ${domainName} does not appear to be in this account!`);
       }
-    };
+    },
-    const retryRequest = async (
+    /**
-      delayTimeArg = Math.floor(Math.random() * (60000 - 8000) + 8000)
+     * gets a record
-    ) => {
+     * @param domainNameArg
-      console.log(`retry started and waiting for ${delayTimeArg} ms`);
+     * @param typeArg
-      await plugins.smartdelay.delayFor(delayTimeArg);
+     */
-      if (retryCount < 10) {
+    getRecord: async (
-        retryCount++;
+      domainNameArg: string,
-        return await makeRequest();
+      typeArg: plugins.tsclass.network.TDnsRecordType
+    ): Promise<plugins.ICloudflareTypes['Record']> => {
+      const domain = new plugins.smartstring.Domain(domainNameArg);
+      const recordArrayArg = await this.convenience.listRecords(domain.zoneName);
+      const filteredResponse = recordArrayArg.filter((recordArg) => {
+        return recordArg.type === typeArg && recordArg.name === domainNameArg;
+      });
+      return filteredResponse[0];
+    },
+    /**
+     * creates a record
+     */
+    createRecord: async (
+      domainNameArg: string,
+      typeArg: plugins.tsclass.network.TDnsRecordType,
+      contentArg: string,
+      ttlArg = 1
+    ): Promise<any> => {
+      const domain = new plugins.smartstring.Domain(domainNameArg);
+      const zoneId = await this.convenience.getZoneId(domain.zoneName);
+      const response = await this.apiAccount.dns.records.create({
+        zone_id: zoneId,
+        type: typeArg as any,
+        name: domain.fullName,
+        content: contentArg,
+        ttl: ttlArg,
+      })
+      return response;
+    },
+    /**
+     * removes a record from Cloudflare
+     * @param domainNameArg
+     * @param typeArg
+     */
+    removeRecord: async (
+      domainNameArg: string,
+      typeArg: plugins.tsclass.network.TDnsRecordType
+    ): Promise<any> => {
+      const domain = new plugins.smartstring.Domain(domainNameArg);
+      const zoneId = await this.convenience.getZoneId(domain.zoneName);
+      const records = await this.convenience.listRecords(domain.zoneName);
+      const recordToDelete = records.find((recordArg) => {
+        return recordArg.name === domainNameArg && recordArg.type === typeArg;
+      });
+      if (recordToDelete) {
+        await this.apiAccount.dns.records.delete(recordToDelete.id, {
+          zone_id: zoneId,
+        });
+      } else {
+        logger.log('warn', `record ${domainNameArg} of type ${typeArg} not found`);
       }
-    };
+    },
-    makeRequest();
-    return done.promise;
-  }
 
-  private authCheck() {
+    /**
-    return this.authEmail && this.authKey; // check if auth is available
+     * cleanrecord allows the cleaning of any previous records to avoid unwanted sideeffects
-  }
+     */
+    cleanRecord: async (domainNameArg: string, typeArg: plugins.tsclass.network.TDnsRecordType) => {
+      logger.log('info', `Cleaning ${typeArg} records for ${domainNameArg}`);
+      const records = await this.convenience.listRecords(domainNameArg);
+      const recordsToDelete = records.filter((recordArg) => {
+        return recordArg.type === typeArg;
+      });
+      for (const recordToDelete of recordsToDelete) {
+        await this.apiAccount.dns.records.delete(recordToDelete.id, {
+          zone_id: recordToDelete.zone_id,
+        });
+      }
+    },
 
-  // acme convenience functions
+    /**
+     * updates a record
+     * @param domainNameArg Domain name for the record
+     * @param typeArg Type of DNS record
+     * @param contentArg New content for the record
+     * @param ttlArg Time to live in seconds (optional)
+     * @returns Updated record
+     */
+    updateRecord: async (
+      domainNameArg: string,
+      typeArg: plugins.tsclass.network.TDnsRecordType,
+      contentArg: string,
+      ttlArg: number = 1
+    ): Promise<plugins.ICloudflareTypes['Record']> => {
+      const domain = new plugins.smartstring.Domain(domainNameArg);
+      const zoneId = await this.convenience.getZoneId(domain.zoneName);
+      
+      // Find existing record
+      const record = await this.convenience.getRecord(domainNameArg, typeArg);
+      
+      if (!record) {
+        logger.log('warn', `Record ${domainNameArg} of type ${typeArg} not found for update, creating instead`);
+        return this.convenience.createRecord(domainNameArg, typeArg, contentArg, ttlArg);
+      }
+      
+      // Update the record
+      const updatedRecord = await this.apiAccount.dns.records.edit(record.id, {
+        zone_id: zoneId,
+        type: typeArg as any,
+        name: domain.fullName,
+        content: contentArg,
+        ttl: ttlArg
+      });
+      
+      return updatedRecord;
+    },
+    /**
+     * list all records of a specified domain name
+     * @param domainNameArg - the domain name that you want to get the records from
+     */
+    listRecords: async (domainNameArg: string) => {
+      const domain = new plugins.smartstring.Domain(domainNameArg);
+      const zoneId = await this.convenience.getZoneId(domain.zoneName);
+      const records: plugins.ICloudflareTypes['Record'][] = [];
+      for await (const record of this.apiAccount.dns.records.list({
+        zone_id: zoneId,
+      })) {
+        records.push(record);
+      }
+      return records;
+    },
+    /**
+     * list all zones in the associated authenticated account
+     * @param domainName
+     */
+    listZones: async (domainName?: string) => {
+      const zones: plugins.ICloudflareTypes['Zone'][] = [];
+      for await (const zone of this.apiAccount.zones.list()) {
+        zones.push(zone);
+      }
+      return zones;
+    },
+    /**
+     * purges a zone
+     */
+    purgeZone: async (domainName: string): Promise<void> => {
+      const domain = new plugins.smartstring.Domain(domainName);
+      const zoneId = await this.convenience.getZoneId(domain.zoneName);
+      await this.apiAccount.cache.purge({
+        zone_id: zoneId,
+        purge_everything: true,
+      });
+    },
+
+    // acme convenience functions
+    acmeSetDnsChallenge: async (dnsChallenge: plugins.tsclass.network.IDnsChallenge) => {
+      await this.convenience.cleanRecord(dnsChallenge.hostName, 'TXT');
+      await this.convenience.createRecord(
+        dnsChallenge.hostName,
+        'TXT',
+        dnsChallenge.challenge,
+        120
+      );
+    },
+    acmeRemoveDnsChallenge: async (dnsChallenge: plugins.tsclass.network.IDnsChallenge) => {
+      await this.convenience.removeRecord(dnsChallenge.hostName, 'TXT');
+    },
+  };
 }

ts/cloudflare.classes.record.ts

@@ -0,0 +1,96 @@
+import * as plugins from './cloudflare.plugins.js';
+import { logger } from './cloudflare.logger.js';
+
+export interface ICloudflareRecordInfo {
+  id: string;
+  type: plugins.tsclass.network.TDnsRecordType;
+  name: string;
+  content: string;
+  proxiable: boolean;
+  proxied: boolean;
+  ttl: number;
+  locked: boolean;
+  zone_id: string;
+  zone_name: string;
+  created_on: string;
+  modified_on: string;
+}
+
+export class CloudflareRecord {
+  /**
+   * Create a CloudflareRecord instance from an API object
+   * @param apiObject Cloudflare DNS record API object
+   * @returns CloudflareRecord instance
+   */
+  public static createFromApiObject(apiObject: plugins.ICloudflareTypes['Record']): CloudflareRecord {
+    const record = new CloudflareRecord();
+    Object.assign(record, apiObject);
+    return record;
+  }
+
+  // Record properties
+  public id: string;
+  public type: plugins.tsclass.network.TDnsRecordType;
+  public name: string;
+  public content: string;
+  public proxiable: boolean;
+  public proxied: boolean;
+  public ttl: number;
+  public locked: boolean;
+  public zone_id: string;
+  public zone_name: string;
+  public created_on: string;
+  public modified_on: string;
+
+  /**
+   * Update the record content
+   * @param cloudflareAccount The Cloudflare account to use
+   * @param newContent New content for the record
+   * @param ttl Optional TTL value in seconds
+   * @returns Updated record
+   */
+  public async update(
+    cloudflareAccount: any,
+    newContent: string,
+    ttl?: number
+  ): Promise<CloudflareRecord> {
+    logger.log('info', `Updating record ${this.name} (${this.type}) with new content`);
+    
+    const updatedRecord = await cloudflareAccount.apiAccount.dns.records.edit(this.id, {
+      zone_id: this.zone_id,
+      type: this.type as any,
+      name: this.name,
+      content: newContent,
+      ttl: ttl || this.ttl,
+      proxied: this.proxied
+    });
+    
+    // Update this instance
+    this.content = newContent;
+    if (ttl) {
+      this.ttl = ttl;
+    }
+    
+    return this;
+  }
+  
+  /**
+   * Delete this record
+   * @param cloudflareAccount The Cloudflare account to use
+   * @returns Boolean indicating success
+   */
+  public async delete(cloudflareAccount: any): Promise<boolean> {
+    try {
+      logger.log('info', `Deleting record ${this.name} (${this.type})`);
+      
+      await cloudflareAccount.apiAccount.dns.records.delete(this.id, {
+        zone_id: this.zone_id
+      });
+      
+      return true;
+    } catch (error) {
+      logger.log('error', `Failed to delete record: ${error.message}`);
+      return false;
+    }
+  }
+}

ts/cloudflare.classes.worker.ts

@@ -1,11 +1,17 @@
-import * as plugins from './cloudflare.plugins';
+import * as plugins from './cloudflare.plugins.js';
-import * as interfaces from './interfaces';
+import * as interfaces from './interfaces/index.js';
-import { WorkerManager } from './cloudflare.classes.workermanager';
+import { WorkerManager } from './cloudflare.classes.workermanager.js';
+import { logger } from './cloudflare.logger.js';
 
 export interface IWorkerRoute extends interfaces.ICflareWorkerRoute {
   zoneName: string;
 }
 
+export interface IWorkerRouteDefinition {
+  zoneName: string;
+  pattern: string;
+}
+
 export class CloudflareWorker {
   // STATIC
   public static async fromApiObject(
@@ -38,16 +44,15 @@ export class CloudflareWorker {
    * gets all routes for a worker
    */
   public async getRoutes() {
-    const zones = await this.workerManager.cfAccount.listZones();
+    const zones = await this.workerManager.cfAccount.convenience.listZones();
     for (const zone of zones) {
       const requestRoute = `/zones/${zone.id}/workers/routes`;
       const response: {
         result: interfaces.ICflareWorkerRoute[];
       } = await this.workerManager.cfAccount.request('GET', requestRoute);
       for (const route of response.result) {
-        console.log('hey');
+        logger.log('debug', `Processing route: ${route.pattern}`);
-        console.log(route);
+        logger.log('debug', `Comparing script: ${route.script} with worker ID: ${this.id}`);
-        console.log(this.id);
         if (route.script === this.id) {
           this.routes.push({ ...route, zoneName: zone.name });
         }
@@ -55,7 +60,11 @@ export class CloudflareWorker {
     }
   }
 
-  public async setRoutes(routeArray: Array<{ zoneName: string; pattern: string }>) {
+  /**
+   * Sets routes for this worker
+   * @param routeArray Array of route definitions
+   */
+  public async setRoutes(routeArray: IWorkerRouteDefinition[]) {
     for (const newRoute of routeArray) {
       // lets determine wether a route is new, needs an update or already up to date.
       let routeStatus: 'new' | 'needsUpdate' | 'alreadyUpToDate' = 'new';
@@ -66,25 +75,25 @@ export class CloudflareWorker {
           routeIdForUpdate = existingRoute.id;
           if (existingRoute.script === this.id) {
             routeStatus = 'alreadyUpToDate';
-            plugins.smartlog.defaultLogger.log('info', `route already exists, no update needed`);
+            logger.log('info', `route already exists, no update needed`);
           }
         }
       }
 
       // lets care about actually setting routes
       if (routeStatus === 'new') {
-        const zoneId = await this.workerManager.cfAccount.getZoneId(newRoute.zoneName);
+        const zoneId = await this.workerManager.cfAccount.convenience.getZoneId(newRoute.zoneName);
         const requestRoute = `/zones/${zoneId}/workers/routes`;
         await this.workerManager.cfAccount.request('POST', requestRoute, {
           pattern: newRoute.pattern,
-          script: this.id
+          script: this.id,
         });
       } else if (routeStatus === 'needsUpdate') {
-        const zoneId = await this.workerManager.cfAccount.getZoneId(newRoute.zoneName);
+        const zoneId = await this.workerManager.cfAccount.convenience.getZoneId(newRoute.zoneName);
         const requestRoute = `/zones/${zoneId}/workers/routes/${routeIdForUpdate}`;
         await this.workerManager.cfAccount.request('PUT', requestRoute, {
           pattern: newRoute.pattern,
-          script: this.id
+          script: this.id,
         });
       }
     }

ts/cloudflare.classes.workermanager.ts

@@ -1,6 +1,7 @@
-import * as plugins from './cloudflare.plugins';
+import * as plugins from './cloudflare.plugins.js';
-import { CloudflareAccount } from './cloudflare.classes.account';
+import { CloudflareAccount } from './cloudflare.classes.account.js';
-import { CloudflareWorker } from './cloudflare.classes.worker';
+import { CloudflareWorker } from './cloudflare.classes.worker.js';
+import { logger } from './cloudflare.logger.js';
 
 export class WorkerManager {
   public cfAccount: CloudflareAccount;
@@ -9,28 +10,81 @@ export class WorkerManager {
     this.cfAccount = cfAccountArg;
   }
 
-  public async createWorker(workerName: string, workerScript: string): Promise<CloudflareWorker> {
+  /**
-    const accountIdentifier = await this.cfAccount.getAccountIdentifier();
+   * Creates a new worker or updates an existing one
-    const route = `/accounts/${accountIdentifier}/workers/scripts/${workerName}`;
+   * @param workerName Name of the worker
-    const responseBody = await this.cfAccount.request('PUT', route, workerScript, {
+   * @param workerScript JavaScript content of the worker
-      'Content-Type': 'application/javascript',
+   * @returns The created or updated worker
-      'Content-Length': Buffer.byteLength(workerScript)
+   */
+  public async createWorker(workerName: string, workerScript: string): Promise<plugins.ICloudflareTypes['Script']> {
+    if (!this.cfAccount.preselectedAccountId) {
+      throw new Error('No account selected. Please select it first on the account.');
+    }
+    const worker = await this.cfAccount.apiAccount.workers.scripts.content.update(workerName, {
+      account_id: this.cfAccount.preselectedAccountId,
+      "CF-WORKER-BODY-PART": workerScript,
     });
-    return CloudflareWorker.fromApiObject(this, responseBody.result);
+    return worker;
   }
 
   /**
-   * lists workers
+   * Get a worker by name
+   * @param workerName Name of the worker to retrieve
+   * @returns CloudflareWorker instance or undefined if not found
    */
-  public async listWorkers() {
+  public async getWorker(workerName: string): Promise<CloudflareWorker | undefined> {
-    const accountIdentifier = await this.cfAccount.getAccountIdentifier();
+    if (!this.cfAccount.preselectedAccountId) {
-    const route = `/accounts/${accountIdentifier}/workers/scripts`;
+      throw new Error('No account selected. Please select it first on the account.');
-    const response = await this.cfAccount.request('GET', route);
+    }
-    const results = response.result;
+    
-    const workers: CloudflareWorker[] = [];
+    try {
-    for (const apiObject of results) {
+      const script = await this.cfAccount.apiAccount.workers.scripts.get(workerName, {
-      workers.push(await CloudflareWorker.fromApiObject(this, apiObject));
+        account_id: this.cfAccount.preselectedAccountId
+      });
+      
+      return CloudflareWorker.fromApiObject(this, script);
+    } catch (error) {
+      logger.log('warn', `Worker '${workerName}' not found: ${error.message}`);
+      return undefined;
+    }
+  }
+
+  /**
+   * Lists all worker scripts
+   * @returns Array of worker scripts
+   */
+  public async listWorkerScripts() {
+    if (!this.cfAccount.preselectedAccountId) {
+      throw new Error('No account selected. Please select it first on the account.');
+    }
+    const workerScripts: plugins.ICloudflareTypes['Script'][] = [];
+    for await (const scriptArg of this.cfAccount.apiAccount.workers.scripts.list({
+      account_id: this.cfAccount.preselectedAccountId,
+    })) {
+      workerScripts.push(scriptArg);
+    }
+    return workerScripts;
+  }
+  
+  /**
+   * Deletes a worker script
+   * @param workerName Name of the worker to delete
+   * @returns True if deletion was successful
+   */
+  public async deleteWorker(workerName: string): Promise<boolean> {
+    if (!this.cfAccount.preselectedAccountId) {
+      throw new Error('No account selected. Please select it first on the account.');
+    }
+    
+    try {
+      await this.cfAccount.apiAccount.workers.scripts.delete(workerName, {
+        account_id: this.cfAccount.preselectedAccountId
+      });
+      logger.log('info', `Worker '${workerName}' deleted successfully`);
+      return true;
+    } catch (error) {
+      logger.log('error', `Failed to delete worker '${workerName}': ${error.message}`);
+      return false;
     }
-    return workers;
   }
 }

ts/cloudflare.classes.zone.ts

@@ -1,6 +1,177 @@
-import * as plugins from './cloudflare.plugins';
+import * as plugins from './cloudflare.plugins.js';
-import * as interfaces from './interfaces';
+import { logger } from './cloudflare.logger.js';
+import * as interfaces from './interfaces/index.js';
 
 export class CloudflareZone {
-  // TODO
+  // Zone properties
+  public id: string;
+  public name: string;
+  public status: interfaces.ICflareZone['status'];
+  public paused: boolean;
+  public type: interfaces.ICflareZone['type'];
+  public development_mode: number;
+  public name_servers: string[];
+  public original_name_servers: string[];
+  public original_registrar: string | null;
+  public original_dnshost: string | null;
+  public modified_on: string;
+  public created_on: string;
+  public activated_on: string;
+  public meta: interfaces.ICflareZone['meta'];
+  public owner: interfaces.ICflareZone['owner'];
+  public account: interfaces.ICflareZone['account'];
+  public permissions: string[];
+  public plan: interfaces.ICflareZone['plan'];
+  
+  private cfAccount: any; // Will be set when created through a manager
+
+  /**
+   * Create a CloudflareZone instance from an API object
+   * @param apiObject Cloudflare Zone API object
+   * @param cfAccount Optional Cloudflare account instance
+   * @returns CloudflareZone instance
+   */
+  public static createFromApiObject(
+    apiObject: plugins.ICloudflareTypes['Zone'], 
+    cfAccount?: any
+  ): CloudflareZone {
+    const cloudflareZone = new CloudflareZone();
+    Object.assign(cloudflareZone, apiObject);
+    
+    if (cfAccount) {
+      cloudflareZone.cfAccount = cfAccount;
+    }
+    
+    return cloudflareZone;
+  }
+  
+  /**
+   * Check if development mode is currently active
+   * @returns True if development mode is active
+   */
+  public isDevelopmentModeActive(): boolean {
+    return this.development_mode > 0;
+  }
+  
+  /**
+   * Enable development mode for the zone
+   * @param cfAccount Cloudflare account to use if not already set
+   * @param duration Duration in seconds (default: 3 hours)
+   * @returns Updated zone
+   */
+  public async enableDevelopmentMode(
+    cfAccount?: any,
+    duration: number = 10800
+  ): Promise<CloudflareZone> {
+    const account = cfAccount || this.cfAccount;
+    if (!account) {
+      throw new Error('CloudflareAccount is required to enable development mode');
+    }
+    
+    logger.log('info', `Enabling development mode for zone ${this.name}`);
+    
+    const response = await account.request('PATCH', `/zones/${this.id}/settings/development_mode`, {
+      value: 'on',
+      time: duration
+    });
+    
+    this.development_mode = duration;
+    return this;
+  }
+  
+  /**
+   * Disable development mode for the zone
+   * @param cfAccount Cloudflare account to use if not already set
+   * @returns Updated zone
+   */
+  public async disableDevelopmentMode(cfAccount?: any): Promise<CloudflareZone> {
+    const account = cfAccount || this.cfAccount;
+    if (!account) {
+      throw new Error('CloudflareAccount is required to disable development mode');
+    }
+    
+    logger.log('info', `Disabling development mode for zone ${this.name}`);
+    
+    const response = await account.request('PATCH', `/zones/${this.id}/settings/development_mode`, {
+      value: 'off'
+    });
+    
+    this.development_mode = 0;
+    return this;
+  }
+  
+  /**
+   * Purge all cached content for this zone
+   * @param cfAccount Cloudflare account to use if not already set
+   * @returns True if successful
+   */
+  public async purgeCache(cfAccount?: any): Promise<boolean> {
+    const account = cfAccount || this.cfAccount;
+    if (!account) {
+      throw new Error('CloudflareAccount is required to purge cache');
+    }
+    
+    logger.log('info', `Purging all cache for zone ${this.name}`);
+    
+    try {
+      await account.request('POST', `/zones/${this.id}/purge_cache`, {
+        purge_everything: true
+      });
+      return true;
+    } catch (error) {
+      logger.log('error', `Failed to purge cache: ${error.message}`);
+      return false;
+    }
+  }
+  
+  /**
+   * Purge specific URLs from the cache
+   * @param urls Array of URLs to purge
+   * @param cfAccount Cloudflare account to use if not already set
+   * @returns True if successful
+   */
+  public async purgeUrls(urls: string[], cfAccount?: any): Promise<boolean> {
+    const account = cfAccount || this.cfAccount;
+    if (!account) {
+      throw new Error('CloudflareAccount is required to purge URLs');
+    }
+    
+    if (!urls.length) {
+      return true;
+    }
+    
+    logger.log('info', `Purging ${urls.length} URLs from cache for zone ${this.name}`);
+    
+    try {
+      await account.request('POST', `/zones/${this.id}/purge_cache`, {
+        files: urls
+      });
+      return true;
+    } catch (error) {
+      logger.log('error', `Failed to purge URLs: ${error.message}`);
+      return false;
+    }
+  }
+  
+  /**
+   * Check if the zone is active
+   * @returns True if the zone is active
+   */
+  public isActive(): boolean {
+    return this.status === 'active' && !this.paused;
+  }
+  
+  /**
+   * Check if the zone is using Cloudflare nameservers
+   * @returns True if using Cloudflare nameservers
+   */
+  public isUsingCloudflareNameservers(): boolean {
+    // Check if original nameservers match current nameservers
+    if (!this.original_name_servers || !this.name_servers) {
+      return false;
+    }
+    
+    // If they're different, and current nameservers are Cloudflare's
+    return this.name_servers.some(ns => ns.includes('cloudflare'));
+  }
 }

ts/cloudflare.classes.zonemanager.ts

@@ -1,11 +1,153 @@
-import * as plugins from './cloudflare.plugins';
+import * as plugins from './cloudflare.plugins.js';
-import { CloudflareAccount } from './cloudflare.classes.account';
+import * as interfaces from './interfaces/index.js';
+import { CloudflareAccount } from './cloudflare.classes.account.js';
+import { CloudflareZone } from './cloudflare.classes.zone.js';
+import { logger } from './cloudflare.logger.js';
 
 export class ZoneManager {
   public cfAccount: CloudflareAccount;
-  public zoneName: string;
 
   constructor(cfAccountArg: CloudflareAccount) {
     this.cfAccount = cfAccountArg;
   }
+
+  /**
+   * Get all zones, optionally filtered by name
+   * @param zoneName Optional zone name to filter by
+   * @returns Array of CloudflareZone instances
+   */
+  public async getZones(zoneName?: string): Promise<CloudflareZone[]> {
+    let requestRoute = `/zones?per_page=50`;
+    
+    // May be optionally filtered by domain name
+    if (zoneName) {
+      requestRoute = `${requestRoute}&name=${encodeURIComponent(zoneName)}`;
+    }
+
+    try {
+      const response: { result: interfaces.ICflareZone[] } = await this.cfAccount.request('GET', requestRoute);
+      
+      return response.result.map(apiObject => 
+        CloudflareZone.createFromApiObject(apiObject as any, this.cfAccount)
+      );
+    } catch (error) {
+      logger.log('error', `Failed to fetch zones: ${error.message}`);
+      return [];
+    }
+  }
+  
+  /**
+   * Get a single zone by name
+   * @param zoneName Zone name to find
+   * @returns CloudflareZone instance or undefined if not found
+   */
+  public async getZoneByName(zoneName: string): Promise<CloudflareZone | undefined> {
+    const zones = await this.getZones(zoneName);
+    return zones.find(zone => zone.name === zoneName);
+  }
+  
+  /**
+   * Get a zone by its ID
+   * @param zoneId Zone ID to find
+   * @returns CloudflareZone instance or undefined if not found
+   */
+  public async getZoneById(zoneId: string): Promise<CloudflareZone | undefined> {
+    try {
+      const response: { result: interfaces.ICflareZone } = await this.cfAccount.request(
+        'GET', 
+        `/zones/${zoneId}`
+      );
+      
+      return CloudflareZone.createFromApiObject(response.result as any, this.cfAccount);
+    } catch (error) {
+      logger.log('error', `Failed to fetch zone with ID ${zoneId}: ${error.message}`);
+      return undefined;
+    }
+  }
+  
+  /**
+   * Create a new zone
+   * @param zoneName Name of the zone to create
+   * @param jumpStart Whether to automatically attempt to fetch existing DNS records
+   * @param accountId Account ID to use (defaults to preselected account)
+   * @returns The created zone
+   */
+  public async createZone(
+    zoneName: string, 
+    jumpStart: boolean = false,
+    accountId?: string
+  ): Promise<CloudflareZone | undefined> {
+    const useAccountId = accountId || this.cfAccount.preselectedAccountId;
+    
+    if (!useAccountId) {
+      throw new Error('No account selected. Please select it first on the account.');
+    }
+    
+    try {
+      logger.log('info', `Creating zone ${zoneName}`);
+      
+      const response: { result: interfaces.ICflareZone } = await this.cfAccount.request(
+        'POST', 
+        '/zones', 
+        {
+          name: zoneName,
+          jump_start: jumpStart,
+          account: { id: useAccountId }
+        }
+      );
+      
+      return CloudflareZone.createFromApiObject(response.result as any, this.cfAccount);
+    } catch (error) {
+      logger.log('error', `Failed to create zone ${zoneName}: ${error.message}`);
+      return undefined;
+    }
+  }
+  
+  /**
+   * Delete a zone
+   * @param zoneId ID of the zone to delete
+   * @returns True if successful
+   */
+  public async deleteZone(zoneId: string): Promise<boolean> {
+    try {
+      logger.log('info', `Deleting zone with ID ${zoneId}`);
+      
+      await this.cfAccount.request('DELETE', `/zones/${zoneId}`);
+      return true;
+    } catch (error) {
+      logger.log('error', `Failed to delete zone with ID ${zoneId}: ${error.message}`);
+      return false;
+    }
+  }
+  
+  /**
+   * Check if a zone exists
+   * @param zoneName Name of the zone to check
+   * @returns True if the zone exists
+   */
+  public async zoneExists(zoneName: string): Promise<boolean> {
+    const zones = await this.getZones(zoneName);
+    return zones.some(zone => zone.name === zoneName);
+  }
+  
+  /**
+   * Activate a zone (if it's in pending status)
+   * @param zoneId ID of the zone to activate
+   * @returns Updated zone or undefined if activation failed
+   */
+  public async activateZone(zoneId: string): Promise<CloudflareZone | undefined> {
+    try {
+      logger.log('info', `Activating zone with ID ${zoneId}`);
+      
+      const response: { result: interfaces.ICflareZone } = await this.cfAccount.request(
+        'PUT', 
+        `/zones/${zoneId}/activation_check`
+      );
+      
+      return CloudflareZone.createFromApiObject(response.result as any, this.cfAccount);
+    } catch (error) {
+      logger.log('error', `Failed to activate zone with ID ${zoneId}: ${error.message}`);
+      return undefined;
+    }
+  }
 }

ts/cloudflare.logger.ts

@@ -0,0 +1,3 @@
+import * as plugins from './cloudflare.plugins.js';
+
+export const logger = new plugins.smartlog.ConsoleLog();

ts/cloudflare.plugins.ts

@@ -1,8 +1,24 @@
-import * as smartlog from '@pushrocks/smartlog';
+import * as smartlog from '@push.rocks/smartlog';
-import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartdelay from '@push.rocks/smartdelay';
-import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartrequest from '@push.rocks/smartrequest';
-import * as smartstring from '@pushrocks/smartstring';
+import * as smartstring from '@push.rocks/smartstring';
 import * as tsclass from '@tsclass/tsclass';
 
 export { smartlog, smartpromise, smartdelay, smartrequest, smartstring, tsclass };
+
+// third party
+import * as cloudflare from 'cloudflare';
+import * as interfaces from './interfaces/index.js';
+import type { Zone } from 'cloudflare/resources/zones/zones.js';
+import type { Record } from 'cloudflare/resources/dns/records.js';
+import type { Script } from 'cloudflare/resources/workers/scripts/index.js';
+
+export interface ICloudflareTypes {
+  Account: interfaces.ICloudflareApiAccountObject;
+  Record: Record;
+  Zone: Zone;
+  Script: Script;
+}
+
+export { cloudflare };

ts/cloudflare.utils.ts

@@ -0,0 +1,130 @@
+import * as plugins from './cloudflare.plugins.js';
+import { logger } from './cloudflare.logger.js';
+
+export class CloudflareUtils {
+  /**
+   * Validates if a domain name is properly formatted
+   * @param domainName Domain name to validate
+   * @returns True if the domain is valid
+   */
+  public static isValidDomain(domainName: string): boolean {
+    try {
+      const domain = new plugins.smartstring.Domain(domainName);
+      return domain.isValid();
+    } catch (error) {
+      return false;
+    }
+  }
+  
+  /**
+   * Extracts the zone name (apex domain) from a full domain
+   * @param domainName Domain name to process
+   * @returns Zone name (apex domain)
+   */
+  public static getZoneName(domainName: string): string {
+    try {
+      const domain = new plugins.smartstring.Domain(domainName);
+      return domain.zoneName;
+    } catch (error) {
+      logger.log('error', `Invalid domain name: ${domainName}`);
+      throw new Error(`Invalid domain name: ${domainName}`);
+    }
+  }
+  
+  /**
+   * Checks if a string is a valid Cloudflare API token
+   * @param token API token to validate
+   * @returns True if the token format is valid
+   */
+  public static isValidApiToken(token: string): boolean {
+    // Cloudflare API tokens are typically 40+ characters long and start with specific patterns
+    return /^[A-Za-z0-9_-]{40,}$/.test(token);
+  }
+  
+  /**
+   * Validates a DNS record type
+   * @param type DNS record type to validate
+   * @returns True if it's a valid DNS record type
+   */
+  public static isValidRecordType(type: string): boolean {
+    const validTypes: plugins.tsclass.network.TDnsRecordType[] = [
+      'A', 'AAAA', 'CNAME', 'TXT', 'SRV', 'LOC', 'MX',
+      'NS', 'SPF', 'CERT', 'DNSKEY', 'DS', 'NAPTR', 'SMIMEA',
+      'SSHFP', 'TLSA', 'URI'
+    ];
+    return validTypes.includes(type as any);
+  }
+  
+  /**
+   * Formats a URL for cache purging (ensures it starts with http/https)
+   * @param url URL to format
+   * @returns Properly formatted URL
+   */
+  public static formatUrlForPurge(url: string): string {
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+      return `https://${url}`;
+    }
+    return url;
+  }
+  
+  /**
+   * Converts a TTL value in seconds to a human-readable string
+   * @param ttl TTL in seconds
+   * @returns Human-readable TTL
+   */
+  public static formatTtl(ttl: number): string {
+    if (ttl === 1) {
+      return 'Automatic';
+    } else if (ttl === 120) {
+      return '2 minutes';
+    } else if (ttl === 300) {
+      return '5 minutes';
+    } else if (ttl === 600) {
+      return '10 minutes';
+    } else if (ttl === 900) {
+      return '15 minutes';
+    } else if (ttl === 1800) {
+      return '30 minutes';
+    } else if (ttl === 3600) {
+      return '1 hour';
+    } else if (ttl === 7200) {
+      return '2 hours';
+    } else if (ttl === 18000) {
+      return '5 hours';
+    } else if (ttl === 43200) {
+      return '12 hours';
+    } else if (ttl === 86400) {
+      return '1 day';
+    } else {
+      return `${ttl} seconds`;
+    }
+  }
+  
+  /**
+   * Safely handles API pagination for Cloudflare requests
+   * @param makeRequest Function that makes the API request with page parameters
+   * @returns Combined results from all pages
+   */
+  public static async paginateResults<T>(
+    makeRequest: (page: number, perPage: number) => Promise<{ result: T[], result_info: { total_pages: number } }>
+  ): Promise<T[]> {
+    const perPage = 50; // Cloudflare's maximum
+    let page = 1;
+    let totalPages = 1;
+    const allResults: T[] = [];
+    
+    do {
+      try {
+        const response = await makeRequest(page, perPage);
+        allResults.push(...response.result);
+        totalPages = response.result_info.total_pages;
+        page++;
+      } catch (error) {
+        logger.log('error', `Pagination error on page ${page}: ${error.message}`);
+        break;
+      }
+    } while (page <= totalPages);
+    
+    return allResults;
+  }
+}

ts/index.ts

@@ -1,2 +1,11 @@
-export { CloudflareAccount } from './cloudflare.classes.account';
+export { CloudflareAccount } from './cloudflare.classes.account.js';
-export { CloudflareWorker } from './cloudflare.classes.worker';
+export { CloudflareWorker, type IWorkerRoute, type IWorkerRouteDefinition } from './cloudflare.classes.worker.js';
+export { WorkerManager } from './cloudflare.classes.workermanager.js';
+export { CloudflareRecord, type ICloudflareRecordInfo } from './cloudflare.classes.record.js';
+export { CloudflareZone } from './cloudflare.classes.zone.js';
+export { ZoneManager } from './cloudflare.classes.zonemanager.js';
+export { CloudflareUtils } from './cloudflare.utils.js';
+export { commitinfo } from './00_commitinfo_data.js';
+
+// Re-export interfaces
+export * from './interfaces/index.js';

ts/interfaces/cloudflare.api.account.ts

@@ -0,0 +1,20 @@
+export interface ICloudflareApiAccountObject {
+  id: string;
+  name: string;
+  type: 'standard' | 'enterprise' | 'pro' | 'free'; // Assuming other possible types
+  settings: {
+    enforce_twofactor: boolean;
+    api_access_enabled: boolean | null;
+    access_approval_expiry: string | null; // Assuming ISO date string or null
+    use_account_custom_ns_by_default: boolean;
+    default_nameservers: string;
+  };
+  legacy_flags: {
+    enterprise_zone_quota: {
+      maximum: number;
+      current: number;
+      available: number;
+    };
+  };
+  created_on: string; // Assuming ISO date string
+}

ts/interfaces/cloudflare.api.record.ts

@@ -1,15 +0,0 @@
-export interface ICflareRecord {
-  id: string;
-  type: string;
-  name: string;
-  content: string;
-  proxiable: boolean;
-  proxied: boolean;
-  ttl: number;
-  locked: boolean;
-  zone_id: string;
-  zone_name: string;
-  created_on: string;
-  modified_on: string;
-  data: any;
-}

ts/interfaces/cloudflare.api.zone.ts

@@ -1,17 +1,33 @@
 export interface ICflareZone {
   id: string;
   name: string;
+  status: 'active' | 'pending' | 'initializing' | 'moved' | 'deleted' | 'deactivated';
+  paused: boolean;
+  type: 'full' | 'partial' | 'secondary';
   development_mode: number;
-  original_name_servers: string[];
-  original_registrar: string;
-  original_dnshost: string;
-  created_on: string;
-  modified_on: string;
   name_servers: string[];
+  original_name_servers: string[];
+  original_registrar: string | null;
+  original_dnshost: string | null;
+  modified_on: string;
+  created_on: string;
+  activated_on: string;
+  meta: {
+    step: number;
+    wildcard_proxiable: boolean;
+    custom_certificate_quota: number;
+    page_rule_quota: number;
+    phishing_detected: boolean;
+    multiple_railguns_allowed: boolean;
+  };
   owner: {
+    id: string | null;
+    type: 'user' | 'organization';
+    email: string | null;
+  };
+  account: {
     id: string;
-    email: string;
+    name: string;
-    owner_type: string;
   };
   permissions: string[];
   plan: {
@@ -20,22 +36,10 @@ export interface ICflareZone {
     price: number;
     currency: string;
     frequency: string;
-    legacy_id: string;
     is_subscribed: boolean;
     can_subscribe: boolean;
-  };
-  plan_pending: {
-    id: string;
-    name: string;
-    price: number;
-    currency: string;
-    frequency: string;
     legacy_id: string;
-    is_subscribed: string;
+    legacy_discount: boolean;
-    can_subscribe: string;
+    externally_managed: boolean;
   };
-  status: string;
-  paused: boolean;
-  type: string;
-  checked_on: string;
 }

ts/interfaces/index.ts

@@ -1,3 +1,3 @@
-export * from './cloudflare.api.record';
+export * from './cloudflare.api.account.js';
-export * from './cloudflare.api.zone';
+export * from './cloudflare.api.workerroute.js';
-export * from './cloudflare.api.workerroute';
+export * from './cloudflare.api.zone.js';

tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
+}

tslint.json

@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}