@tidecloak/js 0.9.11

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

@@ -0,0 +1,30 @@
+export default class dVVKSigningFlow_DEPRECATED {
+    /**
+     * @param {string} vvkid
+     * @param {Point} vvkPublic
+     * @param {OrkInfo[]} orks
+     * @param {Uint8Array} sessKey
+     * @param {Point} gSessKey
+     * @param {string} voucherURL
+     */
+    constructor(vvkid: string, vvkPublic: Point, orks: OrkInfo[], sessKey: Uint8Array, gSessKey: Point, voucherURL: string);
+    vvkid: string;
+    vvkPublic: Point;
+    orks: OrkInfo[];
+    sessKey: Uint8Array<ArrayBufferLike>;
+    gSessKey: Point;
+    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 BaseTideRequest from "../../Models/BaseTideRequest.js";

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

@@ -0,0 +1,13 @@
+export default class SimulatorFlow {
+    /**
+     *
+     * @returns {OrkInfo[]}
+     */
+    static GetSomeOrks(): OrkInfo[];
+    /**
+     * @param {OrkInfo[]} orks
+     * @returns {OrkInfo[]}
+     */
+    static FilterInactiveOrks(orks: OrkInfo[]): OrkInfo[];
+}
+import OrkInfo from "../Models/Infos/OrkInfo.js";

package/dist/types/modules/tide-js/Flow/VoucherFlows/VoucherFlow.d.ts

@@ -0,0 +1,23 @@
+export default class VoucherFlow {
+    /**
+     * @param {Point[]} orkPaymentPublics
+     * @param {string} voucherURL
+     * @param {string} action
+     */
+    constructor(orkPaymentPublics: Point[], voucherURL: string, action: string);
+    orkPaymentPublics: Point[];
+    voucherURL: string;
+    action: string;
+    /**
+     * I'm making this so I can use keycloak's client that has all of the keycloak's authorization built in.
+     * @param {(request: string) => Promise<string>} clientFunction
+     * @returns
+     */
+    GetVouchers(clientFunction?: (request: string) => Promise<string>): Promise<{
+        vouchers: VoucherResponse;
+        k: TideKey;
+    }>;
+}
+import { Point } from "../../Cryptide/Ed25519.js";
+import VoucherResponse from "../../Models/Responses/Vendor/VoucherResponse.js";
+import TideKey from "../../Cryptide/TideKey.js";

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

@@ -0,0 +1,41 @@
+export default class dAccountRecoveryFlow {
+    /**
+     * @param {string} uid
+     * @param {OrkInfo[]} orks
+     * @param {TideKey} sessKey
+     * @param {string} voucherURL
+     */
+    constructor(uid: string, orks: OrkInfo[], sessKey: TideKey, voucherURL: string);
+    uid: string;
+    orks: OrkInfo[];
+    sessKey: TideKey;
+    voucherURL: string;
+    rState: {
+        bitwise: any;
+        selfRequesti: any[];
+        expiry: number;
+    } | undefined;
+    StartAccountRecovery(homeOrkUrl: any, pollingClient: any, signal: any): Promise<{
+        status: string;
+        channelId?: undefined;
+    } | {
+        channelId: any;
+        status?: undefined;
+    }>;
+    /**
+     * @returns
+     */
+    RetrieveEmailAuths(channelId: any, progressTrackerCallback: any, pollingClient: any, signal: any): Promise<{
+        status: any;
+    }>;
+    /**
+     * @param {Point} currentUserPublic
+     * @param {Point} newGPass
+     * @param {Point} gVRK
+     */
+    GenerateNewPrism(currentUserPublic: Point, newGPass: Point, gVRK: Point): Promise<void>;
+    CleanUpRecoverySession(channelId: any): Promise<void>;
+}
+import OrkInfo from "../Models/Infos/OrkInfo.js";
+import TideKey from "../Cryptide/TideKey.js";
+import { Point } from "../Cryptide/Ed25519.js";

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

@@ -0,0 +1,104 @@
+export default class dKeyGenerationFlow {
+    static ReserveUID(uid: any, voucherURL: any, gSessKeyPub: any): Promise<{
+        reservationConfirmation: any;
+        activeOrks: OrkInfo[];
+    }>;
+    /**
+     * @param {string} uid
+     * @param {string} gVRK
+     * @param {OrkInfo[]} orks
+     * @param {Uint8Array} sessKey
+     * @param {Point} gSessKeyPub
+     * @param {string} purpose
+     * @param {string} voucherURL
+     * @param {string[]} emails
+     * @param {(0|1)[]} bitwise
+     * @param {string[]} selfRequesti
+     * @param {Point} userPublic
+     * @param {number} expired
+     */
+    constructor(uid: string, gVRK: string, orks: OrkInfo[], sessKey: Uint8Array, gSessKeyPub: Point, purpose: string, voucherURL: string, emails?: string[], bitwise?: (0 | 1)[], selfRequesti?: string[], userPublic?: Point, expired?: number);
+    uid: string;
+    gVRK: Point | undefined;
+    bitwise: (0 | 1)[] | null;
+    orks: OrkInfo[];
+    selfRequesti: string[];
+    userPublic: Point;
+    sessKey: Uint8Array<ArrayBufferLike>;
+    gSessKeyPub: Point;
+    purpose: string;
+    voucherURL: string;
+    emails: string[];
+    getVouchersFunction: ((request: string) => Promise<string>) | null;
+    savedOrkPublics: Point[];
+    orksToWaitFor: number;
+    /**
+     * @param {(request: string) => Promise<string> } getVouchersFunction
+     * @returns {dKeyGenerationFlow}
+     */
+    setVoucherRetrievalFunction(getVouchersFunction: (request: string) => Promise<string>): dKeyGenerationFlow;
+    /**
+     * @param {number} numKeys
+     * @param {Point[]} gMultipliers
+     * @param {string} reservationAuth
+     */
+    GenShard(numKeys: number, gMultipliers: Point[], reservationAuth?: string): Promise<{
+        gMultiplied: any;
+        gK: Point | undefined;
+    }>;
+    gState: {
+        gMultiplied: any;
+        gR: Point | null;
+        gK: Point | undefined;
+        timestamp: bigint;
+        sortedShares: string[][];
+        VRK_gR: (Point | null)[] | null;
+        bitwise: (0 | 1)[];
+        keyUse: string[];
+        prkECHi: Uint8Array<ArrayBuffer>[];
+    } | {
+        gMultiplied: any;
+        gR: Point | null;
+        gK: Point | undefined;
+        timestamp: bigint;
+        sortedShares: string[][];
+        VRK_gR: (Point | null)[] | null;
+        bitwise: any[];
+        prkECHi: Uint8Array<ArrayBuffer>[];
+    } | undefined;
+    /**
+     * @param {string} auth
+     * @param {string} authSig
+     */
+    GenVVKShard(auth: string, authSig: string): Promise<{
+        gK: Point | undefined;
+    }>;
+    /**
+     * @param {string} authorizer
+     * @param {string} keyType
+     */
+    SetShard(authorizer: string, keyType: string): Promise<{
+        VRK_SIGNATURE_TO_STORE: Uint8Array<ArrayBuffer>;
+        M: string;
+        FIRST_ADMIN: {
+            authorizer: string;
+            certificate: Uint8Array<ArrayBuffer>;
+        };
+    }>;
+    sState: {
+        S: bigint;
+        gR: Point;
+        gSessKeyPub: Point;
+        M: Uint8Array<ArrayBuffer>;
+        vrkSignatureToStore: Uint8Array<ArrayBuffer>;
+        firstAdmin: {
+            authorizer: string;
+            certificate: Uint8Array<ArrayBuffer>;
+        };
+    } | undefined;
+    /**
+     */
+    Commit(): Promise<void>;
+}
+import { Point } from "../Cryptide/Ed25519.js";
+import OrkInfo from "../Models/Infos/OrkInfo.js";

package/dist/types/modules/tide-js/Math/DecryptRequest.d.ts

@@ -0,0 +1,19 @@
+export default class DecryptRequest {
+    /**
+     *
+     * @param {Uint8Array[]} serializedFields
+     * @param {Uint8Array[]} ECDHi
+     */
+    static generateRequests(serializedFields: Uint8Array[], ECDHi: Uint8Array[]): Promise<{
+        encRequests: string[];
+        encryptedFields: any[];
+        tags: any[];
+    }>;
+    /**
+     * @param {Uint8Array[]} encryptedFields
+     * @param {Uint8Array[]} ECDHi
+     * @param {string[]} encryptedFieldKeys
+     * @param {bignt[]} lis
+     */
+    static decryptFields(encryptedFields: Uint8Array[], ECDHi: Uint8Array[], encryptedFieldKeys: string[], lis: bignt[]): Promise<Uint8Array<ArrayBuffer>[]>;
+}

package/dist/types/modules/tide-js/Math/EncryptRequest.d.ts

@@ -0,0 +1,57 @@
+export default class EncryptRequest {
+    /**
+     *
+     * @param {Point} gCVK
+     * @param {Uint8Array} fieldDatum
+     * @param {number} timestamp
+     */
+    static generatePartialRequest(gCVK: Point, fieldDatum: Uint8Array, timestamp: number): Promise<{
+        C1: Point;
+        EncField: Uint8Array<ArrayBuffer>;
+        EncFieldChk: Uint8Array<ArrayBuffer>;
+        timestamp: number;
+    }>;
+    /**
+     * @param {{
+            C1: Point;
+            EncField: Uint8Array;
+            EncFieldChk: Uint8Array;
+            timestamp: number;
+        }[]} partialRequests
+     * @param {bigint} li
+     * @param {Datum[]} datums
+     * @param {Point[]} gCVKRi
+     * @param {Uint8Array} ECDHi
+     */
+    static generateEncryptedRequest(partialRequests: {
+        C1: Point;
+        EncField: Uint8Array;
+        EncFieldChk: Uint8Array;
+        timestamp: number;
+    }[], li: bigint, datums: Datum[], gCVKRi: Point[], ECDHi: Uint8Array): Promise<string>;
+    /**
+     * Will decrypt encrypted sigs, validate those sigs, and generate the serialized fields for the vendor to store
+     * @param {string[]} encryptedS
+     * @param  {{
+            EncFields: Uint8Array[];
+            EncFieldChks: Uint8Array[];
+            C1s: Point[];
+            Tags: number[];
+            GCVKRi: Point[];
+            Timestamp: number;
+        }} plainRequest
+     * @param {bigint[]} lis
+     * @param {Uint8Array[]} ECDHi
+     * @param {Point} gCVK
+     */
+    static generateSerializedFields(encryptedS: string[], plainRequest: {
+        EncFields: Uint8Array[];
+        EncFieldChks: Uint8Array[];
+        C1s: Point[];
+        Tags: number[];
+        GCVKRi: Point[];
+        Timestamp: number;
+    }, lis: bigint[], ECDHi: Uint8Array[], gCVK: Point): Promise<Uint8Array<ArrayBuffer>[]>;
+}
+import { Point } from "../Cryptide/Ed25519.js";
+import Datum from "../Models/Datum.js";

package/dist/types/modules/tide-js/Math/KeyAuthentication.d.ts

@@ -0,0 +1,95 @@
+/**
+ * For use in change password flow
+ * @param {PrismConvertResponse[]} convertResponses
+ * @param {bigint[]} lis
+ * @param {Point[]} mgORKi
+ * @param {bigint} r1
+ * @returns
+ */
+export function GetDecryptedChallenge(convertResponses: PrismConvertResponse[], lis: bigint[], mgORKi: Point[], r1: bigint): Promise<string[]>;
+/**
+ * @param {PrismConvertResponse[]} convertResponses
+ * @param {bigint[]} ids
+ * @param {Point[]} mgORKi
+ * @param {bigint} r1
+ * @param {Uint8Array[]} prkECDHi
+ */
+export function PrismConvertReply(convertResponses: PrismConvertResponse[], ids: bigint[], mgORKi: Point[], r1: bigint, prkECDHi: Uint8Array[]): Promise<{
+    prismAuthis: Uint8Array<ArrayBuffer>[];
+    timestampi: bigint;
+    selfRequesti: string[];
+    expired: number;
+}>;
+/**
+ * @param {CMKConvertResponse[]} convertResponses
+ * @param {bigint[]} ids
+ * @param {Uint8Array[]} prismAuthis
+ * @param {Point} gCMK
+ * @param {bigint} timestampi
+ * @param {string} sessID
+ * @param {string} purpose
+ * @param {Point} qPub
+ * @param {bigint} uDeObf
+ * @param {bigint} blurerKPriv
+ * @param {Ed25519PublicComponent} gSessKeyPub
+ */
+export function CmkConvertReply(convertResponses: CMKConvertResponse[], ids: bigint[], prismAuthis: Uint8Array[], gCMK: Point, timestampi: bigint, sessID: string, purpose: string, qPub: Point, uDeObf: bigint, blurerKPriv: bigint, gSessKeyPub: Ed25519PublicComponent): Promise<{
+    VUID: string;
+    blurHCMKMul: bigint;
+    r4: bigint;
+    gCMKAuth: Point;
+    authToken: AuthRequest;
+    gRMul: Point;
+}>;
+/**
+ * @param {ConvertRememberedResponse[]} responses
+ * @param {bigint[]} mIdORKi
+ * @param {Point} gCMK
+ * @param {string} sessID
+ * @param {Uint8Array[]} prkECDHi
+ * @param {Point} qPub
+ * @param {bigint} uDeObf
+ * @param {bigint} blurerKPriv
+ * @param {Ed25519PublicComponent} gSessKeyPub
+ */
+export function ConvertRememberedReply(responses: ConvertRememberedResponse[], mIdORKi: bigint[], gCMK: Point, sessID: string, prkECDHi: Uint8Array[], qPub: Point, uDeObf: bigint, blurerKPriv: bigint, gSessKeyPub: Ed25519PublicComponent): Promise<{
+    VUID: string;
+    gCMKAuth: Point;
+    blurHCMKMul: bigint;
+    r4: bigint;
+    gRMul: Point;
+    authToken: AuthRequest;
+    prkECDHi: Uint8Array<ArrayBufferLike>[];
+}>;
+/**
+ *
+ * @param {string} vuid
+ * @param {Uint8Array[]} prkECDHi
+ * @param {string[]} encSigi
+ * @param {Point} gCMKAuth
+ * @param {AuthRequest} authToken
+ * @param {bigint} r4
+ * @param {Point} gRMul
+ * @param {Point} gVRK
+ */
+export function AuthenticateBasicReply(vuid: string, prkECDHi: Uint8Array[], encSigi: string[], gCMKAuth: Point, authToken: AuthRequest, r4: bigint, gRMul: Point, gVRK: Point): Promise<string>;
+/**
+ *
+ * @param {string} vuid
+ * @param {Uint8Array[]} prkECDHi
+ * @param {string[]} encSigi
+ * @param {Point} gCMKAuth
+ * @param {AuthRequest} authToken
+ * @param {bigint} r4
+ * @param {Point} gRMul
+ * @param {Point} gVRK
+ * @param {bigint} sessKey
+ * @param {string} consentToSign
+ */
+export function AuthenticateConsentReply(vuid: string, prkECDHi: Uint8Array[], encSigi: string[], gCMKAuth: Point, authToken: AuthRequest, r4: bigint, gRMul: Point, gVRK: Point, sessKey: bigint, consentToSign: string): Promise<string>;
+import PrismConvertResponse from "../Models/Responses/KeyAuth/Convert/PrismConvertResponse.js";
+import { Point } from "../Cryptide/Ed25519.js";
+import CMKConvertResponse from "../Models/Responses/KeyAuth/Convert/CMKConvertResponse.js";
+import { Ed25519PublicComponent } from "../Cryptide/Components/Schemes/Ed25519/Ed25519Components.js";
+import AuthRequest from "../Models/AuthRequest.js";
+import ConvertRememberedResponse from "../Models/Responses/KeyAuth/Convert/ConvertRememberedResponse.js";

package/dist/types/modules/tide-js/Math/KeyDecryption.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {Point[][]} appliedC1s
+ * @param {bigint[]} ids
+ */
+export function GetKeys(appliedC1s: Point[][], ids: bigint[]): Promise<Uint8Array<ArrayBuffer>[]>;
+import { Point } from "../Cryptide/Ed25519.js";

package/dist/types/modules/tide-js/Math/KeyGeneration.d.ts

@@ -0,0 +1,42 @@
+/**
+* @param {GenShardResponse[]} responses Can be T amount
+* @param {(0 | 1)[]} bitwise
+* @param {Uint8Array} sessKey
+* @param {boolean} vrkSigning
+*/
+export function ProcessShards(responses: GenShardResponse[], bitwise: (0 | 1)[], sessKey: Uint8Array, vrkSigning?: boolean): Promise<{
+    gMultiplied: any;
+    gR: Point | null;
+    gK: Point | undefined;
+    timestamp: bigint;
+    sortedShares: string[][];
+    VRK_gR: (Point | null)[] | null;
+}>;
+/**
+ * @param {string} keyId
+ * @param {SetShardResponse[]} sendShardResponses
+ * @param {Point[]} mgORKi
+ * @param {bigint} timestamp
+ * @param {Point} R
+ * @param {Point} gK1
+ * @param {(0|1)[]} participatingBitwise
+ * @param {string} purpose
+ * @param {Uint8Array} sessKey
+ * @param {Point} gSessKeyPub
+ * @param {Point[] | null} vrk_gR
+ * @param {string | null} authorizer_package
+ */
+export function CommitShardPrep(keyId: string, sendShardResponses: SetShardResponse[], mgORKi: Point[], timestamp: bigint, R: Point, gK1: Point, participatingBitwise: (0 | 1)[], purpose: string, sessKey: Uint8Array, gSessKeyPub: Point, vrk_gR?: Point[] | null, authorizer_package?: string | null): Promise<{
+    S: bigint;
+    gR: Point;
+    gSessKeyPub: Point;
+    M: Uint8Array<ArrayBuffer>;
+    vrkSignatureToStore: Uint8Array<ArrayBuffer>;
+    firstAdmin: {
+        authorizer: string;
+        certificate: Uint8Array<ArrayBuffer>;
+    };
+}>;
+import GenShardResponse from "../Models/Responses/KeyGen/GenShard/GenShardResponse.js";
+import { Point } from "../Cryptide/Ed25519.js";
+import SetShardResponse from "../Models/Responses/KeyGen/SetShard/SetShardResponse.js";

package/dist/types/modules/tide-js/Math/KeySigning.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {Point[][]} GRij
+ */
+export function PreSign(GRij: Point[][]): Point[];
+/**
+ *
+ * @param {BigInt[][]} Sis
+ */
+export function Sign(Sis: bigint[][]): bigint[];
+import { Point } from "../Cryptide/Ed25519.js";

package/dist/types/modules/tide-js/Models/AdminAuthorization.d.ts

@@ -0,0 +1,16 @@
+export class AdminAuthorization {
+    static fromString(s: any): AdminAuthorization;
+    constructor(...args: any[]);
+    adminContext: any;
+    adminCertificate: any;
+    adminTideAuthMsg: any;
+    blindSig: any;
+    approvalSig: any;
+    EncodedApproval: Uint8Array<ArrayBuffer> | null;
+    compareInitCertHash(initCertHash: any): any;
+    getInitCertHash(): any;
+    encodeContext(): Uint8Array<ArrayBufferLike>;
+    getAdminCert(): any;
+    encodeApproval(): Uint8Array<ArrayBuffer>;
+    toString(): any;
+}

package/dist/types/modules/tide-js/Models/AuthRequest.d.ts

@@ -0,0 +1,28 @@
+export default class AuthRequest {
+    /**
+     * @param {string} keyId
+     * @param {string} purpose
+     * @param {string} clientKey
+     * @param {bigint} expiry
+     * @param {string} sessionId
+     * @returns
+     */
+    static "new"(keyId: string, purpose: string, clientKey: string, expiry: bigint, sessionId?: string): AuthRequest;
+    static from(data: any): AuthRequest;
+    /**
+     *
+     * @param {string} keyId
+     * @param {string} purpose
+     * @param {string} keyPub
+     * @param {bigint} expiry
+     * @param {string} sessionId
+     */
+    constructor(keyId: string, purpose: string, keyPub: string, expiry: bigint, sessionId?: string);
+    keyId: string;
+    purpose: string;
+    keyPub: string;
+    expiry: bigint;
+    sessionId: string;
+    toUint8Array(): Uint8Array<ArrayBufferLike>;
+    toString(): string;
+}

package/dist/types/modules/tide-js/Models/AuthorizationBuilder.d.ts

@@ -0,0 +1,17 @@
+export default class AuthorizationBuilder {
+    constructor(tideRequest?: null, authorizationPacks?: null, ruleSettings?: null);
+    tideRequest: BaseTideRequest | null;
+    authorizationPacks: Uint8Array<ArrayBufferLike> | null;
+    ruleSettings: any;
+    /**
+     * @param {BaseTideRequest} request
+     */
+    setTideRequest(request: BaseTideRequest): void;
+    /**
+     * @param {Uint8Array} authPacks
+     */
+    setAuthorizationPacks(authPacks: Uint8Array): void;
+    setRuleSettings(ruleSettings: any): void;
+    addAuthorization(): void;
+}
+import BaseTideRequest from "./BaseTideRequest.js";

package/dist/types/modules/tide-js/Models/BaseTideRequest.d.ts

@@ -0,0 +1,52 @@
+export default class BaseTideRequest {
+    /**
+     *
+     * @param {string} name
+     * @param {string} version
+     * @param {string} authFlow
+     * @param {Uint8Array} draft
+     * @param {Uint8Array} dyanmicData
+     */
+    constructor(name: string, version: string, authFlow: string, draft: Uint8Array, dyanmicData?: Uint8Array);
+    name: string;
+    version: string;
+    authFlow: string;
+    draft: Uint8Array<ArrayBuffer>;
+    dyanmicData: Uint8Array<ArrayBuffer>;
+    authorization: Uint8Array<ArrayBuffer>;
+    authorizerCert: Uint8Array<ArrayBuffer>;
+    authorizer: Uint8Array<ArrayBuffer>;
+    expiry: any;
+    rules: Uint8Array<ArrayBuffer>;
+    rulesCert: Uint8Array<ArrayBuffer>;
+    /**
+     *
+     * @param {number} timeFromNowInSeconds
+     */
+    setCustomExpiry(timeFromNowInSeconds: number): this;
+    /**
+     * @param {Uint8Array} authorizer
+     */
+    addAuthorizer(authorizer: Uint8Array): void;
+    /**
+     *
+     * @param {Uint8Array} authorizerCertificate
+     */
+    addAuthorizerCertificate(authorizerCertificate: Uint8Array): void;
+    /**
+     *
+     * @param {Uint8Array} authorization
+     */
+    addAuthorization(authorization: Uint8Array): this;
+    /**
+     * @param {Uint8Array} rules
+     */
+    addRules(rules: Uint8Array): void;
+    /**
+     *
+     * @param {Uint8Array} rulesCert
+     */
+    addRulesCert(rulesCert: Uint8Array): void;
+    dataToAuthorize(): Promise<Uint8Array<ArrayBufferLike>>;
+    encode(): Uint8Array<ArrayBuffer>;
+}

package/dist/types/modules/tide-js/Models/Cardano/CardanoTxBody.d.ts

@@ -0,0 +1,16 @@
+export default class CardanoTxBody {
+    constructor(data: any);
+    transaction: CardanoTransaction;
+    toPrettyObject(): any;
+}
+declare class CardanoTransaction {
+    static deserializeTransaction(cborBytes: any): CardanoTransaction;
+    static parseTransaction(data: any): CardanoTransaction;
+    constructor(inputs: any, outputs: any, fee: any, ttl?: null);
+    inputs: any;
+    outputs: any;
+    fee: any;
+    ttl: any;
+    totalInputAmount(utxos: any): bigint;
+}
+export {};

package/dist/types/modules/tide-js/Models/Datum.d.ts

@@ -0,0 +1,14 @@
+export default class Datum {
+    static fromJSON(json: any): Datum;
+    /**
+     * @param {string|Uint8Array} Data
+     * @param {number} Tag
+     */
+    constructor(Data: string | Uint8Array, Tag: number);
+    data: Uint8Array<ArrayBufferLike>;
+    tag: number;
+    toObject(): {
+        Data: string;
+        Tag: number;
+    };
+}

package/dist/types/modules/tide-js/Models/Doken.d.ts

@@ -0,0 +1,52 @@
+/**
+ *
+ * @param {string} data
+ */
+export function Doken(data: string): void;
+export class Doken {
+    /**
+     *
+     * @param {string} data
+     */
+    constructor(data: string);
+    dataRef: string;
+    header: any;
+    payload: {
+        sessionKey: Ed25519PublicComponent;
+        tideuserkey: Ed25519PublicComponent;
+        vuid: any;
+        homeOrk: string;
+        exp: any;
+        aud: any;
+        realm_access: any;
+        resource_access: any;
+        serialize(): string;
+    };
+    signature: Uint8Array<ArrayBufferLike>;
+    isExpired: () => boolean;
+    setNewSessionKey: (sessionKey: any) => void;
+    setNewSignature: (sig: any) => void;
+    /**
+     *
+     * @param {TideKey} sessionKeyToCheck
+     */
+    validate: (sessionKeyToCheck?: TideKey) => {
+        success: boolean;
+        reason: string;
+    } | {
+        success: boolean;
+        reason?: undefined;
+    };
+    /**
+     *
+     * @param {Ed25519PublicComponent} vendorPublic
+     */
+    verify: (vendorPublic: Ed25519PublicComponent) => Promise<any>;
+    /**
+     *
+     * @returns {string}
+     */
+    serialize: () => string;
+}
+import { Ed25519PublicComponent } from "../Cryptide/Components/Schemes/Ed25519/Ed25519Components.js";
+import TideKey from "../Cryptide/TideKey.js";

package/dist/types/modules/tide-js/Models/EnclaveEntry.d.ts

@@ -0,0 +1,22 @@
+export default class EnclaveEntry {
+    static from(data: any): EnclaveEntry;
+    /**
+     * @param {string} username
+     * @param {string} persona
+     * @param {bigint} expired
+     * @param {KeyInfo} userInfo
+     * @param {(0|1)[]} orksBitwise
+     * @param {string[]} selfRequesti
+     * @param {Uint8Array} sessKey
+     */
+    constructor(username: string, persona: string, expired: bigint, userInfo: KeyInfo, orksBitwise: (0 | 1)[], selfRequesti: string[], sessKey: Uint8Array);
+    username: string;
+    persona: string;
+    expired: bigint;
+    userInfo: KeyInfo;
+    orksBitwise: (0 | 1)[];
+    selfRequesti: string[];
+    sessKey: Uint8Array<ArrayBufferLike>;
+    toString(): string;
+}
+import KeyInfo from "./Infos/KeyInfo.js";