@dfns/sdk 0.1.0-alpha.1

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

@@ -0,0 +1,252 @@
+import { Amount, AssetSymbol, EntityId, IntegerPositiveStrict, IsoDatetime, Tag, Username } from '../Foundations';
+export type Policy = {
+    id: EntityId;
+    version: string;
+    activityKind: PolicyActivityKind;
+    tags?: Tag[];
+    dateCreated: IsoDatetime;
+    orgId: EntityId;
+    description?: string;
+    author: Username;
+    name?: string;
+    status: PolicyStatus;
+    controlIds: EntityId[];
+    ruleIds: EntityId[];
+    filter?: PolicyObjectFilter;
+};
+export type NotifyAndAuditPcConf = {
+    kind: PolicyControlKind.NotifyAndAudit;
+    usernames?: string[];
+    groups?: string[];
+};
+export type RequestApprovalPcConf = {
+    kind: PolicyControlKind.RequestApproval;
+    approverGroups?: string[];
+    approverUsernames?: string[];
+    numApprovals: number;
+    timeoutInMinutes?: IntegerPositiveStrict;
+};
+export type PolicyRule = {
+    id: EntityId;
+    version: string;
+    kind: PolicyRuleKind;
+    tags?: Tag[];
+    dateCreated: IsoDatetime;
+    orgId: EntityId;
+    author: Username;
+    description?: string;
+    name?: string;
+    configuration: PolicyRuleConfiguration;
+    status: PolicyRuleStatus;
+};
+export type PolicyControl = {
+    id: EntityId;
+    version: string;
+    kind: PolicyControlKind;
+    tags?: Tag[];
+    dateCreated: IsoDatetime;
+    orgId: EntityId;
+    author: Username;
+    description?: string;
+    name?: string;
+    /**
+     * Indicates whether control should merge with same one (compared by values).
+     * This property should not be set to true, unless outcomes are understood. For example: Let's say we have 3 policies:
+     *
+     * 1. policy to require approval for payments over €5000
+     * 1. policy to require approval for payments done out of office hours
+     * 1. policy to require approval for payments done out of Geofence.
+     *
+     * In this case policies will require 3 approvals combined, which might not be an intent, and only one approval is required.
+     */
+    shouldMergeWithSameControl: boolean;
+    configuration: PolicyControlConfiguration;
+    status: PolicyControlStatus;
+};
+export type CreateAmountLimitPrConf = {
+    kind: PolicyRuleKind.PaymentAmountLimit;
+    limit: Amount;
+    assetSymbol: AssetSymbol;
+    shouldIgnoreAssetsWithoutMarketValue: boolean;
+};
+export type UpdateAmountLimitPrConf = {
+    limit?: Amount;
+    assetSymbol?: AssetSymbol;
+    shouldIgnoreAssetsWithoutMarketValue?: boolean;
+};
+export type CreateOutgoingVelocityPrConf = {
+    kind: PolicyRuleKind.PaymentAmountOutgoingVelocity;
+    velocity: Amount;
+    assetSymbol: AssetSymbol;
+    intervalInMinutes: number;
+    shouldIgnoreAssetsWithoutMarketValue: boolean;
+};
+export type CreateSiphoningPrConf = {
+    kind: PolicyRuleKind.Siphoning;
+    maxTxCount: number;
+    intervalInMinutes: number;
+};
+export type SiphoningPrConf = {
+    maxTxCount: number;
+    intervalInMinutes: number;
+};
+export type UpdateSiphoningPrConf = {
+    maxTxCount?: number;
+    intervalInMinutes?: number;
+};
+export type AmountLimitPrConf = {
+    limit: Amount;
+    assetSymbol: AssetSymbol;
+    shouldIgnoreAssetsWithoutMarketValue: boolean;
+};
+export type UpdateOutgoingVelocityPrConf = {
+    velocity?: Amount;
+    assetSymbol?: AssetSymbol;
+    intervalInMinutes?: number;
+    shouldIgnoreAssetsWithoutMarketValue?: boolean;
+};
+export type OutgoingVelocityPrConf = {
+    velocity: Amount;
+    assetSymbol: AssetSymbol;
+    intervalInMinutes: number;
+    shouldIgnoreAssetsWithoutMarketValue: boolean;
+};
+export type CreateRequestApprovalPcConf = {
+    kind: PolicyControlKind.RequestApproval;
+    approverUsernames?: string[];
+    approverGroups?: string[];
+    timeoutInMinutes?: IntegerPositiveStrict;
+    numApprovals: number;
+};
+export type UpdateRequestApprovalPcConf = {
+    approverUsernames?: string[];
+    approverGroups?: string[];
+    timeoutInMinutes?: number;
+    numApprovals?: number;
+};
+export type CreateNotifyAndAuditPcConf = {
+    kind: PolicyControlKind.NotifyAndAudit;
+    usernames?: string[];
+    groups?: string[];
+};
+export type UpdateNotifyAndAuditPcConf = {
+    groups?: string[];
+    usernames?: string[];
+};
+export type PolicyManagementPreferences = {
+    /**
+     * Sets default `AssetSymbol` for the policy rules that use it, such as Limit, Velocity, Siphoning, and others.
+     */
+    policyRuleAssetSymbol?: boolean;
+    /**
+     * Sets default interval in minutes for policy rules that use intervals, such as Velocity and Siphoning.
+     *
+     * This setting does not update existing rules. This will only impact rules that are created  after this setting is set.
+     */
+    policyRuleVelocityIntervalInMinutes?: number;
+};
+export type Create = {};
+export type EmptyConfiguration = {};
+export type CreateAlwaysActivatedPrConf = {
+    kind: PolicyRuleKind.AlwaysActivated;
+};
+export type UpdateAlwaysActivatedPrConf = {};
+export type AssetAccountFilter = {
+    kind: PolicyObjectFilterKind.AssetAccount;
+    assetAccountIds?: EntityId[];
+    tags?: Tag[];
+    assetSymbols?: string[];
+};
+export type PublicKeyFilter = {
+    kind: PolicyObjectFilterKind.PublicKey;
+    publicKeyIds?: EntityId[];
+    tags?: string[];
+};
+export type CreatePolicyInput = {
+    activityKind: PolicyActivityKind;
+    description: string;
+    name?: string;
+    controlIds: EntityId[];
+    ruleIds: EntityId[];
+    status: PolicyStatus;
+    filter?: PolicyObjectFilter;
+    isImmutable?: boolean;
+};
+export type UpdatePolicyInput = {
+    description?: string;
+    controlIds?: EntityId[];
+    ruleIds?: EntityId[];
+    status?: PolicyStatus;
+    filter?: PolicyObjectFilter;
+};
+export type CreatePolicyControlInput = {
+    description?: string;
+    name?: string;
+    configuration: CreatePolicyControlConfiguration;
+    isImmutable?: boolean;
+};
+export type UpdatePolicyControlInput = {
+    description?: string;
+    name?: string;
+    configuration?: UpdatePolicyControlConfiguration;
+};
+export type CreatePolicyRuleInput = {
+    description?: string;
+    name?: string;
+    configuration: CreatePolicyRuleConfiguration;
+    isImmutable?: boolean;
+};
+export type UpdatePolicyRuleInput = {
+    description?: string;
+    name?: string;
+    configuration: UpdatePolicyRuleConfiguration;
+};
+export type CreatePolicyRuleConfiguration = CreateAmountLimitPrConf | CreateOutgoingVelocityPrConf | CreateSiphoningPrConf | CreateAlwaysActivatedPrConf;
+export type UpdatePolicyRuleConfiguration = UpdateAmountLimitPrConf | UpdateSiphoningPrConf | UpdateOutgoingVelocityPrConf | UpdateAlwaysActivatedPrConf;
+export type UpdatePolicyControlConfiguration = UpdateRequestApprovalPcConf | UpdateNotifyAndAuditPcConf;
+export type CreatePolicyControlConfiguration = CreateRequestApprovalPcConf | CreateNotifyAndAuditPcConf;
+export type PolicyRuleConfiguration = SiphoningPrConf | AmountLimitPrConf | OutgoingVelocityPrConf | OutgoingVelocityPrConf | EmptyConfiguration;
+export type PolicyControlConfiguration = NotifyAndAuditPcConf | RequestApprovalPcConf;
+export type PolicyObjectFilter = AssetAccountFilter | PublicKeyFilter;
+export declare enum PolicyActivityKind {
+    PaymentInitiation = "PaymentInitiation",
+    AddingEmployee = "AddingEmployee",
+    UpdatingEmployeeDetails = "UpdatingEmployeeDetails",
+    RemovingEmployee = "RemovingEmployee",
+    CreatingSignature = "CreatingSignature",
+    TransactionInitiation = "TransactionInitiation"
+}
+export declare enum PolicyStatus {
+    Enabled = "Enabled",
+    Disabled = "Disabled",
+    Archived = "Archived"
+}
+/**
+ * enumm:
+ * * NotifyAndAudit
+ * * RequestApproval
+ */
+export declare enum PolicyControlKind {
+    NotifyAndAudit = "NotifyAndAudit",
+    RequestApproval = "RequestApproval"
+}
+export declare enum PolicyRuleKind {
+    PaymentAmountLimit = "PaymentAmountLimit",
+    EmployeeAdded = "EmployeeAdded",
+    EmployeeDetailsUpdated = "EmployeeDetailsUpdated",
+    Siphoning = "Siphoning",
+    AlwaysActivated = "AlwaysActivated",
+    PaymentAmountOutgoingVelocity = "PaymentAmountOutgoingVelocity"
+}
+export declare enum PolicyControlStatus {
+    Enabled = "Enabled",
+    Archived = "Archived"
+}
+export declare enum PolicyRuleStatus {
+    Enabled = "Enabled",
+    Archived = "Archived"
+}
+export declare enum PolicyObjectFilterKind {
+    AssetAccount = "AssetAccount",
+    PublicKey = "PublicKey"
+}

package/codegen/datamodel/PolicyManagement/types.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyObjectFilterKind = exports.PolicyRuleStatus = exports.PolicyControlStatus = exports.PolicyRuleKind = exports.PolicyControlKind = exports.PolicyStatus = exports.PolicyActivityKind = void 0;
+// FIXME: Missing documentation for PolicyActivityKind
+var PolicyActivityKind;
+(function (PolicyActivityKind) {
+    // FIXME: Missing documentation for PaymentInitiation
+    PolicyActivityKind["PaymentInitiation"] = "PaymentInitiation";
+    // FIXME: Missing documentation for AddingEmployee
+    PolicyActivityKind["AddingEmployee"] = "AddingEmployee";
+    // FIXME: Missing documentation for UpdatingEmployeeDetails
+    PolicyActivityKind["UpdatingEmployeeDetails"] = "UpdatingEmployeeDetails";
+    // FIXME: Missing documentation for RemovingEmployee
+    PolicyActivityKind["RemovingEmployee"] = "RemovingEmployee";
+    // FIXME: Missing documentation for CreatingSignature
+    PolicyActivityKind["CreatingSignature"] = "CreatingSignature";
+    // FIXME: Missing documentation for TransactionInitiation
+    PolicyActivityKind["TransactionInitiation"] = "TransactionInitiation";
+})(PolicyActivityKind = exports.PolicyActivityKind || (exports.PolicyActivityKind = {}));
+// FIXME: Missing documentation for PolicyStatus
+var PolicyStatus;
+(function (PolicyStatus) {
+    // FIXME: Missing documentation for Enabled
+    PolicyStatus["Enabled"] = "Enabled";
+    // FIXME: Missing documentation for Disabled
+    PolicyStatus["Disabled"] = "Disabled";
+    // FIXME: Missing documentation for Archived
+    PolicyStatus["Archived"] = "Archived";
+})(PolicyStatus = exports.PolicyStatus || (exports.PolicyStatus = {}));
+/**
+ * enumm:
+ * * NotifyAndAudit
+ * * RequestApproval
+ */
+var PolicyControlKind;
+(function (PolicyControlKind) {
+    // FIXME: Missing documentation for NotifyAndAudit
+    PolicyControlKind["NotifyAndAudit"] = "NotifyAndAudit";
+    // FIXME: Missing documentation for RequestApproval
+    PolicyControlKind["RequestApproval"] = "RequestApproval";
+})(PolicyControlKind = exports.PolicyControlKind || (exports.PolicyControlKind = {}));
+// FIXME: Missing documentation for PolicyRuleKind
+var PolicyRuleKind;
+(function (PolicyRuleKind) {
+    // FIXME: Missing documentation for PaymentAmountLimit
+    PolicyRuleKind["PaymentAmountLimit"] = "PaymentAmountLimit";
+    // FIXME: Missing documentation for EmployeeAdded
+    PolicyRuleKind["EmployeeAdded"] = "EmployeeAdded";
+    // FIXME: Missing documentation for EmployeeDetailsUpdated
+    PolicyRuleKind["EmployeeDetailsUpdated"] = "EmployeeDetailsUpdated";
+    // FIXME: Missing documentation for Siphoning
+    PolicyRuleKind["Siphoning"] = "Siphoning";
+    // FIXME: Missing documentation for AlwaysActivated
+    PolicyRuleKind["AlwaysActivated"] = "AlwaysActivated";
+    // FIXME: Missing documentation for PaymentAmountOutgoingVelocity
+    PolicyRuleKind["PaymentAmountOutgoingVelocity"] = "PaymentAmountOutgoingVelocity";
+})(PolicyRuleKind = exports.PolicyRuleKind || (exports.PolicyRuleKind = {}));
+// FIXME: Missing documentation for PolicyControlStatus
+var PolicyControlStatus;
+(function (PolicyControlStatus) {
+    // FIXME: Missing documentation for Enabled
+    PolicyControlStatus["Enabled"] = "Enabled";
+    // FIXME: Missing documentation for Archived
+    PolicyControlStatus["Archived"] = "Archived";
+})(PolicyControlStatus = exports.PolicyControlStatus || (exports.PolicyControlStatus = {}));
+// FIXME: Missing documentation for PolicyRuleStatus
+var PolicyRuleStatus;
+(function (PolicyRuleStatus) {
+    // FIXME: Missing documentation for Enabled
+    PolicyRuleStatus["Enabled"] = "Enabled";
+    // FIXME: Missing documentation for Archived
+    PolicyRuleStatus["Archived"] = "Archived";
+})(PolicyRuleStatus = exports.PolicyRuleStatus || (exports.PolicyRuleStatus = {}));
+// FIXME: Missing documentation for PolicyObjectFilterKind
+var PolicyObjectFilterKind;
+(function (PolicyObjectFilterKind) {
+    // FIXME: Missing documentation for AssetAccount
+    PolicyObjectFilterKind["AssetAccount"] = "AssetAccount";
+    // FIXME: Missing documentation for PublicKey
+    PolicyObjectFilterKind["PublicKey"] = "PublicKey";
+})(PolicyObjectFilterKind = exports.PolicyObjectFilterKind || (exports.PolicyObjectFilterKind = {}));

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

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

package/codegen/datamodel/PublicKeys/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/PublicKeys/responses.d.ts

@@ -0,0 +1,56 @@
+import { BadRequestError, EntityNotFoundError, ForbiddenError, PaymentRequiredError, UnauthorizedError } from '../Foundations';
+import { BroadcastedTransaction, GetPublicKeyAddressResponse, GetPublicKeyResponse, PublicKeyRecord, Signature, SignatureResponse, StartWalletConnectSessionOutput } from './types';
+export type GetPublicKeyByIdSuccess = GetPublicKeyResponse;
+export type GetPublicKeyByIdError = {
+    error: EntityNotFoundError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetPublicKeyByIdResponse = GetPublicKeyByIdSuccess | GetPublicKeyByIdError;
+export type CreatePublicKeySuccess = PublicKeyRecord;
+export type CreatePublicKeyError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreatePublicKeyResponse = CreatePublicKeySuccess | CreatePublicKeyError;
+export type ListPublicKeysSuccess = {
+    items: GetPublicKeyResponse[];
+};
+export type ListPublicKeysError = {
+    error: EntityNotFoundError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListPublicKeysResponse = ListPublicKeysSuccess | ListPublicKeysError;
+export type GetAddressForNetworkSuccess = GetPublicKeyAddressResponse;
+export type GetAddressForNetworkError = {
+    error: EntityNotFoundError | BadRequestError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetAddressForNetworkResponse = GetAddressForNetworkSuccess | GetAddressForNetworkError;
+export type GetSignatureByIdSuccess = Signature;
+export type GetSignatureByIdError = {
+    error: EntityNotFoundError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetSignatureByIdResponse = GetSignatureByIdSuccess | GetSignatureByIdError;
+export type CreateSignatureSuccess = SignatureResponse;
+export type CreateSignatureError = {
+    error: EntityNotFoundError | PaymentRequiredError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateSignatureResponse = CreateSignatureSuccess | CreateSignatureError;
+export type StartWalletConnectSessionSuccess = StartWalletConnectSessionOutput;
+export type StartWalletConnectSessionError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type StartWalletConnectSessionResponse = StartWalletConnectSessionSuccess | StartWalletConnectSessionError;
+export type ListTransactionsSuccess = {
+    items: BroadcastedTransaction[];
+};
+export type ListTransactionsError = {
+    error: EntityNotFoundError | BadRequestError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListTransactionsResponse = ListTransactionsSuccess | ListTransactionsError;
+export type CreateTransactionSuccess = BroadcastedTransaction;
+export type CreateTransactionError = {
+    error: EntityNotFoundError | BadRequestError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateTransactionResponse = CreateTransactionSuccess | CreateTransactionError;
+export type GetTransactionByIdSuccess = BroadcastedTransaction;
+export type GetTransactionByIdError = {
+    error: EntityNotFoundError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetTransactionByIdResponse = GetTransactionByIdSuccess | GetTransactionByIdError;

package/codegen/datamodel/PublicKeys/responses.js

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

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

@@ -0,0 +1,222 @@
+import { Amount, BlockchainAddress, BlockchainNetwork, DocumentSnapshot, EntityId, Initiator, IntegerPositiveStrict, IsoDatetime, PublicKey, Tag } from '../Foundations';
+export type SignatureResponse = {
+    r: string;
+    s: string;
+    recid: number;
+};
+export type PublicKeyRecord = {
+    id: EntityId;
+    externalId?: string;
+    orgId: EntityId;
+    publicKey: PublicKey;
+    signerIds: string[];
+    groupThreshold: number;
+    groupSize: number;
+    tags?: Tag[];
+    isEddsa: boolean;
+};
+export type GetPublicKeyAddressResponse = {
+    publicKeyId: string;
+    network: string;
+    address: BlockchainAddress;
+};
+export type Signature = {
+    id: EntityId;
+    orgId: EntityId;
+    publicKeyId: string;
+    hash: string;
+    r: string;
+    s: string;
+    recid: number;
+    status: SignatureStatus;
+    initiator: Initiator;
+    dateCreated: IsoDatetime;
+};
+export type CosmosDenomAmount = {
+    denom: string;
+    amount: string;
+};
+export type CosmosTimeoutHeight = {
+    revisionNumber: string;
+    revisionHeight: string;
+};
+export type EvmGenericTx = {
+    templateKind: TransactionTemplateKind.EvmGenericTx;
+    to: string;
+    gasLimit: Amount;
+    gasPrice: Amount;
+    nonce?: string;
+    value?: string;
+    data?: string;
+    publicKeyId?: string;
+    network: BlockchainNetwork;
+    /**
+     * the maximum amount of gas to be included as a tip to the miner
+     */
+    maxPriorityFeePerGas?: Amount;
+    /**
+     * the maximum amount of gas willing to be paid for the transaction (inclusive of baseFeePerGas and maxPriorityFeePerGas)
+     */
+    maxFeePerGas?: Amount;
+    typedData?: Eip712TypedData;
+};
+export type CosmosIbcTransferTx = {
+    templateKind: TransactionTemplateKind.CosmosIbcTransfer;
+    sourcePort: string;
+    sourceChannel: string;
+    token: CosmosDenomAmount;
+    sender: string;
+    receiver: string;
+    timeoutHeight: CosmosTimeoutHeight;
+    timeoutTimestamp: string;
+    publicKeyId?: string;
+    network: BlockchainNetwork;
+};
+export type Eip712TypedData = {
+    types: Record<string, unknown>;
+    values: Record<string, unknown>;
+    domain?: Eip712TypedDataDomain;
+};
+export type Eip712TypedDataDomain = {
+    name?: string;
+    chainId?: string;
+    version?: string;
+    verifyingContract?: string;
+    salt?: string;
+};
+export type SolanaTxInstruction = {
+    data: string;
+    programId: string;
+    keys: SolanaTxAccountMeta[];
+};
+export type SolanaTx = {
+    feePayer?: string;
+    blockhash?: string;
+    lastValidBlockHeight?: IntegerPositiveStrict;
+    minNonceContextSlot?: IntegerPositiveStrict;
+    instructions: SolanaTxInstruction[];
+    signatures?: SolanaTxSignature[];
+    templateKind: TransactionTemplateKind.SolanaTx;
+};
+export type SolanaTxSignature = {
+    signature: string;
+    publicKey: string;
+};
+export type SolanaTxAccountMeta = {
+    pubkey: string;
+    isSigner: boolean;
+    isWritable: boolean;
+};
+export type TronTx = {
+    visible?: boolean;
+    txID?: string;
+    contract_address?: string;
+    raw_data_hex?: string;
+    raw_data: Record<string, unknown>;
+    templateKind: TransactionTemplateKind.TronTx;
+};
+export type TezosTx = {
+    protocol?: string;
+    chain?: string;
+    block?: string;
+    payload: TezosTxPayload;
+    templateKind: TransactionTemplateKind.TezosTx;
+};
+export type TezosTxPayload = {
+    branch?: string;
+    contents: Record<string, unknown>[];
+};
+export type BroadcastedTransaction = {
+    id: EntityId;
+    transaction: TransactionPayload;
+    snapshot: DocumentSnapshot;
+    network: BlockchainNetwork;
+    dateCreated: IsoDatetime;
+    dateUpdated: IsoDatetime;
+    status: TransactionStatus;
+    txHash?: string;
+    networkResponse?: string;
+    dateBroadcasted?: IsoDatetime;
+    dateConfirmed?: IsoDatetime;
+    initiator: Initiator;
+    publicKeyId: string;
+    orgId: EntityId;
+    fee?: Amount;
+};
+export type GetPublicKeyResponse = {
+    id: EntityId;
+    externalId?: string;
+    publicKey: PublicKey;
+    groupThreshold: number;
+    groupSize: number;
+    tags?: Tag[];
+    isEddsa: boolean;
+};
+export type StartWalletConnectSessionOutput = {
+    session: WalletConnectSession;
+};
+export type WalletConnectClientMeta = {
+    name: string;
+    description: string;
+    icons: string[];
+};
+export type WalletConnectSession = {
+    accounts: string[];
+    chainId: IntegerPositiveStrict;
+    bridge: string;
+    key: string;
+    clientId: string;
+    clientMeta?: WalletConnectClientMeta;
+    peerId: string;
+    peerMeta?: WalletConnectClientMeta;
+    handshakeId: IntegerPositiveStrict;
+    handshakeTopic: string;
+};
+export type CreateSignatureInput = {
+    hash: string;
+};
+export type CreatePublicKeyInput = {
+    externalId?: string;
+    assetAccountId?: EntityId;
+    groupSize?: number;
+    groupThreshold?: number;
+    isEddsa: boolean;
+    tags?: Tag[];
+};
+export type CreateWalletTxInput = {
+    to: BlockchainAddress;
+    amount: Amount;
+    asset: string;
+};
+export type StartWalletConnectSessionInput = {
+    wcUri: string;
+};
+export type TransactionPayload = EvmGenericTx | CosmosIbcTransferTx | SolanaTx | TronTx | TezosTx;
+export declare enum PublicKeyStatus {
+    Active = "Active",
+    Disabled = "Disabled",
+    Compromised = "Compromised"
+}
+export declare enum SignatureStatus {
+    Pending = "Pending",
+    Executed = "Executed",
+    Rejected = "Rejected",
+    Failed = "Failed"
+}
+export declare enum TransactionTemplateKind {
+    EvmGenericTx = "EvmGenericTx",
+    CosmosIbcTransfer = "CosmosIbcTransfer",
+    SolanaTx = "SolanaTx",
+    TronTx = "TronTx",
+    TezosTx = "TezosTx"
+}
+export declare enum TransactionStatus {
+    Initiated = "Initiated",
+    PolicyAccepted = "PolicyAccepted",
+    PolicyRejected = "PolicyRejected",
+    BroadcastPending = "BroadcastPending",
+    BroadcastRejected = "BroadcastRejected",
+    Broadcasted = "Broadcasted",
+    Confirmed = "Confirmed",
+    Failed = "Failed"
+}