@dfns/sdk 0.2.3-rc.1 → 0.2.3

package/codegen/datamodel/Wallets/types.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockchainNetwork = exports.SignatureStatus = exports.TransactionStatus = exports.TransferStatus = exports.TransferDirection = exports.EventKind = exports.BalanceKind = exports.KeyProtocol = exports.KeyCurve = exports.KeyScheme = exports.WalletStatus = exports.SignatureKind = exports.TransactionKind = exports.TransferKind = void 0;
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+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";
+    // FIXME: Missing documentation for Trc10
+    TransferKind["Trc10"] = "Trc10";
+    // FIXME: Missing documentation for Trc20
+    TransferKind["Trc20"] = "Trc20";
+    // FIXME: Missing documentation for Trc721
+    TransferKind["Trc721"] = "Trc721";
+})(TransferKind || (exports.TransferKind = TransferKind = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var TransactionKind;
+(function (TransactionKind) {
+    // FIXME: Missing documentation for Transaction
+    TransactionKind["Transaction"] = "Transaction";
+    // FIXME: Missing documentation for Evm
+    TransactionKind["Evm"] = "Evm";
+    // FIXME: Missing documentation for Eip1559
+    TransactionKind["Eip1559"] = "Eip1559";
+    // FIXME: Missing documentation for EvmLegacy
+    TransactionKind["EvmLegacy"] = "EvmLegacy";
+    // FIXME: Missing documentation for Psbt
+    TransactionKind["Psbt"] = "Psbt";
+})(TransactionKind || (exports.TransactionKind = TransactionKind = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var SignatureKind;
+(function (SignatureKind) {
+    // FIXME: Missing documentation for Hash
+    SignatureKind["Hash"] = "Hash";
+    // FIXME: Missing documentation for Message
+    SignatureKind["Message"] = "Message";
+    // FIXME: Missing documentation for Transaction
+    SignatureKind["Transaction"] = "Transaction";
+    // FIXME: Missing documentation for Eip712
+    SignatureKind["Eip712"] = "Eip712";
+    // FIXME: Missing documentation for Psbt
+    SignatureKind["Psbt"] = "Psbt";
+})(SignatureKind || (exports.SignatureKind = SignatureKind = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var WalletStatus;
+(function (WalletStatus) {
+    // FIXME: Missing documentation for Active
+    WalletStatus["Active"] = "Active";
+    // FIXME: Missing documentation for Archived
+    WalletStatus["Archived"] = "Archived";
+})(WalletStatus || (exports.WalletStatus = WalletStatus = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var KeyScheme;
+(function (KeyScheme) {
+    // FIXME: Missing documentation for ECDSA
+    KeyScheme["ECDSA"] = "ECDSA";
+    // FIXME: Missing documentation for EdDSA
+    KeyScheme["EdDSA"] = "EdDSA";
+})(KeyScheme || (exports.KeyScheme = KeyScheme = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var KeyCurve;
+(function (KeyCurve) {
+    // FIXME: Missing documentation for ed25519
+    KeyCurve["ed25519"] = "ed25519";
+    // FIXME: Missing documentation for secp256k1
+    KeyCurve["secp256k1"] = "secp256k1";
+    // FIXME: Missing documentation for stark
+    KeyCurve["stark"] = "stark";
+})(KeyCurve || (exports.KeyCurve = KeyCurve = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var KeyProtocol;
+(function (KeyProtocol) {
+    // FIXME: Missing documentation for CGGMP21
+    KeyProtocol["CGGMP21"] = "CGGMP21";
+    // FIXME: Missing documentation for BINANCE_EDDSA
+    KeyProtocol["BINANCE_EDDSA"] = "BINANCE_EDDSA";
+})(KeyProtocol || (exports.KeyProtocol = KeyProtocol = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var BalanceKind;
+(function (BalanceKind) {
+    // FIXME: Missing documentation for Native
+    BalanceKind["Native"] = "Native";
+    // FIXME: Missing documentation for Erc20
+    BalanceKind["Erc20"] = "Erc20";
+    // FIXME: Missing documentation for Erc721
+    BalanceKind["Erc721"] = "Erc721";
+})(BalanceKind || (exports.BalanceKind = BalanceKind = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+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 = EventKind = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var TransferDirection;
+(function (TransferDirection) {
+    // FIXME: Missing documentation for In
+    TransferDirection["In"] = "In";
+    // FIXME: Missing documentation for Out
+    TransferDirection["Out"] = "Out";
+})(TransferDirection || (exports.TransferDirection = TransferDirection = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var TransferStatus;
+(function (TransferStatus) {
+    // FIXME: Missing documentation for Pending
+    TransferStatus["Pending"] = "Pending";
+    // FIXME: Missing documentation for Executing
+    TransferStatus["Executing"] = "Executing";
+    // FIXME: Missing documentation for Broadcasted
+    TransferStatus["Broadcasted"] = "Broadcasted";
+    // FIXME: Missing documentation for Confirmed
+    TransferStatus["Confirmed"] = "Confirmed";
+    // FIXME: Missing documentation for Failed
+    TransferStatus["Failed"] = "Failed";
+    // FIXME: Missing documentation for Rejected
+    TransferStatus["Rejected"] = "Rejected";
+})(TransferStatus || (exports.TransferStatus = TransferStatus = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var TransactionStatus;
+(function (TransactionStatus) {
+    // FIXME: Missing documentation for Pending
+    TransactionStatus["Pending"] = "Pending";
+    // FIXME: Missing documentation for Executing
+    TransactionStatus["Executing"] = "Executing";
+    // FIXME: Missing documentation for Broadcasted
+    TransactionStatus["Broadcasted"] = "Broadcasted";
+    // FIXME: Missing documentation for Confirmed
+    TransactionStatus["Confirmed"] = "Confirmed";
+    // FIXME: Missing documentation for Failed
+    TransactionStatus["Failed"] = "Failed";
+    // FIXME: Missing documentation for Rejected
+    TransactionStatus["Rejected"] = "Rejected";
+})(TransactionStatus || (exports.TransactionStatus = TransactionStatus = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var SignatureStatus;
+(function (SignatureStatus) {
+    // FIXME: Missing documentation for Pending
+    SignatureStatus["Pending"] = "Pending";
+    // FIXME: Missing documentation for Executing
+    SignatureStatus["Executing"] = "Executing";
+    // FIXME: Missing documentation for Signed
+    SignatureStatus["Signed"] = "Signed";
+    // FIXME: Missing documentation for Confirmed
+    SignatureStatus["Confirmed"] = "Confirmed";
+    // FIXME: Missing documentation for Failed
+    SignatureStatus["Failed"] = "Failed";
+    // FIXME: Missing documentation for Rejected
+    SignatureStatus["Rejected"] = "Rejected";
+})(SignatureStatus || (exports.SignatureStatus = SignatureStatus = {}));
+/**
+ * @deprecated import equivalent type from '@dfns/sdk/types/wallets' instead
+ */
+var BlockchainNetwork;
+(function (BlockchainNetwork) {
+    // FIXME: Missing documentation for ArbitrumOne
+    BlockchainNetwork["ArbitrumOne"] = "ArbitrumOne";
+    // FIXME: Missing documentation for ArbitrumGoerli
+    BlockchainNetwork["ArbitrumGoerli"] = "ArbitrumGoerli";
+    // FIXME: Missing documentation for ArbitrumSepolia
+    BlockchainNetwork["ArbitrumSepolia"] = "ArbitrumSepolia";
+    // FIXME: Missing documentation for AvalancheC
+    BlockchainNetwork["AvalancheC"] = "AvalancheC";
+    // FIXME: Missing documentation for AvalancheCFuji
+    BlockchainNetwork["AvalancheCFuji"] = "AvalancheCFuji";
+    // FIXME: Missing documentation for Base
+    BlockchainNetwork["Base"] = "Base";
+    // FIXME: Missing documentation for BaseGoerli
+    BlockchainNetwork["BaseGoerli"] = "BaseGoerli";
+    // FIXME: Missing documentation for Bitcoin
+    BlockchainNetwork["Bitcoin"] = "Bitcoin";
+    // FIXME: Missing documentation for BitcoinTestnet3
+    BlockchainNetwork["BitcoinTestnet3"] = "BitcoinTestnet3";
+    // FIXME: Missing documentation for Bsc
+    BlockchainNetwork["Bsc"] = "Bsc";
+    // FIXME: Missing documentation for BscTestnet
+    BlockchainNetwork["BscTestnet"] = "BscTestnet";
+    // FIXME: Missing documentation for Ethereum
+    BlockchainNetwork["Ethereum"] = "Ethereum";
+    // FIXME: Missing documentation for EthereumGoerli
+    BlockchainNetwork["EthereumGoerli"] = "EthereumGoerli";
+    // FIXME: Missing documentation for EthereumSepolia
+    BlockchainNetwork["EthereumSepolia"] = "EthereumSepolia";
+    // FIXME: Missing documentation for FantomOpera
+    BlockchainNetwork["FantomOpera"] = "FantomOpera";
+    // FIXME: Missing documentation for FantomTestnet
+    BlockchainNetwork["FantomTestnet"] = "FantomTestnet";
+    // FIXME: Missing documentation for Optimism
+    BlockchainNetwork["Optimism"] = "Optimism";
+    // FIXME: Missing documentation for OptimismGoerli
+    BlockchainNetwork["OptimismGoerli"] = "OptimismGoerli";
+    // FIXME: Missing documentation for Polygon
+    BlockchainNetwork["Polygon"] = "Polygon";
+    // FIXME: Missing documentation for PolygonMumbai
+    BlockchainNetwork["PolygonMumbai"] = "PolygonMumbai";
+    // FIXME: Missing documentation for Ripple
+    BlockchainNetwork["Ripple"] = "Ripple";
+    // FIXME: Missing documentation for RippleTestnet
+    BlockchainNetwork["RippleTestnet"] = "RippleTestnet";
+    // FIXME: Missing documentation for Solana
+    BlockchainNetwork["Solana"] = "Solana";
+    // FIXME: Missing documentation for SolanaDevnet
+    BlockchainNetwork["SolanaDevnet"] = "SolanaDevnet";
+    // FIXME: Missing documentation for Tezos
+    BlockchainNetwork["Tezos"] = "Tezos";
+    // FIXME: Missing documentation for TezosGhostnet
+    BlockchainNetwork["TezosGhostnet"] = "TezosGhostnet";
+    // FIXME: Missing documentation for Tron
+    BlockchainNetwork["Tron"] = "Tron";
+    // FIXME: Missing documentation for TronNile
+    BlockchainNetwork["TronNile"] = "TronNile";
+    // FIXME: Missing documentation for KeyECDSA
+    BlockchainNetwork["KeyECDSA"] = "KeyECDSA";
+    // FIXME: Missing documentation for KeyEdDSA
+    BlockchainNetwork["KeyEdDSA"] = "KeyEdDSA";
+    // FIXME: Missing documentation for KeyECDSAStark
+    BlockchainNetwork["KeyECDSAStark"] = "KeyECDSAStark";
+})(BlockchainNetwork || (exports.BlockchainNetwork = BlockchainNetwork = {}));

package/dfnsApiClient.d.ts

@@ -0,0 +1,39 @@
+import { DfnsBaseApiOptions } from './baseAuthApi';
+import { AssetsClient } from './codegen/Assets';
+import { AuthClient } from './codegen/Auth';
+import { BlockchainsClient } from './codegen/Blockchains';
+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 { PoliciesClient } from './generated/policies';
+import { SignersClient } from './generated/signers';
+import { WalletsClient } from './generated/wallets';
+import { WebhooksClient } from './generated/webhooks';
+import { CredentialSigner } from './signer';
+export type DfnsApiClientOptions = DfnsBaseApiOptions & {
+    signer: CredentialSigner;
+};
+export declare class DfnsApiClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    get assets(): AssetsClient;
+    get auth(): AuthClient;
+    get blockchains(): BlockchainsClient;
+    get callbacks(): CallbacksClient;
+    get permissions(): PermissionsClient;
+    get policies(): PoliciesClient;
+    /**
+     * @deprecated use the new policy engine instead
+     */
+    get policyExecution(): PolicyExecutionClient;
+    /**
+     * @deprecated use the new policy engine instead
+     */
+    get policyManagement(): PolicyManagementClient;
+    get publicKeys(): PublicKeysClient;
+    get wallets(): WalletsClient;
+    get webhooks(): WebhooksClient;
+    get signers(): SignersClient;
+}

package/dfnsApiClient.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsApiClient = void 0;
+const Assets_1 = require("./codegen/Assets");
+const Auth_1 = require("./codegen/Auth");
+const Blockchains_1 = require("./codegen/Blockchains");
+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 policies_1 = require("./generated/policies");
+const signers_1 = require("./generated/signers");
+const wallets_1 = require("./generated/wallets");
+const webhooks_1 = require("./generated/webhooks");
+class DfnsApiClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    get assets() {
+        return new Assets_1.AssetsClient(this.apiOptions);
+    }
+    get auth() {
+        return new Auth_1.AuthClient(this.apiOptions);
+    }
+    get blockchains() {
+        return new Blockchains_1.BlockchainsClient(this.apiOptions);
+    }
+    get callbacks() {
+        return new Callbacks_1.CallbacksClient(this.apiOptions);
+    }
+    get permissions() {
+        return new Permissions_1.PermissionsClient(this.apiOptions);
+    }
+    get policies() {
+        return new policies_1.PoliciesClient(this.apiOptions);
+    }
+    /**
+     * @deprecated use the new policy engine instead
+     */
+    get policyExecution() {
+        return new PolicyExecution_1.PolicyExecutionClient(this.apiOptions);
+    }
+    /**
+     * @deprecated use the new policy engine instead
+     */
+    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);
+    }
+    get webhooks() {
+        return new webhooks_1.WebhooksClient(this.apiOptions);
+    }
+    get signers() {
+        return new signers_1.SignersClient(this.apiOptions);
+    }
+}
+exports.DfnsApiClient = DfnsApiClient;

package/dfnsAuthenticator.d.ts

@@ -0,0 +1,17 @@
+import { CredentialStore } from './store';
+import { CredentialSigner } from './signer';
+import { CreateUserLoginChallengeRequest, CreateUserRegistrationChallengeRequest, DfnsBaseApiOptions, UserLoginResponse, UserRegistrationResponse } from './baseAuthApi';
+export type LoginRequest = CreateUserLoginChallengeRequest;
+export type LoginResponse = UserLoginResponse;
+export type RegisterRequest = CreateUserRegistrationChallengeRequest;
+export type RegisterResponse = UserRegistrationResponse;
+export type DfnsAuthenticatorOptions = Omit<DfnsBaseApiOptions, 'authToken'> & {
+    signer: CredentialSigner & Partial<CredentialStore>;
+};
+export declare class DfnsAuthenticator {
+    private apiOptions;
+    private api;
+    constructor(apiOptions: DfnsAuthenticatorOptions);
+    login(request: LoginRequest): Promise<LoginResponse>;
+    register(request: RegisterRequest): Promise<RegisterResponse>;
+}

package/dfnsAuthenticator.js

@@ -0,0 +1,29 @@
+"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 assertion = await this.apiOptions.signer.sign(challenge, allowCredentials);
+        return baseAuthApi_1.BaseAuthApi.createUserLogin({
+            challengeIdentifier,
+            firstFactor: assertion,
+        }, this.apiOptions);
+    }
+    async register(request) {
+        if (!this.apiOptions.signer.create) {
+            throw new Error(`Provided signer does not implement 'create'`);
+        }
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserRegistrationChallenge(request, this.apiOptions);
+        const attestation = await this.apiOptions.signer.create(challenge);
+        return baseAuthApi_1.BaseAuthApi.createUserRegistration({ firstFactorCredential: attestation }, {
+            ...this.apiOptions,
+            authToken: challenge.temporaryAuthenticationToken,
+        });
+    }
+}
+exports.DfnsAuthenticator = DfnsAuthenticator;

package/dfnsDelegatedApiClient.d.ts

@@ -0,0 +1,38 @@
+import { DfnsBaseApiOptions } from './baseAuthApi';
+import { DelegatedAssetsClient } from './codegen/Assets';
+import { DelegatedAuthClient } from './codegen/Auth';
+import { DelegatedBlockchainsClient } from './codegen/Blockchains';
+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 { DelegatedPoliciesClient } from './generated/policies';
+import { DelegatedSignersClient } from './generated/signers';
+import { DelegatedWalletsClient } from './generated/wallets';
+import { DelegatedWebhooksClient } from './generated/webhooks';
+export type DfnsDelegatedApiClientOptions = DfnsBaseApiOptions & {
+    authToken: string;
+};
+export declare class DfnsDelegatedApiClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    get assets(): DelegatedAssetsClient;
+    get auth(): DelegatedAuthClient;
+    get blockchains(): DelegatedBlockchainsClient;
+    get callbacks(): DelegatedCallbacksClient;
+    get permissions(): DelegatedPermissionsClient;
+    get policies(): DelegatedPoliciesClient;
+    /**
+     * @deprecated use the new policy engine instead
+     */
+    get policyExecution(): DelegatedPolicyExecutionClient;
+    /**
+     * @deprecated use the new policy engine instead
+     */
+    get policyManagement(): DelegatedPolicyManagementClient;
+    get publicKeys(): DelegatedPublicKeysClient;
+    get wallets(): DelegatedWalletsClient;
+    get webhooks(): DelegatedWebhooksClient;
+    get signers(): DelegatedSignersClient;
+}

package/dfnsDelegatedApiClient.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsDelegatedApiClient = void 0;
+const Assets_1 = require("./codegen/Assets");
+const Auth_1 = require("./codegen/Auth");
+const Blockchains_1 = require("./codegen/Blockchains");
+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 policies_1 = require("./generated/policies");
+const signers_1 = require("./generated/signers");
+const wallets_1 = require("./generated/wallets");
+const webhooks_1 = require("./generated/webhooks");
+class DfnsDelegatedApiClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    get assets() {
+        return new Assets_1.DelegatedAssetsClient(this.apiOptions);
+    }
+    get auth() {
+        return new Auth_1.DelegatedAuthClient(this.apiOptions);
+    }
+    get blockchains() {
+        return new Blockchains_1.DelegatedBlockchainsClient(this.apiOptions);
+    }
+    get callbacks() {
+        return new Callbacks_1.DelegatedCallbacksClient(this.apiOptions);
+    }
+    get permissions() {
+        return new Permissions_1.DelegatedPermissionsClient(this.apiOptions);
+    }
+    get policies() {
+        return new policies_1.DelegatedPoliciesClient(this.apiOptions);
+    }
+    /**
+     * @deprecated use the new policy engine instead
+     */
+    get policyExecution() {
+        return new PolicyExecution_1.DelegatedPolicyExecutionClient(this.apiOptions);
+    }
+    /**
+     * @deprecated use the new policy engine instead
+     */
+    get policyManagement() {
+        return new PolicyManagement_1.DelegatedPolicyManagementClient(this.apiOptions);
+    }
+    get publicKeys() {
+        return new PublicKeys_1.DelegatedPublicKeysClient(this.apiOptions);
+    }
+    get wallets() {
+        return new wallets_1.DelegatedWalletsClient(this.apiOptions);
+    }
+    get webhooks() {
+        return new webhooks_1.DelegatedWebhooksClient(this.apiOptions);
+    }
+    get signers() {
+        return new signers_1.DelegatedSignersClient(this.apiOptions);
+    }
+}
+exports.DfnsDelegatedApiClient = DfnsDelegatedApiClient;

package/dfnsError.d.ts

@@ -0,0 +1,5 @@
+export declare class DfnsError extends Error {
+    httpStatus: number;
+    context?: unknown;
+    constructor(httpStatus: number, message: string, context?: unknown);
+}

package/dfnsError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsError = void 0;
+class DfnsError extends Error {
+    constructor(httpStatus, message, context) {
+        super(message);
+        this.httpStatus = httpStatus;
+        this.context = context;
+    }
+}
+exports.DfnsError = DfnsError;

package/generated/policies/client.d.ts

@@ -0,0 +1,13 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient';
+import * as T from './types';
+export declare class PoliciesClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    archivePolicy(request: T.ArchivePolicyRequest): Promise<T.ArchivePolicyResponse>;
+    createApprovalDecision(request: T.CreateApprovalDecisionRequest): Promise<T.CreateApprovalDecisionResponse>;
+    createPolicy(request: T.CreatePolicyRequest): Promise<T.CreatePolicyResponse>;
+    getPolicy(request: T.GetPolicyRequest): Promise<T.GetPolicyResponse>;
+    listApprovals(request?: T.ListApprovalsRequest): Promise<T.ListApprovalsResponse>;
+    listPolicies(request?: T.ListPoliciesRequest): Promise<T.ListPoliciesResponse>;
+    updatePolicy(request: T.UpdatePolicyRequest): Promise<T.UpdatePolicyResponse>;
+}

package/generated/policies/client.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoliciesClient = void 0;
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class PoliciesClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async archivePolicy(request) {
+        const path = (0, url_1.buildPathAndQuery)('/v2/policies/:policyId', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'DELETE',
+            body: {},
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createApprovalDecision(request) {
+        const path = (0, url_1.buildPathAndQuery)('/v2/policy-approvals/:approvalId/decisions', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createPolicy(request) {
+        const path = (0, url_1.buildPathAndQuery)('/v2/policies', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getPolicy(request) {
+        const path = (0, url_1.buildPathAndQuery)('/v2/policies/:policyId', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listApprovals(request) {
+        const path = (0, url_1.buildPathAndQuery)('/v2/policy-approvals', {
+            path: request ?? {},
+            query: request?.query ?? {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPolicies(request) {
+        const path = (0, url_1.buildPathAndQuery)('/v2/policies', {
+            path: request ?? {},
+            query: request?.query ?? {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async updatePolicy(request) {
+        const path = (0, url_1.buildPathAndQuery)('/v2/policies/:policyId', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.PoliciesClient = PoliciesClient;

package/generated/policies/delegatedClient.d.ts

@@ -0,0 +1,18 @@
+import { SignUserActionChallengeRequest, UserActionChallengeResponse } from '../../baseAuthApi';
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient';
+import * as T from './types';
+export declare class DelegatedPoliciesClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    archivePolicyInit(request: T.ArchivePolicyRequest): Promise<UserActionChallengeResponse>;
+    archivePolicyComplete(request: T.ArchivePolicyRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchivePolicyResponse>;
+    createApprovalDecisionInit(request: T.CreateApprovalDecisionRequest): Promise<UserActionChallengeResponse>;
+    createApprovalDecisionComplete(request: T.CreateApprovalDecisionRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateApprovalDecisionResponse>;
+    createPolicyInit(request: T.CreatePolicyRequest): Promise<UserActionChallengeResponse>;
+    createPolicyComplete(request: T.CreatePolicyRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePolicyResponse>;
+    getPolicy(request: T.GetPolicyRequest): Promise<T.GetPolicyResponse>;
+    listApprovals(request?: T.ListApprovalsRequest): Promise<T.ListApprovalsResponse>;
+    listPolicies(request?: T.ListPoliciesRequest): Promise<T.ListPoliciesResponse>;
+    updatePolicyInit(request: T.UpdatePolicyRequest): Promise<UserActionChallengeResponse>;
+    updatePolicyComplete(request: T.UpdatePolicyRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdatePolicyResponse>;
+}