algosdk 1.13.0-beta.1 → 1.13.0-beta.2

package/dist/types/src/abi/abi_type.d.ts

@@ -6,7 +6,7 @@ export declare const LENGTH_ENCODE_BYTE_SIZE = 2;
 export declare type ABIValue = boolean | number | bigint | string | Uint8Array | ABIValue[];
 export declare abstract class ABIType {
     abstract toString(): string;
-    abstract equal(other: ABIType): boolean;
+    abstract equals(other: ABIType): boolean;
     abstract isDynamic(): boolean;
     abstract byteLen(): number;
     abstract encode(value: ABIValue): Uint8Array;
@@ -17,10 +17,10 @@ export declare class ABIUintType extends ABIType {
     bitSize: number;
     constructor(size: number);
     toString(): string;
-    equal(other: ABIUintType): boolean;
+    equals(other: ABIType): boolean;
     isDynamic(): boolean;
     byteLen(): number;
-    encode(value: bigint | number): Uint8Array;
+    encode(value: ABIValue): Uint8Array;
     decode(byteString: Uint8Array): bigint;
 }
 export declare class ABIUfixedType extends ABIType {
@@ -28,42 +28,42 @@ export declare class ABIUfixedType extends ABIType {
     precision: number;
     constructor(size: number, denominator: number);
     toString(): string;
-    equal(other: ABIUfixedType): boolean;
+    equals(other: ABIType): boolean;
     isDynamic(): boolean;
     byteLen(): number;
-    encode(value: bigint | number): Uint8Array;
+    encode(value: ABIValue): Uint8Array;
     decode(byteString: Uint8Array): bigint;
 }
 export declare class ABIAddressType extends ABIType {
     toString(): string;
-    equal(other: ABIAddressType): boolean;
+    equals(other: ABIType): boolean;
     isDynamic(): boolean;
     byteLen(): number;
-    encode(value: string | Uint8Array): Uint8Array;
+    encode(value: ABIValue): Uint8Array;
     decode(byteString: Uint8Array): string;
 }
 export declare class ABIBoolType extends ABIType {
     toString(): string;
-    equal(other: ABIBoolType): boolean;
+    equals(other: ABIType): boolean;
     isDynamic(): boolean;
     byteLen(): number;
-    encode(value: boolean): Uint8Array;
+    encode(value: ABIValue): Uint8Array;
     decode(byteString: Uint8Array): boolean;
 }
 export declare class ABIByteType extends ABIType {
     toString(): string;
-    equal(other: ABIByteType): boolean;
+    equals(other: ABIType): boolean;
     isDynamic(): boolean;
     byteLen(): number;
-    encode(value: number): Uint8Array;
+    encode(value: ABIValue): Uint8Array;
     decode(byteString: Uint8Array): number;
 }
 export declare class ABIStringType extends ABIType {
     toString(): string;
-    equal(other: ABIStringType): boolean;
+    equals(other: ABIType): boolean;
     isDynamic(): boolean;
     byteLen(): never;
-    encode(value: string): Uint8Array;
+    encode(value: ABIValue): Uint8Array;
     decode(byteString: Uint8Array): string;
 }
 export declare class ABIArrayStaticType extends ABIType {
@@ -71,10 +71,10 @@ export declare class ABIArrayStaticType extends ABIType {
     staticLength: number;
     constructor(argType: ABIType, arrayLength: number);
     toString(): string;
-    equal(other: ABIArrayStaticType): boolean;
+    equals(other: ABIType): boolean;
     isDynamic(): boolean;
     byteLen(): number;
-    encode(values: ABIValue[]): Uint8Array;
+    encode(value: ABIValue): Uint8Array;
     decode(byteString: Uint8Array): ABIValue[];
     toABITupleType(): ABITupleType;
 }
@@ -82,10 +82,10 @@ export declare class ABIArrayDynamicType extends ABIType {
     childType: ABIType;
     constructor(argType: ABIType);
     toString(): string;
-    equal(other: ABIArrayDynamicType): boolean;
+    equals(other: ABIType): boolean;
     isDynamic(): boolean;
     byteLen(): never;
-    encode(values: ABIValue[]): Uint8Array;
+    encode(value: ABIValue): Uint8Array;
     decode(byteString: Uint8Array): ABIValue[];
     toABITupleType(length: number): ABITupleType;
 }
@@ -93,10 +93,10 @@ export declare class ABITupleType extends ABIType {
     childTypes: ABIType[];
     constructor(argTypes: ABIType[]);
     toString(): string;
-    equal(other: ABITupleType): boolean;
+    equals(other: ABIType): boolean;
     isDynamic(): boolean;
     byteLen(): number;
-    encode(values: ABIValue[]): Uint8Array;
+    encode(value: ABIValue): Uint8Array;
     decode(byteString: Uint8Array): ABIValue[];
     static parseTupleContent(str: string): string[];
 }

package/dist/types/src/abi/contract.d.ts

@@ -1,12 +1,20 @@
 import { ABIMethod, ABIMethodParams } from './method';
+export interface ABIContractNetworkInfo {
+    appID: number;
+}
+export interface ABIContractNetworks {
+    [network: string]: ABIContractNetworkInfo;
+}
 export interface ABIContractParams {
     name: string;
-    appId: number;
+    desc?: string;
+    networks?: ABIContractNetworks;
     methods: ABIMethodParams[];
 }
 export declare class ABIContract {
     readonly name: string;
-    readonly appId: number;
+    readonly description?: string;
+    readonly networks: ABIContractNetworks;
     readonly methods: ABIMethod[];
     constructor(params: ABIContractParams);
     toJSON(): ABIContractParams;

package/dist/types/src/abi/index.d.ts

@@ -2,3 +2,5 @@ export * from './abi_type';
 export * from './contract';
 export * from './interface';
 export * from './method';
+export * from './transaction';
+export * from './reference';

package/dist/types/src/abi/interface.d.ts

@@ -1,10 +1,12 @@
 import { ABIMethod, ABIMethodParams } from './method';
 export interface ABIInterfaceParams {
     name: string;
+    desc?: string;
     methods: ABIMethodParams[];
 }
 export declare class ABIInterface {
     readonly name: string;
+    readonly description?: string;
     readonly methods: ABIMethod[];
     constructor(params: ABIInterfaceParams);
     toJSON(): ABIInterfaceParams;

package/dist/types/src/abi/method.d.ts

@@ -1,20 +1,22 @@
-import { TransactionType } from '../types/transactions/base';
 import { ABIType } from './abi_type';
-export declare function abiTypeIsTransaction(type: string): type is TransactionType;
+import { ABITransactionType } from './transaction';
+import { ABIReferenceType } from './reference';
+export interface ABIMethodArgParams {
+    type: string;
+    name?: string;
+    desc?: string;
+}
+export interface ABIMethodReturnParams {
+    type: string;
+    desc?: string;
+}
 export interface ABIMethodParams {
     name: string;
     desc?: string;
-    args: Array<{
-        type: string;
-        name?: string;
-        desc?: string;
-    }>;
-    returns: {
-        type: string;
-        desc?: string;
-    };
+    args: ABIMethodArgParams[];
+    returns: ABIMethodReturnParams;
 }
-export declare type ABIArgumentType = ABIType | TransactionType;
+export declare type ABIArgumentType = ABIType | ABITransactionType | ABIReferenceType;
 export declare type ABIReturnType = ABIType | 'void';
 export declare class ABIMethod {
     readonly name: string;

package/dist/types/src/abi/reference.d.ts

@@ -0,0 +1,15 @@
+export declare enum ABIReferenceType {
+    /**
+     * Account reference type
+     */
+    account = "account",
+    /**
+     * Application reference type
+     */
+    application = "application",
+    /**
+     * Asset reference type
+     */
+    asset = "asset"
+}
+export declare function abiTypeIsReference(type: any): type is ABIReferenceType;

package/dist/types/src/abi/transaction.d.ts

@@ -0,0 +1,33 @@
+import { Transaction } from '../transaction';
+export declare enum ABITransactionType {
+    /**
+     * Any transaction type
+     */
+    any = "txn",
+    /**
+     * Payment transaction type
+     */
+    pay = "pay",
+    /**
+     * Key registration transaction type
+     */
+    keyreg = "keyreg",
+    /**
+     * Asset configuration transaction type
+     */
+    acfg = "acfg",
+    /**
+     * Asset transfer transaction type
+     */
+    axfer = "axfer",
+    /**
+     * Asset freeze transaction type
+     */
+    afrz = "afrz",
+    /**
+     * Application transaction type
+     */
+    appl = "appl"
+}
+export declare function abiTypeIsTransaction(type: any): type is ABITransactionType;
+export declare function abiCheckTransactionType(type: ABITransactionType, txn: Transaction): boolean;

package/dist/types/src/client/baseHTTPClient.d.ts

@@ -0,0 +1,41 @@
+export declare type Query<F> = {
+    format?: F;
+    [key: string]: any;
+};
+export interface BaseHTTPClientResponse {
+    body: Uint8Array;
+    status: number;
+    headers: Record<string, string>;
+}
+/**
+ * BaseHTTPClientError is the interface that errors thrown
+ * by methods of BaseHTTPClient should be using
+ */
+export interface BaseHTTPClientError {
+    response: BaseHTTPClientResponse;
+}
+/**
+ * BaseHTTPClient is an interface abstracting the queries that can be
+ * made to an algod/indexer endpoint.
+ * The SDK normally uses the URLTokenBaseHTTPClient implementation.
+ * But when used via wallets, the wallet may provide a different object
+ * satisfying the HTTPClient interface. This is useful to allow
+ * wallets to provide access to paid API services without leaking
+ * the secret tokens/URLs.
+ *
+ * Note that post and delete also have an optional query parameter
+ * This is to allow future extension where post and delete may have queries
+ * Currently however HTTPClient does not make use of it
+ *
+ * Compared to HTTPClient, BaseHTTPClient does not deal with serialization/deserialization
+ * Everything is already string/Uint8Array
+ * and all the headers (including Accept/Content-Type) are assumed to be provided
+ *
+ * In case of non-200 status, all methods must throw an error of type
+ * BaseHTTPClientError
+ */
+export interface BaseHTTPClient {
+    get(relativePath: string, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+    post(relativePath: string, data: Uint8Array, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+    delete(relativePath: string, data: Uint8Array, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+}

package/dist/types/src/client/client.d.ts

@@ -1,35 +1,62 @@
-import * as request from 'superagent';
 import * as utils from '../utils/utils';
-import IntDecoding from '../types/intDecoding';
-declare type Query<F> = {
-    format?: F;
-    [key: string]: any;
-};
-export interface AlgodTokenHeader {
-    'X-Algo-API-Token': string;
+import { BaseHTTPClient, Query } from './baseHTTPClient';
+import { TokenHeader } from './urlTokenBaseHTTPClient';
+export interface HTTPClientResponse {
+    body: Uint8Array | any;
+    text?: string;
+    headers: Record<string, string>;
+    status: number;
+    ok: boolean;
 }
-export interface IndexerTokenHeader {
-    'X-Indexer-API-Token': string;
-}
-export interface KMDTokenHeader {
-    'X-KMD-API-Token': string;
-}
-export interface CustomTokenHeader {
-    [headerName: string]: string;
-}
-export declare type TokenHeader = AlgodTokenHeader | IndexerTokenHeader | KMDTokenHeader | CustomTokenHeader;
+/**
+ * HTTPClient is a wrapper around a BaseHTTPClient
+ * It takes care of setting the proper "Accept" header and of
+ * decoding the JSON outputs.
+ */
 export default class HTTPClient {
-    private defaultHeaders;
-    private baseURL;
-    private tokenHeader;
-    intDecoding: IntDecoding;
-    constructor(tokenHeader: TokenHeader, baseServer: string, port?: string | number, defaultHeaders?: Record<string, any>);
+    private bc;
+    /**
+     * Construct an HTTPClient from a BaseHTTPClient
+     * @param bc - the BaseHTTPClient used
+     */
+    constructor(bc: BaseHTTPClient);
+    /**
+     * Construct an HTTPClient from a URL (baseServer+port) and a token
+     */
+    constructor(tokenHeader: TokenHeader, baseServer: string, port?: string | number, defaultHeaders?: Record<string, string>);
+    /**
+     * Parse JSON using either the built-in JSON.parse or utils.parseJSON
+     * depending on whether jsonOptions are provided or not
+     *
+     * @param text JSON data
+     * @param status Status of the response (used in case parseJSON fails)
+     * @param jsonOptions Options object to use to decode JSON responses. See
+     *   utils.parseJSON for the options available.
+     * @private
+     */
+    private static parseJSON;
+    /**
+     * Serialize the data according to the requestHeaders
+     * Assumes that requestHeaders contain a key "content-type"
+     * If the content-type is "application/json", data is JSON serialized
+     * Otherwise, data needs to be either an UTF-8 string that is converted to an Uint8Array
+     * or an Uint8Array
+     * @private
+     */
+    private static serializeData;
+    /**
+     * Convert a BaseHTTPClientResponse into a full HTTPClientResponse
+     * Parse the body in
+     * Modifies in place res and return the result
+     */
+    private static prepareResponse;
     /**
-     * Compute the URL for a path relative to the instance's address
-     * @param relativePath - A path string
-     * @returns A URL string
+     * Prepare an error with a response
+     * (the type of errors BaseHTTPClient are supposed to throw)
+     * by adding the status and preparing the internal response
+     * @private
      */
-    private addressWithPath;
+    private static prepareResponseError;
     /**
      * Send a GET request.
      * @param {string} relativePath The path of the request.
@@ -39,8 +66,17 @@ export default class HTTPClient {
      *   utils.parseJSON for the options available.
      * @returns Response object.
      */
-    get(relativePath: string, query?: Query<any>, requestHeaders?: Record<string, any>, jsonOptions?: utils.JSONOptions): Promise<request.Response>;
-    post(relativePath: string, data: string | object, requestHeaders?: Record<string, any>): Promise<request.Response>;
-    delete(relativePath: string, data: string | object, requestHeaders?: Record<string, any>): Promise<request.Response>;
+    get(relativePath: string, query?: Query<any>, requestHeaders?: Record<string, string>, jsonOptions?: utils.JSONOptions): Promise<HTTPClientResponse>;
+    /**
+     * Send a POST request.
+     * If no content-type present, adds the header "content-type: application/json"
+     * and data is serialized in JSON (if not empty)
+     */
+    post(relativePath: string, data: any, requestHeaders?: Record<string, string>): Promise<HTTPClientResponse>;
+    /**
+     * Send a DELETE request.
+     * If no content-type present, adds the header "content-type: application/json"
+     * and data is serialized in JSON (if not empty)
+     */
+    delete(relativePath: string, data: any, requestHeaders?: Record<string, string>): Promise<HTTPClientResponse>;
 }
-export {};

package/dist/types/src/client/kmd.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import ServiceClient from './v2/serviceClient';
 import * as txn from '../transaction';
-import { CustomTokenHeader, KMDTokenHeader } from './client';
+import { CustomTokenHeader, KMDTokenHeader } from './urlTokenBaseHTTPClient';
 export default class Kmd extends ServiceClient {
     constructor(token: string | KMDTokenHeader | CustomTokenHeader, baseServer?: string, port?: string | number, headers?: {});
     /**

package/dist/types/src/client/urlTokenBaseHTTPClient.d.ts

@@ -0,0 +1,44 @@
+import { BaseHTTPClient, BaseHTTPClientResponse, Query } from './baseHTTPClient';
+export interface AlgodTokenHeader {
+    'X-Algo-API-Token': string;
+}
+export interface IndexerTokenHeader {
+    'X-Indexer-API-Token': string;
+}
+export interface KMDTokenHeader {
+    'X-KMD-API-Token': string;
+}
+export interface CustomTokenHeader {
+    [headerName: string]: string;
+}
+export declare type TokenHeader = AlgodTokenHeader | IndexerTokenHeader | KMDTokenHeader | CustomTokenHeader;
+/**
+ * Implementation of BaseHTTPClient that uses a URL and a token
+ * and make the REST queries using superagent.
+ * This is the default implementation of BaseHTTPClient.
+ */
+export declare class URLTokenBaseHTTPClient implements BaseHTTPClient {
+    private defaultHeaders;
+    private readonly baseURL;
+    private readonly tokenHeader;
+    constructor(tokenHeader: TokenHeader, baseServer: string, port?: string | number, defaultHeaders?: Record<string, any>);
+    /**
+     * Compute the URL for a path relative to the instance's address
+     * @param relativePath - A path string
+     * @returns A URL string
+     */
+    private addressWithPath;
+    /**
+     * Convert a superagent response to a valid BaseHTTPClientResponse
+     * Modify the superagent response
+     * @private
+     */
+    private static superagentToHTTPClientResponse;
+    /**
+     * Make a superagent error more readable. For more info, see https://github.com/visionmedia/superagent/issues/1074
+     */
+    private static formatSuperagentError;
+    get(relativePath: string, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+    post(relativePath: string, data: Uint8Array, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+    delete(relativePath: string, data: Uint8Array, query?: Query<string>, requestHeaders?: Record<string, string>): Promise<BaseHTTPClientResponse>;
+}

package/dist/types/src/client/v2/algod/algod.d.ts

@@ -1,5 +1,4 @@
 import ServiceClient from '../serviceClient';
-import { AlgodTokenHeader, CustomTokenHeader } from '../../client';
 import * as modelsv2 from './models/types';
 import AccountInformation from './accountInformation';
 import Block from './block';
@@ -19,8 +18,15 @@ import Supply from './supply';
 import Versions from './versions';
 import Genesis from './genesis';
 import Proof from './proof';
+import { BaseHTTPClient } from '../../baseHTTPClient';
+import { AlgodTokenHeader, CustomTokenHeader } from '../../urlTokenBaseHTTPClient';
 export default class AlgodClient extends ServiceClient {
-    constructor(token: string | AlgodTokenHeader | CustomTokenHeader, baseServer?: string, port?: string | number, headers?: {});
+    /**
+     * Create an AlgodClient from
+     * * either a token, baseServer, port, and optional headers
+     * * or a base client server for interoperability with external dApp wallets
+     */
+    constructor(tokenOrBaseClient: string | AlgodTokenHeader | CustomTokenHeader | BaseHTTPClient, baseServer?: string, port?: string | number, headers?: Record<string, string>);
     healthCheck(): HealthCheck;
     versionsCheck(): Versions;
     sendRawTransaction(stxOrStxs: Uint8Array | Uint8Array[]): SendRawTransaction;

package/dist/types/src/client/v2/indexer/indexer.d.ts

@@ -1,5 +1,4 @@
 import ServiceClient from '../serviceClient';
-import { CustomTokenHeader, IndexerTokenHeader } from '../../client';
 import MakeHealthCheck from './makeHealthCheck';
 import LookupAssetBalances from './lookupAssetBalances';
 import LookupAssetTransactions from './lookupAssetTransactions';
@@ -14,8 +13,15 @@ import SearchAccounts from './searchAccounts';
 import SearchForTransactions from './searchForTransactions';
 import SearchForAssets from './searchForAssets';
 import SearchForApplications from './searchForApplications';
+import { BaseHTTPClient } from '../../baseHTTPClient';
+import { CustomTokenHeader, IndexerTokenHeader } from '../../urlTokenBaseHTTPClient';
 export default class IndexerClient extends ServiceClient {
-    constructor(token: string | IndexerTokenHeader | CustomTokenHeader, baseServer?: string, port?: string | number, headers?: {});
+    /**
+     * Create an IndexerClient from
+     * * either a token, baseServer, port, and optional headers
+     * * or a base client server for interoperability with external dApp wallets
+     */
+    constructor(tokenOrBaseClient: string | IndexerTokenHeader | CustomTokenHeader | BaseHTTPClient, baseServer?: string, port?: string | number, headers?: Record<string, string>);
     /**
      * Returns the health object for the service.
      */

package/dist/types/src/client/v2/serviceClient.d.ts

@@ -1,5 +1,7 @@
-import HTTPClient, { TokenHeader } from '../client';
+import HTTPClient from '../client';
 import IntDecoding from '../../types/intDecoding';
+import { BaseHTTPClient } from '../baseHTTPClient';
+import { TokenHeader } from '../urlTokenBaseHTTPClient';
 export declare type TokenHeaderIdentifier = 'X-Indexer-API-Token' | 'X-KMD-API-Token' | 'X-Algo-API-Token' | string;
 /**
  * Abstract service client to encapsulate shared AlgodClient and IndexerClient logic
@@ -7,7 +9,7 @@ export declare type TokenHeaderIdentifier = 'X-Indexer-API-Token' | 'X-KMD-API-T
 export default abstract class ServiceClient {
     c: HTTPClient;
     intDecoding: IntDecoding;
-    constructor(tokenHeaderIdentifier: TokenHeaderIdentifier, tokenHeaderOrStr: string | TokenHeader, baseServer: string, port?: string | number, defaultHeaders?: Record<string, any>);
+    constructor(tokenHeaderIdentifier: TokenHeaderIdentifier, tokenHeaderOrStrOrBaseClient: string | TokenHeader | BaseHTTPClient, baseServer: string, port?: string | number, defaultHeaders?: Record<string, any>);
     /**
      * Set the default int decoding method for all JSON requests this client creates.
      * @param method - \{"default" | "safe" | "mixed" | "bigint"\} method The method to use when parsing the

package/dist/types/src/composer.d.ts

@@ -68,9 +68,9 @@ export declare class AtomicTransactionComposer {
      * causes the current group to exceed MAX_GROUP_SIZE, or if the provided arguments are invalid
      * for the given method.
      */
-    addMethodCall({ appId, method, methodArgs, sender, suggestedParams, onComplete, note, lease, rekeyTo, signer, }: {
-        /** The ID of the smart contract to call */
-        appId: number;
+    addMethodCall({ appID, method, methodArgs, sender, suggestedParams, onComplete, approvalProgram, clearProgram, numGlobalInts, numGlobalByteSlices, numLocalInts, numLocalByteSlices, extraPages, note, lease, rekeyTo, signer, }: {
+        /** The ID of the smart contract to call. Set this to 0 to indicate an application creation call. */
+        appID: number;
         /** The method to call on the smart contract */
         method: ABIMethod;
         /** The arguments to include in the method call. If omitted, no arguments will be passed to the method. */
@@ -81,6 +81,20 @@ export declare class AtomicTransactionComposer {
         suggestedParams: SuggestedParams;
         /** The OnComplete action to take for this application call. If omitted, OnApplicationComplete.NoOpOC will be used. */
         onComplete?: OnApplicationComplete;
+        /** The approval program for this application call. Only set this if this is an application creation call, or if onComplete is OnApplicationComplete.UpdateApplicationOC */
+        approvalProgram?: Uint8Array;
+        /** The clear program for this application call. Only set this if this is an application creation call, or if onComplete is OnApplicationComplete.UpdateApplicationOC */
+        clearProgram?: Uint8Array;
+        /** The global integer schema size. Only set this if this is an application creation call. */
+        numGlobalInts?: number;
+        /** The global byte slice schema size. Only set this if this is an application creation call. */
+        numGlobalByteSlices?: number;
+        /** The local integer schema size. Only set this if this is an application creation call. */
+        numLocalInts?: number;
+        /** The local byte slice schema size. Only set this if this is an application creation call. */
+        numLocalByteSlices?: number;
+        /** The number of extra pages to allocate for the application's programs. Only set this if this is an application creation call. If omitted, defaults to 0. */
+        extraPages?: number;
         /** The note value for this application call */
         note?: Uint8Array;
         /** The lease value for this application call */

package/dist/types/src/main.d.ts

@@ -66,6 +66,7 @@ export { default as Kmd } from './client/kmd';
 export { default as IntDecoding } from './types/intDecoding';
 export { default as Account } from './types/account';
 export { default as Indexer } from './client/v2/indexer/indexer';
+export { BaseHTTPClient, BaseHTTPClientResponse, BaseHTTPClientError, } from './client/baseHTTPClient';
 export { waitForConfirmation } from './wait';
 export { isValidAddress, encodeAddress, decodeAddress, getApplicationAddress, } from './encoding/address';
 export { encodeUint64, decodeUint64 } from './encoding/uint64';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "algosdk",
-  "version": "1.13.0-beta.1",
+  "version": "1.13.0-beta.2",
   "description": "The official JavaScript SDK for Algorand",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -59,7 +59,9 @@
     "source-map-loader": "^2.0.2",
     "ts-loader": "^8.3.0",
     "ts-node": "^10.0.0",
-    "typedoc": "^0.20.36",
+    "typedoc": "^0.22.10",
+    "typedoc-plugin-missing-exports": "^0.22.6",
+    "typedoc-plugin-rename-defaults": "^0.4.0",
     "typescript": "^4.2.3",
     "webpack": "^5.38.1",
     "webpack-cli": "^4.7.2"
@@ -69,7 +71,7 @@
     "prepare": "npm run build",
     "prepare-browser-tests": "npm run build && mkdir -p tests/cucumber/browser/build && cp dist/browser/algosdk.min.* tests/cucumber/browser/build/ && webpack --config tests/cucumber/browser/webpack.config.js",
     "build": "concurrently \"webpack --config webpack.config.js\" \"tsc -p tsconfig-esm.json\" \"tsc -p tsconfig-cjs.json\"",
-    "docs": "typedoc src/main.ts",
+    "docs": "typedoc src/main.ts --options typedoc.config.json",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "format": "prettier --write .",