@tidecloak/js 0.9.11

package/dist/types/modules/tide-js/Cryptide/Serialization.d.ts

@@ -0,0 +1,195 @@
+/**
+ *
+ * @param {BigInt} value
+ * @returns
+ */
+export function writeInt64LittleEndian(value: bigint): Uint8Array<ArrayBuffer>;
+/**
+ *
+ * @param {Uint8Array} bytes
+ * @returns
+ */
+export function readInt64LittleEndian(bytes: Uint8Array): bigint;
+/**
+ *
+ * @param {Uint8Array} initialValue
+ * @param {number} totalLength
+ * @param {number} version
+ * @returns
+ */
+export function CreateTideMemory(initialValue: Uint8Array, totalLength: number, version?: number): Uint8Array<ArrayBuffer>;
+/**
+ * @param {Uint8Array[]} datas
+ */
+export function CreateTideMemoryFromArray(datas: Uint8Array[]): Uint8Array<ArrayBuffer>;
+/**
+ *
+ * @param {Uint8Array} memory
+ * @param {number} index
+ * @param {Uint8Array} value
+ */
+export function WriteValue(memory: Uint8Array, index: number, value: Uint8Array): void;
+/**
+ *
+ * @param {Uint8Array} a
+ * @param {number} index
+ * @returns
+ */
+export function GetValue(a: Uint8Array, index: number): Uint8Array<ArrayBufferLike>;
+export function TryGetValue(a: any, index: any, returnObj: any): boolean;
+export function DeserializeNetworkKey(data: any): Point;
+/**
+ *
+ * @param {Point} p
+ */
+export function EdPointToJWK(p: Point): Promise<string>;
+/**
+ *
+ * @param {string} key
+ * @param {string} prefix
+ */
+export function DeserializeTIDE_KEY(key: string, prefix: string): bigint;
+export function GetUID(str: any): Promise<string>;
+/**
+ * @param {BigInt} num
+ * @returns {Uint8Array}
+ */
+export function BigIntToByteArray(num: bigint): Uint8Array;
+/**
+ * @param {Uint8Array} bytes
+ * @returns {bigint}
+ */
+export function BigIntFromByteArray(bytes: Uint8Array): bigint;
+/**
+ *
+ * @param {Uint8Array[]} arrays
+ */
+export function ConcatUint8Arrays(arrays: Uint8Array[]): Uint8Array<ArrayBuffer>;
+/**
+ * @param {Uint8Array} array1
+ * @param {Uint8Array} array2
+ */
+export function XOR(array1: Uint8Array, array2: Uint8Array): Uint8Array<ArrayBuffer>;
+/**
+ *
+ * @param {Array} array
+ * @param {number} length
+ * @param {object} padding
+ * @returns
+ */
+export function PadRight(array: any[], length: number, padding?: object): any[];
+/**
+ * @param {string} string
+ */
+export function StringToUint8Array(string: string): Uint8Array<ArrayBufferLike>;
+/**
+ * @param {Uint8Array} bytes
+ */
+export function StringFromUint8Array(bytes: Uint8Array): string;
+export function getBytesFromInt16(schemeInt: any): Uint8Array<ArrayBuffer>;
+/**
+ * @param {number} num
+ * @param {number} len Length of bytes requested
+ * @returns
+ */
+export function numberToUint8Array(num: number, len?: number): Uint8Array<ArrayBuffer>;
+/**
+ * @param {Uint8Array} array
+ */
+export function Uint8ArrayToNumber(byteArray: any): number;
+/**
+ * @param {string} base64
+ * @returns
+ */
+export function base64ToBase64Url(base64: string): string;
+/**
+ * @param {string} base64Url
+ * @returns
+ */
+export function base64UrlToBase64(base64Url: string): string;
+/**
+ * @param {number[]} array
+ * @returns
+ */
+export function bitArrayToUint8Array(array: number[]): Uint8Array<ArrayBuffer>;
+/**
+ * Works for .NET functions.
+ * @param {number[]} array
+ * @returns
+ */
+export function serializeBitArray(bitArray_p: any): Uint8Array<ArrayBuffer>;
+/**
+ *
+ * @param {(0|1)[]} bitarray1
+ * @param {(0|1)[]} bitarray2
+ * @returns
+ */
+export function bitArrayAND(bitarray1: (0 | 1)[], bitarray2: (0 | 1)[]): (0 | 1)[];
+/**
+ * Works for .NET functions.
+ * @param {Uint8Array} byteArray
+ * @returns
+ */
+export function deserializeBitArray(byteArray: Uint8Array): any[];
+export function uint8ArrayToBitArray(byteArray: any): number[];
+/**
+ * @param {string} string
+ * @returns {Uint8Array}
+ */
+export function Hex2Bytes(string: string): Uint8Array;
+/**
+ * @param {Uint8Array} byteArray
+ * @returns {string}
+ */
+export function Bytes2Hex(byteArray: Uint8Array): string;
+/**
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function bytesToBase64(bytes: Uint8Array): string;
+/**
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
+export function base64ToBytes(str: string): Uint8Array;
+export class AuthorizerPack {
+    constructor(data: any);
+    AuthFlow: string;
+    Authorizer: GVRK_Pack;
+    SignModels: string[];
+}
+export class GVRK_Pack {
+    constructor(data: any);
+    /** @type {Ed25519PublicComponent} */
+    GVRK: Ed25519PublicComponent;
+    Expiry: bigint;
+    encode(): Uint8Array<ArrayBuffer>;
+}
+export class Byte {
+    /**
+     * @param {Uint8Array} uint8Array
+     * @returns {Byte}
+     */
+    static fromUint8Array(uint8Array: Uint8Array): Byte;
+    /**
+     * Maximum number of 255
+     * @param {number} number
+     * @returns {Byte}
+     */
+    static fromNumber(number: number): Byte;
+    /**
+     * @type {number[]}
+     */
+    bits: number[];
+    /**
+     * Sets a bit at the start of the array (index 0)
+     * @param {number} bit
+     */
+    setFirstBit(bit: number): void;
+    /**
+     * @returns {Uint8Array}
+     */
+    toUint8Array(): Uint8Array;
+}
+import { Point } from "./Ed25519.js";
+import { Ed25519PublicComponent } from "./Components/Schemes/Ed25519/Ed25519Components.js";

package/dist/types/modules/tide-js/Cryptide/Signing/BlindSig.d.ts

@@ -0,0 +1,32 @@
+/**
+ *
+ * @param {Point} gR
+ * @param {Point} pub
+ * @param {Uint8Array} message
+ * @param {bigint} multiplier
+ */
+export function genBlindMessage(gR: Point, pub: Point, message: Uint8Array, multiplier: bigint): Promise<{
+    blurHCMKMul: bigint;
+    blur: bigint;
+    gRMul: Point;
+}>;
+/**
+ *
+ * @param {bigint} blindS
+ * @param {bigint} blur
+ */
+export function unblindSignature(blindS: bigint, blur: bigint): Promise<bigint>;
+/**
+ *
+ * @param {bigint} S
+ * @param {Point} noncePublic
+ * @param {Point} pub
+ * @param {Uint8Array} message
+ */
+export function verifyBlindSignature(S: bigint, noncePublic: Point, pub: Point, message: Uint8Array): Promise<boolean>;
+/**
+ * @param {bigint} S
+ * @param {Point} noncePublic
+ */
+export function serializeBlindSig(S: bigint, noncePublic: Point): Uint8Array<ArrayBuffer>;
+import { Point } from "../Ed25519.js";

package/dist/types/modules/tide-js/Cryptide/Signing/EdDSA.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Sign the msg with a private key in non-standard way as it uses a random number generator. Non-deterministic.
+ * @param {string | Uint8Array} msg
+ * @param {bigint} priv
+ * @returns A base64 encoding of the signature
+ */
+export function sign(msg: string | Uint8Array, priv: bigint): Promise<string>;
+/**
+ * Verify a EdDSA signature, given a signature, public key and message.
+ * @param {string} sig In base64
+ * @param {string | Point} pub
+ * @param {string | Uint8Array} msg
+ * @returns Boolean dependant on whether the signature is valid or not.
+ */
+export function verify(sig: string, pub: string | Point, msg: string | Uint8Array): Promise<boolean>;
+/**
+ * Verify a message with raw S and R
+ * @param {bigint} S
+ * @param {Point} R
+ * @param {Point} A
+ * @param {Uint8Array} M
+ */
+export function verifyRaw(S: bigint, R: Point, A: Point, M: Uint8Array): Promise<boolean>;
+import { Point } from "../Ed25519.js";

package/dist/types/modules/tide-js/Cryptide/Signing/TideSignature.d.ts

@@ -0,0 +1,50 @@
+export class TideSignatureFormat {
+    /**
+     * @param {string|Uint8Array} message
+     */
+    constructor(message: string | Uint8Array);
+    Name: any;
+    Version: any;
+    Header: () => string;
+    Footer: () => string;
+    Message: Uint8Array<ArrayBufferLike>;
+    /**
+     *
+     * @returns {Uint8Array}
+     */
+    format(): Uint8Array;
+}
+export class URLSignatureFormat extends TideSignatureFormat {
+    constructor(message: any);
+    Name: string;
+    Version: string;
+}
+export class ClientURLSignatureFormat extends TideSignatureFormat {
+    constructor(message: any);
+    Name: string;
+    Version: string;
+}
+export class PublicKeySignatureFormat extends TideSignatureFormat {
+    constructor(message: any);
+    Name: string;
+    Version: string;
+}
+export class AuthorizerSignatureFormat extends TideSignatureFormat {
+    constructor(authflow: any, modelIds: any, authorizer: any);
+    Name: string;
+    Version: string;
+    format(): Uint8Array<ArrayBuffer>;
+}
+export class TidecloakSettingsSignatureFormat extends TideSignatureFormat {
+    constructor(message: any);
+    Name: string;
+    Version: string;
+}
+export class TestSignatureFormat extends TideSignatureFormat {
+    constructor(message: any);
+    Name: string;
+    Version: string;
+}
+export class PlainSignatureFormat extends TideSignatureFormat {
+    format(): Uint8Array<ArrayBuffer>;
+}

package/dist/types/modules/tide-js/Cryptide/TideKey.d.ts

@@ -0,0 +1,24 @@
+export default class TideKey {
+    static NewKey(scheme: any): TideKey;
+    static FromSerializedComponent(c: any): TideKey;
+    constructor(c: any);
+    /**@type { BaseComponent } */
+    component: BaseComponent;
+    privateComponent: any;
+    publicComponent: any;
+    /**
+     *
+     * @returns {BasePrivateComponent}
+     */
+    get_private_component(): BasePrivateComponent;
+    /**
+     * @returns {BasePublicComponent}
+     */
+    get_public_component(): BasePublicComponent;
+    sign(message: any): Promise<any>;
+    verify(message: any, signature: any): Promise<any>;
+    prepVouchersReq(gORKn: any): Promise<any[]>;
+}
+import { BaseComponent } from "./Components/BaseComponent.js";
+import { BasePrivateComponent } from "./Components/BaseComponent.js";
+import { BasePublicComponent } from "./Components/BaseComponent.js";

package/dist/types/modules/tide-js/Cryptide/TideMemoryObjects.d.ts

@@ -0,0 +1,15 @@
+/**
+ *
+ * @param {Ed25519PublicComponent} gvrk
+ * @param {number | bigint} expiry
+ */
+export function CreateVRKPackage(gvrk: Ed25519PublicComponent, expiry: number | bigint): Uint8Array<ArrayBuffer>;
+/**
+ *
+ * @param {string} authFlow
+ * @param {string[]} signModels
+ * @param {Uint8Array} vrk_pack
+ * @returns
+ */
+export function CreateAuthorizerPackage(authFlow: string, signModels: string[], vrk_pack: Uint8Array): Uint8Array<ArrayBuffer>;
+import { Ed25519PublicComponent } from "./Components/Schemes/Ed25519/Ed25519Components.js";

package/dist/types/modules/tide-js/Cryptide/index.d.ts

@@ -0,0 +1,10 @@
+export { default as ElGamal } from "./Encryption/ElGamal.js";
+import * as AES from "./Encryption/AES.js";
+import * as DH from "./Encryption/DH.js";
+import * as EdDSA from "./Signing/EdDSA.js";
+import * as Hash from "./Hashing/Hash.js";
+import * as HashToPoint from "./Hashing/H2P.js";
+import * as Interpolation from "./Interpolation.js";
+import * as Math from "./Math.js";
+import * as Serialization from "./Serialization.js";
+export { AES, DH, EdDSA, Hash, HashToPoint, Interpolation, Math, Serialization };

package/dist/types/modules/tide-js/Flow/AuthenticationFlows/dCMKAcceptAdminFlow.d.ts

@@ -0,0 +1,2 @@
+export default class dCMKAcceptAdminFlow {
+}

package/dist/types/modules/tide-js/Flow/AuthenticationFlows/dCMKPasswordFlow.d.ts

@@ -0,0 +1,64 @@
+export default class dCMKPasswordFlow {
+    /**
+     * @param {KeyInfo} keyInfo
+     * @param {string} sessID
+     * @param {boolean} cmkCommitted
+     * @param {boolean} prismCommitted
+     * @param {string} voucherURL
+     * @param {string} purpose
+     */
+    constructor(keyInfo: KeyInfo, sessID: string, cmkCommitted: boolean, prismCommitted: boolean, voucherURL: string, purpose?: string);
+    keyInfo: KeyInfo;
+    sessID: string;
+    cmkCommitted: boolean;
+    prismCommitted: boolean;
+    voucherURL: string;
+    purpose: string;
+    cState: {
+        VUID: string;
+        blurHCMKMul: bigint;
+        r4: bigint;
+        gCMKAuth: Point;
+        authToken: import("../../Models/AuthRequest.js").default;
+        gRMul: Point;
+        selfRequesti: string[];
+        expired: number;
+        bitwise: (0 | 1)[];
+        prkECDHi: Uint8Array<ArrayBuffer>[];
+    } | undefined;
+    /**
+     * @param {TideKey} sessKey
+     * @param {Point} gSessKeyPub
+     * @param {Point} gPass
+     * @param {Point} gCMK
+     * @param {boolean} rememberMe
+     */
+    Convert(sessKey: TideKey, gPass: Point, gCMK: Point, rememberMe: boolean): Promise<{
+        VUID: string;
+    }>;
+    /**
+     *
+     * @param {TideKey} sessKey
+     * @param {Point} gSessKeyPub
+     * @param {Point} gPass
+     */
+    ConvertPassword(sessKey: TideKey, gPass: Point): Promise<{
+        bitwise: (0 | 1)[];
+        expired: number;
+        selfRequesti: string[];
+    }>;
+    /**
+     * @param {Point} gVRK If a null value is provided, no encryption is applied.
+     * @param {Uint8Array} sessKey
+     * @param {string} consentToSign
+     */
+    Authenticate(gVRK: Point, sessKey?: Uint8Array, consentToSign?: string): Promise<{
+        bitwise: (0 | 1)[];
+        expired: number;
+        selfRequesti: string[];
+        vendorEncryptedData: string;
+    }>;
+}
+import KeyInfo from "../../Models/Infos/KeyInfo.js";
+import { Point } from "../../Cryptide/Ed25519.js";
+import TideKey from "../../Cryptide/TideKey.js";

package/dist/types/modules/tide-js/Flow/AuthenticationFlows/dCMKPasswordlessFlow.d.ts

@@ -0,0 +1,37 @@
+export default class dCMKPasswordlessFlow {
+    /**
+     * @param {string} sessID
+     * @param {EnclaveEntry} flowInitData
+     * @param {string} voucherURL
+     */
+    constructor(sessID: string, flowInitData: EnclaveEntry, voucherURL: string);
+    sessID: string;
+    uid: string;
+    selfRequesti: string[];
+    bitwise: (0 | 1)[];
+    orks: import("../../index.js").OrkInfo[];
+    userPublic: Point;
+    sessKey: TideKey;
+    voucherURL: string;
+    cState: {
+        VUID: string;
+        gCMKAuth: Point;
+        blurHCMKMul: bigint;
+        r4: bigint;
+        gRMul: Point;
+        authToken: import("../../Models/AuthRequest.js").default;
+        prkECDHi: Uint8Array<ArrayBufferLike>[];
+        bitwise: (0 | 1)[];
+    } | undefined;
+    aState: any;
+    ConvertRemembered(): Promise<{
+        VUID: string;
+    }>;
+    /**
+     * @param {Point} gVRK If a null value is provided, no encryption is applied.
+     */
+    AuthenticateRemembered(gVRK: Point): Promise<string>;
+}
+import { Point } from "../../Cryptide/Ed25519.js";
+import TideKey from "../../Cryptide/TideKey.js";
+import EnclaveEntry from "../../Models/EnclaveEntry.js";

package/dist/types/modules/tide-js/Flow/AuthenticationFlows/dCVKAuthenticationFlow.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/tide-js/Flow/DecryptionFlows/dVVKDecryptionFlow.d.ts

@@ -0,0 +1,31 @@
+export default class dVVKDecryptionFlow {
+    /**
+     * @param {string} vvkid
+     * @param {Point} vvkPublic
+     * @param {OrkInfo[]} orks
+     * @param {TideKey} sessKey
+     * @param {Doken} doken
+     * @param {string} voucherURL
+     */
+    constructor(vvkid: string, vvkPublic: Point, orks: OrkInfo[], sessKey: TideKey, doken: Doken, voucherURL: string);
+    vvkid: string;
+    vvkPublic: Point;
+    orks: import("../../index.js").OrkInfo[];
+    sessKey: TideKey;
+    doken: Doken;
+    getVouchersFunction: ((request: string) => Promise<string>) | null;
+    voucherURL: string;
+    /**
+     * @param {(request: string) => Promise<string> } getVouchersFunction
+     * @returns {dVVKSigningFlow}
+     */
+    setVoucherRetrievalFunction(getVouchersFunction: (request: string) => Promise<string>): dVVKSigningFlow;
+    /**
+     * @param {BaseTideRequest} request
+     * @param {bool} waitForAll
+     */
+    start(request: BaseTideRequest, waitForAll?: bool): Promise<Uint8Array<ArrayBuffer>[]>;
+}
+import TideKey from "../../Cryptide/TideKey.js";
+import { Doken } from "../../Models/Doken.js";
+import BaseTideRequest from "../../Models/BaseTideRequest.js";

package/dist/types/modules/tide-js/Flow/EncryptionFlows/AuthorizedEncryptionFlow.d.ts

@@ -0,0 +1,75 @@
+/**
+ *
+ * @param {{
+ * vendorId: string,
+ * token: Doken,
+ * sessionKey: TideKey
+ * voucherURL: string,
+ * homeOrkUrl: string | null
+ * keyInfo: KeyInfo
+ * }} config
+ */
+export function AuthorizedEncryptionFlow(config: {
+    vendorId: string;
+    token: Doken;
+    sessionKey: TideKey;
+    voucherURL: string;
+    homeOrkUrl: string | null;
+    keyInfo: KeyInfo;
+}): void;
+export class AuthorizedEncryptionFlow {
+    /**
+     *
+     * @param {{
+     * vendorId: string,
+     * token: Doken,
+     * sessionKey: TideKey
+     * voucherURL: string,
+     * homeOrkUrl: string | null
+     * keyInfo: KeyInfo
+     * }} config
+     */
+    constructor(config: {
+        vendorId: string;
+        token: Doken;
+        sessionKey: TideKey;
+        voucherURL: string;
+        homeOrkUrl: string | null;
+        keyInfo: KeyInfo;
+    });
+    vvkId: string;
+    token: Doken;
+    sessKey: TideKey;
+    voucherURL: string;
+    vvkInfo: KeyInfo;
+    /**
+     *
+     * @param {[
+    * {
+    *      data: Uint8Array,
+    *      tags: string[]
+    * }
+    * ]} datasToEncrypt
+     * @returns
+     */
+    encrypt: (datasToEncrypt: [{
+        data: Uint8Array;
+        tags: string[];
+    }]) => Promise<Uint8Array<ArrayBuffer>[]>;
+    /**
+         *
+         * @param {[
+         * {
+         *    encrypted: Uint8Array,
+         *    tags: string[]
+         * }
+         * ]} datasToDecrypt
+         */
+    decrypt: (datasToDecrypt: [{
+        encrypted: Uint8Array;
+        tags: string[];
+    }]) => Promise<Uint8Array<ArrayBuffer>[]>;
+}
+import { Doken } from "../../Models/Doken.js";
+import TideKey from "../../Cryptide/TideKey.js";
+import KeyInfo from "../../Models/Infos/KeyInfo.js";

package/dist/types/modules/tide-js/Flow/SigningFlows/AuthorizedSigningFlow.d.ts

@@ -0,0 +1,51 @@
+/**
+ *
+ * @param {{
+* vendorId: string,
+* token: Doken,
+* sessionKey: TideKey
+* voucherURL: string,
+* homeOrkUrl: string | null
+* keyInfo: KeyInfo
+* }} config
+*/
+export function AuthorizedSigningFlow(config: {
+    vendorId: string;
+    token: Doken;
+    sessionKey: TideKey;
+    voucherURL: string;
+    homeOrkUrl: string | null;
+    keyInfo: KeyInfo;
+}): void;
+export class AuthorizedSigningFlow {
+    /**
+     *
+     * @param {{
+    * vendorId: string,
+    * token: Doken,
+    * sessionKey: TideKey
+    * voucherURL: string,
+    * homeOrkUrl: string | null
+    * keyInfo: KeyInfo
+    * }} config
+    */
+    constructor(config: {
+        vendorId: string;
+        token: Doken;
+        sessionKey: TideKey;
+        voucherURL: string;
+        homeOrkUrl: string | null;
+        keyInfo: KeyInfo;
+    });
+    vvkId: string;
+    token: Doken;
+    voucherURL: string;
+    sessKey: TideKey;
+    vvkInfo: KeyInfo;
+    /**
+     * @param {Uint8Array} tideSerializedRequest
+     */
+    signv2: (tideSerializedRequest: Uint8Array) => Promise<Uint8Array<ArrayBuffer>[]>;
+}
+import TideKey from "../../Cryptide/TideKey.js";
+import KeyInfo from "../../Models/Infos/KeyInfo.js";

package/dist/types/modules/tide-js/Flow/SigningFlows/dTestVVkSigningFlow.d.ts

@@ -0,0 +1,25 @@
+export default class dTestVVKSigningFlow {
+    /**
+     * @param {string} vvkid
+     * @param {Point} vvkPublic
+     * @param {OrkInfo[]} orks
+     * @param {Uint8Array} sessKey
+     * @param {Point} gSessKey
+     * @param {BigInt} vrk
+     * @param {Uint8Array} authorizer
+     * @param {Uint8Array} authorizerCert
+     * @param {string} voucherURL
+     */
+    constructor(vvkid: string, vvkPublic: Point, orks: OrkInfo[], sessKey: Uint8Array, gSessKey: Point, vrk: bigint, authorizer: Uint8Array, authorizerCert: Uint8Array, voucherURL: string);
+    vvkid: string;
+    vvkPublic: Point;
+    orks: OrkInfo[];
+    sessKey: Uint8Array<ArrayBufferLike>;
+    gSessKey: Point;
+    vrk: bigint;
+    authorizer: Uint8Array<ArrayBufferLike>;
+    authorizerCert: Uint8Array<ArrayBufferLike>;
+    voucherURL: string;
+    start(): Promise<void>;
+}
+import OrkInfo from "../../Models/Infos/OrkInfo.js";

package/dist/types/modules/tide-js/Flow/SigningFlows/dVVKSigningFlow.d.ts

@@ -0,0 +1,32 @@
+export default class dVVKSigningFlow {
+    /**
+     * @param {string} vvkid
+     * @param {Point} vvkPublic
+     * @param {OrkInfo[]} orks
+     * @param {TideKey} sessKey
+     * @param {Doken} doken
+     * @param {string} voucherURL
+     */
+    constructor(vvkid: string, vvkPublic: Point, orks: OrkInfo[], sessKey: TideKey, doken: Doken, voucherURL: string);
+    vvkid: string;
+    vvkPublic: Point;
+    orks: OrkInfo[];
+    doken: string | undefined;
+    sessKey: TideKey;
+    getVouchersFunction: ((request: string) => Promise<string>) | null;
+    voucherURL: string;
+    /**
+     * @param {(request: string) => Promise<string> } getVouchersFunction
+     * @returns {dVVKSigningFlow}
+     */
+    setVoucherRetrievalFunction(getVouchersFunction: (request: string) => Promise<string>): dVVKSigningFlow;
+    /**
+     * @param {BaseTideRequest} request
+     * @param {bool} waitForAll
+     */
+    start(request: BaseTideRequest, waitForAll?: bool): Promise<Uint8Array<ArrayBuffer>[]>;
+}
+import OrkInfo from "../../Models/Infos/OrkInfo.js";
+import TideKey from "../../Cryptide/TideKey.js";
+import BaseTideRequest from "../../Models/BaseTideRequest.js";
+import { Doken } from "../../Models/Doken.js";