@dfns/sdk 0.1.0-alpha.1

package/codegen/datamodel/PublicKeys/types.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionStatus = exports.TransactionTemplateKind = exports.SignatureStatus = exports.PublicKeyStatus = void 0;
+// FIXME: Missing documentation for PublicKeyStatus
+var PublicKeyStatus;
+(function (PublicKeyStatus) {
+    // FIXME: Missing documentation for Active
+    PublicKeyStatus["Active"] = "Active";
+    // FIXME: Missing documentation for Disabled
+    PublicKeyStatus["Disabled"] = "Disabled";
+    // FIXME: Missing documentation for Compromised
+    PublicKeyStatus["Compromised"] = "Compromised";
+})(PublicKeyStatus = exports.PublicKeyStatus || (exports.PublicKeyStatus = {}));
+// FIXME: Missing documentation for SignatureStatus
+var SignatureStatus;
+(function (SignatureStatus) {
+    // FIXME: Missing documentation for Pending
+    SignatureStatus["Pending"] = "Pending";
+    // FIXME: Missing documentation for Executed
+    SignatureStatus["Executed"] = "Executed";
+    // FIXME: Missing documentation for Rejected
+    SignatureStatus["Rejected"] = "Rejected";
+    // FIXME: Missing documentation for Failed
+    SignatureStatus["Failed"] = "Failed";
+})(SignatureStatus = exports.SignatureStatus || (exports.SignatureStatus = {}));
+// FIXME: Missing documentation for TransactionTemplateKind
+var TransactionTemplateKind;
+(function (TransactionTemplateKind) {
+    // FIXME: Missing documentation for EvmGenericTx
+    TransactionTemplateKind["EvmGenericTx"] = "EvmGenericTx";
+    // FIXME: Missing documentation for CosmosIbcTransfer
+    TransactionTemplateKind["CosmosIbcTransfer"] = "CosmosIbcTransfer";
+    // FIXME: Missing documentation for SolanaTx
+    TransactionTemplateKind["SolanaTx"] = "SolanaTx";
+    // FIXME: Missing documentation for TronTx
+    TransactionTemplateKind["TronTx"] = "TronTx";
+    // FIXME: Missing documentation for TezosTx
+    TransactionTemplateKind["TezosTx"] = "TezosTx";
+})(TransactionTemplateKind = exports.TransactionTemplateKind || (exports.TransactionTemplateKind = {}));
+// FIXME: Missing documentation for TransactionStatus
+var TransactionStatus;
+(function (TransactionStatus) {
+    // FIXME: Missing documentation for Initiated
+    TransactionStatus["Initiated"] = "Initiated";
+    // FIXME: Missing documentation for PolicyAccepted
+    TransactionStatus["PolicyAccepted"] = "PolicyAccepted";
+    // FIXME: Missing documentation for PolicyRejected
+    TransactionStatus["PolicyRejected"] = "PolicyRejected";
+    // FIXME: Missing documentation for BroadcastPending
+    TransactionStatus["BroadcastPending"] = "BroadcastPending";
+    // FIXME: Missing documentation for BroadcastRejected
+    TransactionStatus["BroadcastRejected"] = "BroadcastRejected";
+    // FIXME: Missing documentation for Broadcasted
+    TransactionStatus["Broadcasted"] = "Broadcasted";
+    // FIXME: Missing documentation for Confirmed
+    TransactionStatus["Confirmed"] = "Confirmed";
+    // FIXME: Missing documentation for Failed
+    TransactionStatus["Failed"] = "Failed";
+})(TransactionStatus = exports.TransactionStatus || (exports.TransactionStatus = {}));

package/codegen/datamodel/Wallets/index.d.ts

@@ -0,0 +1,2 @@
+export * from './responses';
+export * from './types';

package/codegen/datamodel/Wallets/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./responses"), exports);
+__exportStar(require("./types"), exports);

package/codegen/datamodel/Wallets/responses.d.ts

@@ -0,0 +1,77 @@
+import { BadRequestError, EntityNotFoundError, ForbiddenError, UnauthorizedError } from '../Foundations';
+import { PaginatedEventHistory, PaginatedSignatureList, PaginatedTransactionList, PaginatedTransferList, PaginatedWalletList, SignatureRequest, TransactionRequest, TransferRequest, Wallet, WalletAssets, WalletNfts } from './types';
+export type CreateWalletSuccess = Wallet;
+export type CreateWalletError = {
+    error: BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateWalletResponse = CreateWalletSuccess | CreateWalletError;
+export type GetWalletSuccess = Wallet;
+export type GetWalletError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetWalletResponse = GetWalletSuccess | GetWalletError;
+export type GetWalletAssetsSuccess = WalletAssets;
+export type GetWalletAssetsError = {
+    error: EntityNotFoundError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetWalletAssetsResponse = GetWalletAssetsSuccess | GetWalletAssetsError;
+export type GetWalletNftsSuccess = WalletNfts;
+export type GetWalletNftsError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetWalletNftsResponse = GetWalletNftsSuccess | GetWalletNftsError;
+export type ListWalletsSuccess = PaginatedWalletList;
+export type ListWalletsError = {
+    error: ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListWalletsResponse = ListWalletsSuccess | ListWalletsError;
+export type GetWalletHistorySuccess = PaginatedEventHistory;
+export type GetWalletHistoryError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError;
+};
+export type GetWalletHistoryResponse = GetWalletHistorySuccess | GetWalletHistoryError;
+export type TransferAssetSuccess = TransferRequest;
+export type TransferAssetError = {
+    error: BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type TransferAssetResponse = TransferAssetSuccess | TransferAssetError;
+export type GetTransferSuccess = TransferRequest;
+export type GetTransferError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetTransferResponse = GetTransferSuccess | GetTransferError;
+export type ListTransfersSuccess = PaginatedTransferList;
+export type ListTransfersError = {
+    error: ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListTransfersResponse = ListTransfersSuccess | ListTransfersError;
+export type BroadcastTransactionSuccess = TransactionRequest;
+export type BroadcastTransactionError = {
+    error: BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type BroadcastTransactionResponse = BroadcastTransactionSuccess | BroadcastTransactionError;
+export type GetTransactionSuccess = TransactionRequest;
+export type GetTransactionError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetTransactionResponse = GetTransactionSuccess | GetTransactionError;
+export type ListTransactionsSuccess = PaginatedTransactionList;
+export type ListTransactionsError = {
+    error: ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListTransactionsResponse = ListTransactionsSuccess | ListTransactionsError;
+export type GenerateSignatureSuccess = SignatureRequest;
+export type GenerateSignatureError = {
+    error: BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GenerateSignatureResponse = GenerateSignatureSuccess | GenerateSignatureError;
+export type GetSignatureSuccess = SignatureRequest;
+export type GetSignatureError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetSignatureResponse = GetSignatureSuccess | GetSignatureError;
+export type ListSignaturesSuccess = PaginatedSignatureList;
+export type ListSignaturesError = {
+    error: ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListSignaturesResponse = ListSignaturesSuccess | ListSignaturesError;

package/codegen/datamodel/Wallets/responses.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/codegen/datamodel/Wallets/types.d.ts

@@ -0,0 +1,261 @@
+import { Amount, BlockchainAddress, BlockchainNetwork, EntityId, IsoDatetime, Tag } from '../Foundations';
+import { IdentityKind } from '../Permissions';
+export type TransferNativeRequest = {
+    kind: TransferKind.Native;
+    to: BlockchainAddress;
+    amount: Amount;
+};
+export type TransferErc20Request = {
+    kind: TransferKind.Erc20;
+    contract: BlockchainAddress;
+    to: BlockchainAddress;
+    amount: Amount;
+};
+export type TransferErc721Request = {
+    kind: TransferKind.Erc721;
+    contract: BlockchainAddress;
+    to: BlockchainAddress;
+    tokenId: string;
+};
+export type BroadcastEvmTransactionRequest = {
+    kind: TransactionKind.Evm;
+    to?: BlockchainAddress;
+    value?: Amount;
+    data?: string;
+    nonce?: number;
+    gasLimit?: Amount;
+    gasPrice?: Amount;
+    maxPriorityFeePerGas?: Amount;
+    maxFeePerGas?: Amount;
+};
+export type SignHashRequest = {
+    kind: SignatureKind.Hash;
+    hash: string;
+};
+export type Eip712Domain = {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: BlockchainAddress;
+    salt?: string;
+};
+export type SignEip712TypedDataRequest = {
+    kind: SignatureKind.Eip712;
+    types: Record<string, unknown>;
+    domain: Eip712Domain;
+    message: Record<string, unknown>;
+};
+export type Wallet = {
+    id: EntityId;
+    network: BlockchainNetwork;
+    status: WalletStatus;
+    address?: string;
+    name?: string;
+    externalId?: string;
+    tags: Tag[];
+    dateCreated: IsoDatetime;
+};
+export type WalletAssets = {
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    assets: WalletAsset[];
+};
+export type WalletAsset = {
+    contract?: string;
+    name?: string;
+    symbol?: string;
+    decimals: number;
+    balance: Amount;
+};
+export type WalletNfts = {
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    nfts: WalletNft[];
+};
+export type WalletNft = {
+    contract: string;
+    name?: string;
+    symbol?: string;
+    tokenIds: string[];
+    count: number;
+};
+export type PaginatedWalletList = {
+    items: Wallet[];
+    nextPageToken?: string;
+};
+export type NativeTransferEvent = {
+    kind: EventKind.NativeTransfer;
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    blockNumber: number;
+    txHash: string;
+    index?: string;
+    timestamp: IsoDatetime;
+    fee?: Amount;
+    direction: TransferDirection;
+    symbol: string;
+    decimals: number;
+    from: BlockchainAddress;
+    to: BlockchainAddress;
+    value: Amount;
+};
+export type Erc20TransferEvent = {
+    kind: EventKind.Erc20Transfer;
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    blockNumber: number;
+    txHash: string;
+    index?: string;
+    timestamp: IsoDatetime;
+    fee?: Amount;
+    direction: TransferDirection;
+    contract: BlockchainAddress;
+    name?: string;
+    symbol?: string;
+    decimals: number;
+    from: BlockchainAddress;
+    to: BlockchainAddress;
+    value: Amount;
+};
+export type Erc721TransferEvent = {
+    kind: EventKind.Erc721Transfer;
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    blockNumber: number;
+    txHash: string;
+    index?: string;
+    timestamp: IsoDatetime;
+    fee?: Amount;
+    direction: TransferDirection;
+    contract: BlockchainAddress;
+    name?: string;
+    symbol?: string;
+    from: BlockchainAddress;
+    to: BlockchainAddress;
+    tokenId: string;
+};
+export type PaginatedEventHistory = {
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    items: BlockchainEvent[];
+    nextPageToken?: string;
+};
+export type TransferRequest = {
+    id: EntityId;
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    txHash?: string;
+    requester: RequesterIdentity;
+    requestBody: TransferAssetRequest;
+    status: TransferStatus;
+    fee?: Amount;
+    error?: string;
+    dateRequested: IsoDatetime;
+    dateBroadcasted?: IsoDatetime;
+    dateConfirmed?: IsoDatetime;
+};
+export type PaginatedTransferList = {
+    walletId: EntityId;
+    items: TransferRequest[];
+    nextPageToken?: string;
+};
+export type TransactionRequest = {
+    id: EntityId;
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    txHash?: string;
+    requester: RequesterIdentity;
+    requestBody: BroadcastTransactionRequest;
+    status: TransactionStatus;
+    error?: string;
+    fee?: Amount;
+    dateRequested: IsoDatetime;
+    dateBroadcasted?: IsoDatetime;
+    dateConfirmed?: IsoDatetime;
+};
+export type PaginatedTransactionList = {
+    walletId: EntityId;
+    items: TransactionRequest[];
+    nextPageToken?: string;
+};
+export type Signature = {
+    r: string;
+    s: string;
+    recid?: number;
+};
+export type SignatureRequest = {
+    id: EntityId;
+    walletId: EntityId;
+    requester: RequesterIdentity;
+    requestBody: GenerateSignatureRequest;
+    signature?: Signature;
+    status: SignatureStatus;
+    error?: string;
+    dateRequested: IsoDatetime;
+    datePolicyResolved?: IsoDatetime;
+    dateSigned?: IsoDatetime;
+};
+export type PaginatedSignatureList = {
+    walletId: EntityId;
+    items: SignatureRequest[];
+    nextPageToken?: string;
+};
+export type RequesterIdentity = {
+    kind: IdentityKind;
+    userId: EntityId;
+    tokenId?: EntityId;
+    appId?: EntityId;
+};
+export type CreateWalletRequest = {
+    network: BlockchainNetwork;
+    externalId?: string;
+    tags?: Tag[];
+    name?: string;
+};
+export type TransferAssetRequest = TransferNativeRequest | TransferErc20Request | TransferErc721Request;
+export type BroadcastTransactionRequest = BroadcastEvmTransactionRequest;
+export type GenerateSignatureRequest = SignHashRequest | SignEip712TypedDataRequest;
+export type BlockchainEvent = NativeTransferEvent | Erc20TransferEvent | Erc721TransferEvent;
+export declare enum TransferKind {
+    Native = "Native",
+    Erc20 = "Erc20",
+    Erc721 = "Erc721"
+}
+export declare enum TransactionKind {
+    Evm = "Evm"
+}
+export declare enum SignatureKind {
+    Hash = "Hash",
+    Eip712 = "Eip712"
+}
+export declare enum WalletStatus {
+    Active = "Active",
+    Creating = "Creating",
+    Failed = "Failed"
+}
+export declare enum EventKind {
+    NativeTransfer = "NativeTransfer",
+    Erc20Transfer = "Erc20Transfer",
+    Erc721Transfer = "Erc721Transfer"
+}
+export declare enum TransferDirection {
+    In = "In",
+    Out = "Out"
+}
+export declare enum TransferStatus {
+    Pending = "Pending",
+    Broadcasted = "Broadcasted",
+    Confirmed = "Confirmed",
+    Failed = "Failed"
+}
+export declare enum TransactionStatus {
+    Pending = "Pending",
+    Broadcasted = "Broadcasted",
+    Confirmed = "Confirmed",
+    Failed = "Failed"
+}
+export declare enum SignatureStatus {
+    Pending = "Pending",
+    Signed = "Signed",
+    Failed = "Failed"
+}

package/codegen/datamodel/Wallets/types.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureStatus = exports.TransactionStatus = exports.TransferStatus = exports.TransferDirection = exports.EventKind = exports.WalletStatus = exports.SignatureKind = exports.TransactionKind = exports.TransferKind = void 0;
+// FIXME: Missing documentation for TransferKind
+var TransferKind;
+(function (TransferKind) {
+    // FIXME: Missing documentation for Native
+    TransferKind["Native"] = "Native";
+    // FIXME: Missing documentation for Erc20
+    TransferKind["Erc20"] = "Erc20";
+    // FIXME: Missing documentation for Erc721
+    TransferKind["Erc721"] = "Erc721";
+})(TransferKind = exports.TransferKind || (exports.TransferKind = {}));
+// FIXME: Missing documentation for TransactionKind
+var TransactionKind;
+(function (TransactionKind) {
+    // FIXME: Missing documentation for Evm
+    TransactionKind["Evm"] = "Evm";
+})(TransactionKind = exports.TransactionKind || (exports.TransactionKind = {}));
+// FIXME: Missing documentation for SignatureKind
+var SignatureKind;
+(function (SignatureKind) {
+    // FIXME: Missing documentation for Hash
+    SignatureKind["Hash"] = "Hash";
+    // FIXME: Missing documentation for Eip712
+    SignatureKind["Eip712"] = "Eip712";
+})(SignatureKind = exports.SignatureKind || (exports.SignatureKind = {}));
+// FIXME: Missing documentation for WalletStatus
+var WalletStatus;
+(function (WalletStatus) {
+    // FIXME: Missing documentation for Active
+    WalletStatus["Active"] = "Active";
+    //Initial state of `AssetAccount` entity, indicating that it’s being created at the moment.
+    WalletStatus["Creating"] = "Creating";
+    // FIXME: Missing documentation for Failed
+    WalletStatus["Failed"] = "Failed";
+})(WalletStatus = exports.WalletStatus || (exports.WalletStatus = {}));
+// FIXME: Missing documentation for EventKind
+var EventKind;
+(function (EventKind) {
+    // FIXME: Missing documentation for NativeTransfer
+    EventKind["NativeTransfer"] = "NativeTransfer";
+    // FIXME: Missing documentation for Erc20Transfer
+    EventKind["Erc20Transfer"] = "Erc20Transfer";
+    // FIXME: Missing documentation for Erc721Transfer
+    EventKind["Erc721Transfer"] = "Erc721Transfer";
+})(EventKind = exports.EventKind || (exports.EventKind = {}));
+// FIXME: Missing documentation for TransferDirection
+var TransferDirection;
+(function (TransferDirection) {
+    // FIXME: Missing documentation for In
+    TransferDirection["In"] = "In";
+    // FIXME: Missing documentation for Out
+    TransferDirection["Out"] = "Out";
+})(TransferDirection = exports.TransferDirection || (exports.TransferDirection = {}));
+// FIXME: Missing documentation for TransferStatus
+var TransferStatus;
+(function (TransferStatus) {
+    // FIXME: Missing documentation for Pending
+    TransferStatus["Pending"] = "Pending";
+    // FIXME: Missing documentation for Broadcasted
+    TransferStatus["Broadcasted"] = "Broadcasted";
+    // FIXME: Missing documentation for Confirmed
+    TransferStatus["Confirmed"] = "Confirmed";
+    // FIXME: Missing documentation for Failed
+    TransferStatus["Failed"] = "Failed";
+})(TransferStatus = exports.TransferStatus || (exports.TransferStatus = {}));
+// FIXME: Missing documentation for TransactionStatus
+var TransactionStatus;
+(function (TransactionStatus) {
+    // FIXME: Missing documentation for Pending
+    TransactionStatus["Pending"] = "Pending";
+    // FIXME: Missing documentation for Broadcasted
+    TransactionStatus["Broadcasted"] = "Broadcasted";
+    // FIXME: Missing documentation for Confirmed
+    TransactionStatus["Confirmed"] = "Confirmed";
+    // FIXME: Missing documentation for Failed
+    TransactionStatus["Failed"] = "Failed";
+})(TransactionStatus = exports.TransactionStatus || (exports.TransactionStatus = {}));
+// FIXME: Missing documentation for SignatureStatus
+var SignatureStatus;
+(function (SignatureStatus) {
+    // FIXME: Missing documentation for Pending
+    SignatureStatus["Pending"] = "Pending";
+    // FIXME: Missing documentation for Signed
+    SignatureStatus["Signed"] = "Signed";
+    // FIXME: Missing documentation for Failed
+    SignatureStatus["Failed"] = "Failed";
+})(SignatureStatus = exports.SignatureStatus || (exports.SignatureStatus = {}));

package/dfnsApiClient.d.ts

@@ -0,0 +1,27 @@
+import { DfnsBaseApiOptions } from './baseAuthApi';
+import { ApiKeysClient } from './codegen/ApiKeys';
+import { AssetsClient } from './codegen/Assets';
+import { AuthClient } from './codegen/Auth';
+import { CallbacksClient } from './codegen/Callbacks';
+import { PermissionsClient } from './codegen/Permissions';
+import { PolicyExecutionClient } from './codegen/PolicyExecution';
+import { PolicyManagementClient } from './codegen/PolicyManagement';
+import { PublicKeysClient } from './codegen/PublicKeys';
+import { WalletsClient } from './codegen/Wallets';
+import { Signer } from './signer';
+export type DfnsApiClientOptions = DfnsBaseApiOptions & {
+    signer: Signer;
+};
+export declare class DfnsApiClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    get apiKeys(): ApiKeysClient;
+    get assets(): AssetsClient;
+    get auth(): AuthClient;
+    get callbacks(): CallbacksClient;
+    get permissions(): PermissionsClient;
+    get policyExecution(): PolicyExecutionClient;
+    get policyManagement(): PolicyManagementClient;
+    get publicKeys(): PublicKeysClient;
+    get wallets(): WalletsClient;
+}

package/dfnsApiClient.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsApiClient = void 0;
+const ApiKeys_1 = require("./codegen/ApiKeys");
+const Assets_1 = require("./codegen/Assets");
+const Auth_1 = require("./codegen/Auth");
+const Callbacks_1 = require("./codegen/Callbacks");
+const Permissions_1 = require("./codegen/Permissions");
+const PolicyExecution_1 = require("./codegen/PolicyExecution");
+const PolicyManagement_1 = require("./codegen/PolicyManagement");
+const PublicKeys_1 = require("./codegen/PublicKeys");
+const Wallets_1 = require("./codegen/Wallets");
+class DfnsApiClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    get apiKeys() {
+        return new ApiKeys_1.ApiKeysClient(this.apiOptions);
+    }
+    get assets() {
+        return new Assets_1.AssetsClient(this.apiOptions);
+    }
+    get auth() {
+        return new Auth_1.AuthClient(this.apiOptions);
+    }
+    get callbacks() {
+        return new Callbacks_1.CallbacksClient(this.apiOptions);
+    }
+    get permissions() {
+        return new Permissions_1.PermissionsClient(this.apiOptions);
+    }
+    get policyExecution() {
+        return new PolicyExecution_1.PolicyExecutionClient(this.apiOptions);
+    }
+    get policyManagement() {
+        return new PolicyManagement_1.PolicyManagementClient(this.apiOptions);
+    }
+    get publicKeys() {
+        return new PublicKeys_1.PublicKeysClient(this.apiOptions);
+    }
+    get wallets() {
+        return new Wallets_1.WalletsClient(this.apiOptions);
+    }
+}
+exports.DfnsApiClient = DfnsApiClient;

package/dfnsAuthenticator.d.ts

@@ -0,0 +1,11 @@
+import { CreateUserLoginChallengeRequest, UserLoginResponse } from './baseAuthApi';
+import { DfnsApiClientOptions } from './dfnsApiClient';
+export type LoginRequest = CreateUserLoginChallengeRequest;
+export type LoginResponse = UserLoginResponse;
+export type DfnsAuthenticatorOptions = Omit<DfnsApiClientOptions, 'accessToken'>;
+export declare class DfnsAuthenticator {
+    private apiOptions;
+    private api;
+    constructor(apiOptions: DfnsAuthenticatorOptions);
+    login(request: LoginRequest): Promise<LoginResponse>;
+}

package/dfnsAuthenticator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsAuthenticator = void 0;
+const baseAuthApi_1 = require("./baseAuthApi");
+class DfnsAuthenticator {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async login(request) {
+        const { challenge, challengeIdentifier, allowCredentials } = await baseAuthApi_1.BaseAuthApi.createUserLoginChallenge(request, this.apiOptions);
+        const assertions = await this.apiOptions.signer.sign(challenge, allowCredentials);
+        return baseAuthApi_1.BaseAuthApi.signUserLoginChallenge({
+            challengeIdentifier,
+            ...assertions,
+        }, this.apiOptions);
+    }
+}
+exports.DfnsAuthenticator = DfnsAuthenticator;

package/dfnsDelegatedApiClient.d.ts

@@ -0,0 +1,24 @@
+import { DfnsBaseApiOptions } from './baseAuthApi';
+import { DelegatedApiKeysClient } from './codegen/ApiKeys';
+import { DelegatedAssetsClient } from './codegen/Assets';
+import { DelegatedCallbacksClient } from './codegen/Callbacks';
+import { DelegatedPermissionsClient } from './codegen/Permissions';
+import { DelegatedPolicyExecutionClient } from './codegen/PolicyExecution';
+import { DelegatedPolicyManagementClient } from './codegen/PolicyManagement';
+import { DelegatedPublicKeysClient } from './codegen/PublicKeys';
+import { DelegatedWalletsClient } from './codegen/Wallets';
+export type DfnsDelegatedApiClientOptions = DfnsBaseApiOptions & {
+    accessToken: string;
+};
+export declare class DfnsDelegatedApiClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    get apiKeys(): DelegatedApiKeysClient;
+    get assets(): DelegatedAssetsClient;
+    get callbacks(): DelegatedCallbacksClient;
+    get permissions(): DelegatedPermissionsClient;
+    get policyExecution(): DelegatedPolicyExecutionClient;
+    get policyManagement(): DelegatedPolicyManagementClient;
+    get publicKeys(): DelegatedPublicKeysClient;
+    get wallets(): DelegatedWalletsClient;
+}