6.0.5

.gitignore

@@ -1,7 +1,20 @@
+.nogit/
+
+# artifacts
 coverage/
-docs/
-ts/typings/
+public/
+pages/
+
+# installs
 node_modules/
 
-.nogit/
-nogit/
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+# custom

.gitlab-ci.yml

@@ -1,43 +0,0 @@
-image: hosttoday/ht-docker-node:npmts
-
-stages:
-- test1
-- test2
-- test3
-- release
-
-testLEGACY:
-  stage: test1
-  script:
-    - npmci test legacy
-  only:
-    - tags
-  tags:
-    - docker
-
-testLTS:
-  stage: test2
-  script:
-    - npmci test lts
-  only:
-    - tags
-  tags:
-    - docker
-    
-testSTABLE:
-  stage: test3
-  script:
-    - npmci test stable
-  only:
-    - tags
-  tags:
-    - docker
-
-release:
-  stage: release
-  script:
-    - npmci publish
-  only:
-    - tags
-  tags:
-    - docker

.travis.yml

@@ -1,12 +0,0 @@
-language: node_js
-node_js:
-- '4'
-- stable
-deploy:
-  provider: npm
-  email: npm@lossless.digital
-  api_key:
-    secure: uWqO634z8xMWI8tcIpSvUeVeG4ypX5fppXWxrSKbO5zOHCHGqJK90XiGFfKUekMf0cYQPb5dLT5+J/3nd4mf4KtU3+v1OK6ZikEqn/PcSeqOmK7EnI9wDFZwDTgJWIn0lRwX2mfB9meblSZ7XthTXumX78fmRTyeyImLm9P0ak+CrNzs8rzKauBoqeVryOez4/LaH3f0kxSz7o7zYLxFqx5xjQ7TFqd1kkVTf4pSQanLHY3z+7+mKrkbcNVxx2gF76hyx6E4pntSJHrOEE/VU/KMk2B6yzrVWYUHUiSRGYOV9U17YaaWlC9DZmnS1cvYcqq3YNujTwPWtci3It9S98hLrSTnCCqin6xhj8IuV6U4WADiXOUvNKuTRcd0/leQ4w3xpPJ1FR2gRtEhwQ0NsnY0vL9tuRAW71lf31122TTJI8lJQNrnaeIGbX7eE0Pq0jeTpmM2W/Tl8pl6s6zBjlEC/mCynQq1pBiz7UmxMYCPE162I8V5USeZOBLzDPZV2y7hmPWjMrWTT+i/IpFmXHjQtVrwlyU6fCOeYHgK/5GdyhnrRYYlx+ce6pCn4tmkVxduimC3m1G8cTkPl00fIpy7KSVcaeQrc1N+KQUqK4FpIjeqB904SVPsI5v3P7sdobaT1aqFqszhR+JK5tXaoesew8R2RncjFK69J7DHJWk=
-  on:
-    tags: true
-    repo: pushrocks/cflare

.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

README.md

@@ -1,31 +0,0 @@
-# cflare
-allows you to manage multiple cloudflare accounts.
-
-> Note: this package is still in alpha, so some things do not yet work.
-I (Phil from Lossless) expect this package to be ready 1. of June 2016.
-
-## Status
-[![Build Status](https://travis-ci.org/pushrocks/cflare.svg?branch=master)](https://travis-ci.org/pushrocks/cflare)
-
-## Usage
-
-```javascript
-var cflare = require("cflare");
-var cflareInstance = new cflare();
-
-cflareInstance.auth({
-    email:"",
-    key:""
-});
-
-cflareInstance.createRecord(); // returns promise with resolve function getting the response;
-cflareInstance.removeRecord(); // returns promise with resolve function getting the response;
-cflareInstance.copyRecord(); // returns promise with resolve function getting the response;
-cflareInstance.listRecords(); // returns promise with resolve function getting the response;
-cflareInstance.listDomains(); // returns promise with resolve function getting the response;
-```
-
-### About the authors:
-[![Project Phase](https://mediaserve.lossless.digital/lossless.com/img/createdby_github.svg)](https://lossless.com/)
-
-[![Gitter](https://img.shields.io/badge/Support%20us-PayPal-blue.svg)](https://paypal.me/lossless)

dist/cflare.classes.cflareaccount.d.ts

@@ -1,19 +0,0 @@
-import "typings-global";
-export declare class CflareAccount {
-    private authEmail;
-    private authKey;
-    private authCheck();
-    constructor();
-    auth(optionsArg: {
-        email: string;
-        key: string;
-    }): void;
-    getZoneId(domainName: string): any;
-    getRecord(domainNameArg: string, typeArg: string): any;
-    createRecord(domainNameArg: string, typeArg: string, contentArg: string): any;
-    removeRecord(domainNameArg: string, typeArg: string): any;
-    updateRecord(domainNameArg: string, typeArg: string, valueArg: any): any;
-    listRecords(domainNameArg: string): any;
-    listZones(domainName?: string): any;
-    request(methodArg: string, routeArg: string, dataArg?: {}): any;
-}

dist/cflare.classes.helpers.d.ts

@@ -1 +0,0 @@
-import "typings-global";

dist/cflare.classes.helpers.js

@@ -1,4 +0,0 @@
-"use strict";
-require("typings-global");
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNmbGFyZS5jbGFzc2VzLmhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQSIsImZpbGUiOiJjZmxhcmUuY2xhc3Nlcy5oZWxwZXJzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFwidHlwaW5ncy1nbG9iYWxcIjtcbmltcG9ydCBwbHVnaW5zID0gcmVxdWlyZShcIi4vY2ZsYXJlLnBsdWdpbnNcIik7Il19

dist/cflare.plugins.d.ts

@@ -1,5 +0,0 @@
-import "typings-global";
-export declare let beautylog: any;
-export declare let q: any;
-export declare let request: any;
-export import smartstring = require("smartstring");

dist/cflare.plugins.js

@@ -1,8 +0,0 @@
-"use strict";
-require("typings-global");
-exports.beautylog = require("beautylog");
-exports.q = require("q");
-exports.request = require("request");
-exports.smartstring = require("smartstring");
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNmbGFyZS5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxRQUFPLGdCQUFnQixDQUFDLENBQUE7QUFDYixpQkFBUyxHQUFHLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQztBQUNqQyxTQUFDLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ2pCLGVBQU8sR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUM7QUFDMUIsbUJBQVcsV0FBVyxhQUFhLENBQUMsQ0FBQyIsImZpbGUiOiJjZmxhcmUucGx1Z2lucy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBcInR5cGluZ3MtZ2xvYmFsXCI7XG5leHBvcnQgbGV0IGJlYXV0eWxvZyA9IHJlcXVpcmUoXCJiZWF1dHlsb2dcIik7XG5leHBvcnQgbGV0IHEgPSByZXF1aXJlKFwicVwiKTtcbmV4cG9ydCBsZXQgcmVxdWVzdCA9IHJlcXVpcmUoXCJyZXF1ZXN0XCIpO1xuZXhwb3J0IGltcG9ydCBzbWFydHN0cmluZyA9IHJlcXVpcmUoXCJzbWFydHN0cmluZ1wiKTsiXX0=

dist/index.d.ts

@@ -1,2 +0,0 @@
-import "typings-global";
-export { CflareAccount } from "./cflare.classes.cflareaccount";

dist/index.js

@@ -1,6 +0,0 @@
-"use strict";
-require("typings-global");
-var cflare_classes_cflareaccount_1 = require("./cflare.classes.cflareaccount");
-exports.CflareAccount = cflare_classes_cflareaccount_1.CflareAccount;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxRQUFPLGdCQUFnQixDQUFDLENBQUE7QUFDeEIsNkNBQTRCLGdDQUFnQyxDQUFDO0FBQXJELHFFQUFxRCIsImZpbGUiOiJpbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBcInR5cGluZ3MtZ2xvYmFsXCI7XG5leHBvcnQge0NmbGFyZUFjY291bnR9IGZyb20gXCIuL2NmbGFyZS5jbGFzc2VzLmNmbGFyZWFjY291bnRcIjsiXX0=

license

@@ -1,6 +1,4 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Lossless GmbH
+Copyright (c) 2014 Task Venture Capital GmbH (hello@task.vc)
 
 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

@@ -0,0 +1,29 @@
+{
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public"
+  },
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "mojoio",
+      "gitrepo": "cloudflare",
+      "description": "A TypeScript client for managing Cloudflare accounts, zones, DNS records, and workers with ease.",
+      "npmPackagename": "@apiclient.xyz/cloudflare",
+      "license": "MIT",
+      "keywords": [
+        "Cloudflare",
+        "DNS management",
+        "zone management",
+        "worker management",
+        "TypeScript",
+        "API client",
+        "cloud infrastructure",
+        "automated DNS",
+        "CDN management",
+        "open source"
+      ]
+    }
+  }
+}

package.json

@@ -1,37 +1,70 @@
 {
-  "name": "cflare",
-  "version": "0.0.6",
-  "description": "cloudflare management for CoreOS",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "name": "@apiclient.xyz/cloudflare",
+  "version": "6.0.5",
+  "private": false,
+  "description": "A TypeScript client for managing Cloudflare accounts, zones, DNS records, and workers with ease.",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "scripts": {
-    "test": "(npmts)"
+    "test": "(tstest test/)",
+    "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://github.com/pushrocks/cflare.git"
+    "url": "git+https://gitlab.com/pushrocks/cflare.git"
   },
   "keywords": [
-    "CoreOS",
-    "cloudflare"
+    "Cloudflare",
+    "DNS management",
+    "zone management",
+    "worker management",
+    "TypeScript",
+    "API client",
+    "cloud infrastructure",
+    "automated DNS",
+    "CDN management",
+    "open source"
   ],
   "author": "Lossless GmbH",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/pushrocks/cflare/issues"
+    "url": "https://gitlab.com/pushrocks/cflare/issues"
   },
-  "homepage": "https://github.com/pushrocks/cflare#readme",
+  "homepage": "https://gitlab.com/pushrocks/cflare#readme",
   "dependencies": {
-    "beautylog": "^5.0.12",
-    "q": "^1.4.1",
-    "request": "^2.72.0",
-    "smartstring": "^2.0.9",
-    "typings-global": "^1.0.3"
+    "@push.rocks/smartdelay": "^3.0.1",
+    "@push.rocks/smartlog": "^3.0.2",
+    "@push.rocks/smartpromise": "^4.0.2",
+    "@push.rocks/smartrequest": "^2.0.15",
+    "@push.rocks/smartstring": "^4.0.5",
+    "@tsclass/tsclass": "^4.0.58",
+    "cloudflare": "^3.2.0"
   },
   "devDependencies": {
-    "npmts-g": "^5.2.6",
-    "qenv": "^1.0.8",
-    "should": "^9.0.2",
-    "typings-test": "^1.0.1"
-  }
+    "@git.zone/tsbuild": "^2.1.66",
+    "@git.zone/tsrun": "^1.2.42",
+    "@git.zone/tstest": "^1.0.74",
+    "@push.rocks/qenv": "^6.0.5",
+    "@push.rocks/tapbundle": "^5.0.4",
+    "@types/node": "^20.3.1",
+    "openapi-typescript": "^6.7.6"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
 }

qenv.yml

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

readme.hints.md

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

readme.md

@@ -0,0 +1,250 @@
+# @apiclient.xyz/cloudflare
+easy cloudflare management
+
+## Install
+To install the `@apiclient.xyz/cloudflare` package, you can use npm. Simply run the following command:
+
+```bash
+npm install @apiclient.xyz/cloudflare
+```
+
+Make sure to include it in your `dependencies` in `package.json`.
+
+## Usage
+
+### Initial Setup
+
+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.
+
+```typescript
+import * as cflare from '@apiclient.xyz/cloudflare';
+
+// Initialize Cloudflare Account
+const myCflareAccount = new cflare.CloudflareAccount('mySuperAwesomeAccountToken');
+```
+
+### Managing Zones
+
+#### List All Zones
+
+To list all zones in your Cloudflare account, you can use the `listZones` method:
+
+```typescript
+const listAllZones = async () => {
+  const myZones = await myCflareAccount.convenience.listZones();
+  console.log(myZones);
+};
+```
+
+#### 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.d.ts

@@ -1 +0,0 @@
-import "typings-test";

test/test.ts

@@ -1,88 +1,104 @@
-import "typings-test";
-import cflare = require("../dist/index");
-let should = require("should");
-import {Qenv} from "qenv";
-let testQenv = new Qenv(process.cwd(),process.cwd() + "/.nogit"); 
-console.log(testQenv.missingEnvVars);
-let testCflareAccount = new cflare.CflareAccount();
-testCflareAccount.auth({
-    email: process.env.CF_EMAIL,
-    key: process.env.CF_KEY
+// tslint:disable-next-line: no-implicit-dependencies
+import { expect, tap } from '@push.rocks/tapbundle';
+// tslint:disable-next-line: no-implicit-dependencies
+import { Qenv } from '@push.rocks/qenv';
+
+import * as cloudflare from '../ts/index.js';
+
+const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit');
+
+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(await testQenv.getEnvVarOnDemand('CF_KEY'));
 });
 
-describe("cflare",function(){
-    describe(".CflareAccount",function(){
-        describe(".listZones()",function(){
-            it("should display an entire account",function(done){
-                this.timeout(10000);
-                testCflareAccount.listZones()
-                    .then((responseArg)=>{
+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.convenience.listZones();
+  console.log(result);
+  // await tools.delayFor(10000);
+});
+
+tap.test(
+  '.getZoneId(domainName) -> should get an Cloudflare Id for a domain string',
+  async (tools) => {
+    tools.timeout(600000);
+    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) => {
+    tools.timeout(600000);
+    await testCloudflareAccount.convenience.listRecords('bleu.de').then(async (responseArg) => {
       console.log(responseArg);
-                        done();
-                    })
     });
-        });
-        describe(".getZoneId(domainName)",function(){
-            it("should get an Cloudflare Id for a domain string",function(done){
-                this.timeout(10000)
-                testCflareAccount.getZoneId("bleu.de")
-                    .then((responseArg)=>{
-                        console.log(responseArg);
-                        done();
-                    });
-            });
-        });
-        describe(".listRecords(domainName)",function(){
-            it("should list all records for a specific Domain Name",function(done){
-                this.timeout(10000);
-                testCflareAccount.listRecords("bleu.de")
+  }
+);
+
+tap.test('should create a valid record for a subdomain', async (tools) => {
+  tools.timeout(600000);
+  await testCloudflareAccount.convenience.createRecord(
+    `${randomPrefix}subdomain.bleu.de`,
+    'A',
+    '127.0.0.1',
+    120
+  );
+});
+
+tap.test('should get a record from Cloudflare', async (tools) => {
+  tools.timeout(600000);
+  await testCloudflareAccount.convenience
+    .getRecord(`${randomPrefix}subdomain.bleu.de`, 'A')
     .then((responseArg) => {
       console.log(responseArg);
-                        done();
     });
-            });
-        })
-        describe(".createRecord",function(){
-            this.timeout(10000);
-            it("should create a valid record for a level 2 domain",function(done){
-                testCflareAccount.createRecord("bleu.de","A","127.0.0.1")
-                    .then(function(responseArg){
-                        console.log(responseArg);
-                        done();
-                    });
-            });
-            it("should create a valid record for a subdomain",function(done){
-                testCflareAccount.createRecord("subdomain.bleu.de","A","127.0.0.1")
-                    .then(function(responseArg){
-                        console.log(responseArg);
-                        done();
-                    });
-            });
-        });
-        describe(".getRecord",function(){
-            it("should get a record from Cloudflare",function(done){
-                testCflareAccount.getRecord("bleu.de","A")
-                    .then(function(responseArg){
-                        console.log(responseArg);
-                        done();
-                    });
-            });
-        });
-        describe(".removeRecord",function(){
-            it("should remove a record from Cloudflare",function(done){
-                testCflareAccount.removeRecord("bleu.de","A")
-                    .then(function(responseArg){
-                        console.log(responseArg);
-                        done();
-                    });
-            });
-            it("should remove a subdomain record from Cloudflare",function(done){
-                testCflareAccount.removeRecord("subdomain.bleu.de","A")
-                    .then(function(responseArg){
-                        console.log(responseArg);
-                        done();
-                    });
-            });
-        });
-    })
 });
+
+tap.test('should remove a subdomain record from Cloudflare', async (tools) => {
+  tools.timeout(600000);
+  await testCloudflareAccount.convenience
+    .removeRecord(`${randomPrefix}subdomain.bleu.de`, 'A')
+    .then(async (responseArg) => {
+      console.log(responseArg);
+    });
+});
+
+tap.test('.purge(some.domain) -> should purge everything', async () => {
+  await testCloudflareAccount.convenience.purgeZone('bleu.de');
+});
+
+tap.test('should list workers', async () => {
+  const workerArray = await testCloudflareAccount.workerManager.listWorkerScripts();
+  console.log(workerArray);
+});
+
+// WORKERS
+tap.test('should create a worker', async () => {
+  const worker = await testCloudflareAccount.workerManager.createWorker(
+    'myawesomescript',
+    `addEventListener('fetch', event => { event.respondWith(fetch(event.request)) })`
+  );
+  await worker.setRoutes([
+    {
+      zoneName: 'bleu.de',
+      pattern: 'https://*bleu.de/hello',
+    },
+  ]);
+  console.log(worker);
+});
+
+tap.test('should get workers again', async () => {
+  const workerArray = await testCloudflareAccount.workerManager.listWorkerScripts();
+  console.log(workerArray);
+});
+
+tap.start();

ts/00_commitinfo_data.ts

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

ts/cflare.classes.cflareaccount.ts

@@ -1,135 +0,0 @@
-import "typings-global";
-import plugins = require("./cflare.plugins");
-import helpers = require("./cflare.classes.helpers");
-
-export class CflareAccount {
-    private authEmail:string;
-    private authKey:string;
-    private authCheck(){
-        return (this.authEmail && this.authKey); //check if auth is available
-    }
-    constructor(){
-        
-    };
-    auth(optionsArg:{email:string,key:string}){
-        this.authEmail = optionsArg.email;
-        this.authKey = optionsArg.key;       
-    }
-    getZoneId(domainName:string){
-        let done = plugins.q.defer();
-        this.listZones(domainName)
-            .then((responseArg) => {
-                let filteredResponse = responseArg.result.filter((zoneArg)=>{
-                    return zoneArg.name === domainName;
-                });
-                if (filteredResponse.length >= 1){
-                    done.resolve(filteredResponse[0].id);
-                } else {
-                    plugins.beautylog.error("the domain " + domainName.blue + " does not appear to be in this account!");
-                    done.reject(undefined);
-                }
-            });
-        return done.promise;
-    }
-    getRecord(domainNameArg:string,typeArg:string){
-        let done = plugins.q.defer();
-        let domain = new plugins.smartstring.Domain(domainNameArg);
-        this.listRecords(domain.zoneName)
-            .then((responseArg) => {
-                let filteredResponse = responseArg.result.filter((recordArg) => {
-                    return (recordArg.type == typeArg && recordArg.name == domainNameArg); 
-                })
-                done.resolve(filteredResponse[0]);
-            })
-        return done.promise;
-    };
-    createRecord(domainNameArg:string,typeArg:string,contentArg:string){
-        let done = plugins.q.defer();
-        let domain = new plugins.smartstring.Domain(domainNameArg);
-        this.getZoneId(domain.zoneName)
-            .then((domainIdArg)=>{
-                let dataObject = {
-                    name: domain.fullName,
-                    type: typeArg,
-                    content: contentArg
-                };
-                this.request("POST","/zones/" + domainIdArg + "/dns_records",dataObject)
-                    .then(function(responseArg){
-                        done.resolve(responseArg);
-                    });
-            });
-        return done.promise;
-    };
-    removeRecord(domainNameArg:string,typeArg:string){
-        let done = plugins.q.defer();
-        let domain = new plugins.smartstring.Domain(domainNameArg);
-        this.getRecord(domain.fullName,typeArg)
-            .then((responseArg) => {
-                if(responseArg){
-                    let requestRoute:string = "/zones/" + responseArg.zone_id + "/dns_records/" + responseArg.id; 
-                    this.request("DELETE",requestRoute)
-                        .then((responseArg) => {
-                            done.resolve(responseArg);
-                        });
-                } else {
-                    done.reject();
-                }
-            });
-        return done.promise;
-    };
-    updateRecord(domainNameArg:string,typeArg:string,valueArg){
-        let done = plugins.q.defer();
-        let domain = new plugins.smartstring.Domain(domainNameArg);
-        return done.promise;
-    };
-    listRecords(domainNameArg:string){
-        let done = plugins.q.defer();
-        let domain = new plugins.smartstring.Domain(domainNameArg);
-        this.getZoneId(domain.zoneName)
-            .then((domainIdArg)=>{
-                this.request("GET","/zones/" + domainIdArg + "/dns_records?per_page=100")
-                    .then(function(responseArg){
-                        done.resolve(responseArg);
-                    });
-            });
-        return done.promise;
-    }
-    listZones(domainName?:string){ // TODO: handle pagination
-        let done = plugins.q.defer();
-        let requestRoute = "/zones?per_page=50"
-        if(domainName) requestRoute = requestRoute + "&name=" + domainName;
-        let result = {}; 
-        this.request("GET",requestRoute)
-            .then(function(responseArg){
-                result = responseArg;
-                done.resolve(result);
-            });
-        return done.promise;
-    };
-    request(methodArg:string,routeArg:string,dataArg = {}){
-        let done = plugins.q.defer();
-        let jsonArg:string = JSON.stringify(dataArg);
-        let options = {
-            method:methodArg,
-            url:"https://api.cloudflare.com/client/v4" + routeArg,
-            headers:{
-                "Content-Type":"application/json",
-                "X-Auth-Email":this.authEmail,
-                "X-Auth-Key":this.authKey
-            },
-            body:jsonArg
-        };
-        //console.log(options);
-        plugins.request(options,function(err, res, body){
-            if (!err && res.statusCode == 200) {
-                var responseObj = JSON.parse(body);
-                done.resolve(responseObj);
-            } else {
-                console.log(err);
-                console.log(res);
-                done.reject(err);
-            };
-        });
-        return done.promise;
-    }
-};

ts/cflare.classes.helpers.ts

@@ -1,2 +0,0 @@
-import "typings-global";
-import plugins = require("./cflare.plugins");

ts/cflare.plugins.ts

@@ -1,5 +0,0 @@
-import "typings-global";
-export let beautylog = require("beautylog");
-export let q = require("q");
-export let request = require("request");
-export import smartstring = require("smartstring");

ts/cloudflare.classes.account.ts

@@ -0,0 +1,211 @@
+import * as plugins from './cloudflare.plugins.js';
+import { logger } from './cloudflare.logger.js';
+import * as interfaces from './interfaces/index.js';
+
+// interfaces
+import { WorkerManager } from './cloudflare.classes.workermanager.js';
+import { ZoneManager } from './cloudflare.classes.zonemanager.js';
+
+export class CloudflareAccount {
+  private authToken: string;
+  public preselectedAccountId: 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(authTokenArg: string) {
+    this.authToken = authTokenArg;
+    this.apiAccount = new plugins.cloudflare.Cloudflare({
+      apiToken: this.authToken,
+    });
+  }
+
+  public async preselectAccountByName(nameArg: string) {
+    const accounts = await this.convenience.listAccounts();
+    const account = accounts.find((accountArg) => {
+      return accountArg.name === nameArg;
+    });
+    if (account) {
+      this.preselectedAccountId = account.id;
+    } else {
+      throw new Error(`account with name ${nameArg} not found`);
+    }
+  }
+
+  public convenience = {
+    /**
+     * listAccounts
+     */
+    listAccounts: async () => {
+      const accounts: plugins.ICloudflareTypes['Account'][] = [];
+      for await (const account of this.apiAccount.accounts.list()) {
+        accounts.push(account as interfaces.ICloudflareApiAccountObject);
+      }
+      return accounts;
+    },
+    /**
+     * gets a zone id of a domain from cloudflare
+     * @param domainName
+     */
+    getZoneId: async (domainName: string) => {
+      const domain = new plugins.smartstring.Domain(domainName);
+      const zoneArray = await this.convenience.listZones(domain.zoneName);
+      const filteredResponse = zoneArray.filter((zoneArg) => {
+        return zoneArg.name === domainName;
+      });
+      if (filteredResponse.length >= 1) {
+        return filteredResponse[0].id;
+      } else {
+        logger.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
+     * @param domainNameArg
+     * @param typeArg
+     */
+    getRecord: async (
+      domainNameArg: string,
+      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`);
+      }
+    },
+
+    /**
+     * cleanrecord allows the cleaning of any previous records to avoid unwanted sideeffects
+     */
+    cleanRecord: async (domainNameArg: string, typeArg: plugins.tsclass.network.TDnsRecordType) => {
+      console.log(`cleaning record 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,
+        });
+      }
+    },
+
+    /**
+     * updates a record
+     * @param domainNameArg
+     * @param typeArg
+     * @param valueArg
+     */
+    updateRecord: async (
+      domainNameArg: string,
+      typeArg: plugins.tsclass.network.TDnsRecordType,
+      valueArg
+    ) => {
+      // TODO: implement
+      const domain = new plugins.smartstring.Domain(domainNameArg);
+    },
+    /**
+     * 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,3 @@
+import * as plugins from './cloudflare.plugins.js';
+
+export class CloudflareRecord {}

ts/cloudflare.classes.worker.ts

@@ -0,0 +1,93 @@
+import * as plugins from './cloudflare.plugins.js';
+import * as interfaces from './interfaces/index.js';
+import { WorkerManager } from './cloudflare.classes.workermanager.js';
+import { logger } from './cloudflare.logger.js';
+
+export interface IWorkerRoute extends interfaces.ICflareWorkerRoute {
+  zoneName: string;
+}
+
+export class CloudflareWorker {
+  // STATIC
+  public static async fromApiObject(
+    workerManager: WorkerManager,
+    apiObject
+  ): Promise<CloudflareWorker> {
+    const newWorker = new CloudflareWorker(workerManager);
+    Object.assign(newWorker, apiObject);
+    await newWorker.getRoutes();
+    return newWorker;
+  }
+
+  // INSTANCE
+  private workerManager: WorkerManager;
+
+  public script: string;
+  public id: string;
+  public etag: string;
+  // tslint:disable-next-line: variable-name
+  public created_on: string;
+  // tslint:disable-next-line: variable-name
+  public modified_on: string;
+
+  public routes: IWorkerRoute[] = [];
+  constructor(workerManagerArg: WorkerManager) {
+    this.workerManager = workerManagerArg;
+  }
+
+  /**
+   * gets all routes for a worker
+   */
+  public async getRoutes() {
+    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');
+        console.log(route);
+        console.log(this.id);
+        if (route.script === this.id) {
+          this.routes.push({ ...route, zoneName: zone.name });
+        }
+      }
+    }
+  }
+
+  public async setRoutes(routeArray: Array<{ zoneName: string; pattern: string }>) {
+    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';
+      let routeIdForUpdate: string;
+      for (const existingRoute of this.routes) {
+        if (existingRoute.pattern === newRoute.pattern) {
+          routeStatus = 'needsUpdate';
+          routeIdForUpdate = existingRoute.id;
+          if (existingRoute.script === this.id) {
+            routeStatus = 'alreadyUpToDate';
+            logger.log('info', `route already exists, no update needed`);
+          }
+        }
+      }
+
+      // lets care about actually setting routes
+      if (routeStatus === 'new') {
+        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,
+        });
+      } else if (routeStatus === 'needsUpdate') {
+        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,
+        });
+      }
+    }
+  }
+}

ts/cloudflare.classes.workermanager.ts

@@ -0,0 +1,38 @@
+import * as plugins from './cloudflare.plugins.js';
+import { CloudflareAccount } from './cloudflare.classes.account.js';
+import { CloudflareWorker } from './cloudflare.classes.worker.js';
+
+export class WorkerManager {
+  public cfAccount: CloudflareAccount;
+
+  constructor(cfAccountArg: CloudflareAccount) {
+    this.cfAccount = cfAccountArg;
+  }
+
+  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 worker;
+  }
+
+  /**
+   * lists workers
+   */
+  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;
+  }
+}

ts/cloudflare.classes.zone.ts

@@ -0,0 +1,9 @@
+import * as plugins from './cloudflare.plugins.js';
+
+export class CloudflareZone {
+  public static createFromApiObject(apiObject: plugins.ICloudflareTypes['Zone']) {
+    const cloudflareZone = new CloudflareZone();
+    Object.assign(cloudflareZone, apiObject);
+    return cloudflareZone;
+  }
+}

ts/cloudflare.classes.zonemanager.ts

@@ -0,0 +1,32 @@
+import * as plugins from './cloudflare.plugins.js';
+import * as interfaces from './interfaces/index.js';
+import { CloudflareAccount } from './cloudflare.classes.account.js';
+import { CloudflareZone } from './cloudflare.classes.zone.js';
+
+export class ZoneManager {
+  public cfAccount: CloudflareAccount;
+  public zoneName: string;
+
+  constructor(cfAccountArg: CloudflareAccount) {
+    this.cfAccount = cfAccountArg;
+  }
+
+  public async getZones(zoneName: string) {
+    let requestRoute = `/zones?per_page=50`;
+    // may be optionally filtered by domain name
+
+    if (zoneName) {
+      requestRoute = `${requestRoute}&name=${zoneName}`;
+    }
+
+    const response: any = await this.cfAccount.request('GET', requestRoute);
+    const apiObjects: interfaces.ICflareZone[] = response.result;
+
+    const cloudflareZoneArray = [];
+    for (const apiObject of apiObjects) {
+      cloudflareZoneArray.push(CloudflareZone.createFromApiObject(apiObject));
+    }
+
+    return cloudflareZoneArray;
+  }
+}

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

@@ -0,0 +1,24 @@
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartrequest from '@push.rocks/smartrequest';
+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/index.ts

@@ -1,2 +1,2 @@
-import "typings-global";
-export {CflareAccount} from "./cflare.classes.cflareaccount";
+export { CloudflareAccount } from './cloudflare.classes.account.js';
+export { CloudflareWorker } from './cloudflare.classes.worker.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.workerroute.ts

@@ -0,0 +1,5 @@
+export interface ICflareWorkerRoute {
+  id: string;
+  pattern: string;
+  script: string;
+}

ts/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from './cloudflare.api.account.js';
+export * from './cloudflare.api.workerroute.js';

ts/typings.json

@@ -1,9 +0,0 @@
-{
-  "version": false,
-  "dependencies": {},
-  "ambientDependencies": {
-    "colors": "registry:dt/colors#0.6.0-1+20160425153322",
-    "mocha": "registry:dt/mocha#2.2.5+20160317120654",
-    "node": "registry:dt/node#4.0.0+20160423143914"
-  }
-}

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"
+  ]
+}