@imtbl/sdk 0.1.8-alpha.2 → 0.1.9-alpha

package/dist/orderbook.d.ts

@@ -1,6 +1,6 @@
 import { OrderbookModuleConfiguration } from 'config/config';
-import { OrderResult, ListOrdersResult } from 'openapi/sdk';
-import { ListOrderParams, PrepareListingParams, PrepareListingResponse, CreateOrderParams, FulfilOrderResponse, CancelOrderResponse } from 'types';
+import { ListingResult, ListListingsResult } from 'openapi/sdk';
+import { ListListingsParams, PrepareListingParams, PrepareListingResponse, CreateListingParams, FulfillOrderResponse, CancelOrderResponse } from 'types';
 
 /**
  * zkEVM orderbook SDK
@@ -14,49 +14,49 @@ declare class Orderbook {
     constructor(config: OrderbookModuleConfiguration);
     /**
      * Get an order by ID
-     * @param {string} orderId - The orderId to find.
-     * @return {OrderResult} The returned order result.
+     * @param {string} listingId - The listingId to find.
+     * @return {ListingResult} The returned order result.
      */
-    getOrder(orderId: string): Promise<OrderResult>;
+    getListing(listingId: string): Promise<ListingResult>;
     /**
      * List orders. This method is used to get a list of orders filtered by conditions specified
      * in the params object.
      * @param {ListOrderParams} listOrderParams - Filtering, ordering and page parameters.
      * @return {Orders} The paged orders.
      */
-    listOrders(listOrderParams: ListOrderParams): Promise<ListOrdersResult>;
+    listListings(listOrderParams: ListListingsParams): Promise<ListListingsResult>;
     /**
      * Get required transactions and messages for signing prior to creating a listing
-     * through the createOrder method
+     * through the createListing method
      * @param {PrepareListingParams} prepareListingParams - Details about the listing to be created.
      * @return {PrepareListingResponse} PrepareListingResponse includes
      * the unsigned approval transaction, the typed order message for signing and
-     * the order components that can be submitted to `createOrder` with a signature.
+     * the order components that can be submitted to `createListing` with a signature.
      */
     prepareListing({ offerer, listingItem, considerationItem, orderExpiry, }: PrepareListingParams): Promise<PrepareListingResponse>;
     /**
      * Create an order
-     * @param {CreateOrderParams} createOrderParams - create an order with the given params.
-     * @return {OrderResult} The result of the order created in the Immutable services.
+     * @param {CreateListingParams} createListingParams - create an order with the given params.
+     * @return {ListingResult} The result of the order created in the Immutable services.
      */
-    createOrder(createOrderParams: CreateOrderParams): Promise<OrderResult>;
+    createListing(createListingParams: CreateListingParams): Promise<ListingResult>;
     /**
      * Get unsigned transactions that can be submitted to fulfil an open order. If the approval
      * transaction exists it must be signed and submitted to the chain before the fulfilment
      * transaction can be submitted or it will be reverted.
-     * @param {string} orderId - The orderId to fulfil.
+     * @param {string} listingId - The listingId to fulfil.
      * @param {string} fulfillerAddress - The address of the account fulfilling the order.
-     * @return {FulfilOrderResponse} Approval and fulfilment transactions.
+     * @return {FulfillOrderResponse} Approval and fulfilment transactions.
      */
-    fulfillOrder(orderId: string, fulfillerAddress: string): Promise<FulfilOrderResponse>;
+    fulfillOrder(listingId: string, fulfillerAddress: string): Promise<FulfillOrderResponse>;
     /**
      * Get an unsigned cancel order transaction. Orders can only be cancelled by
      * the account that created them.
-     * @param {string} orderId - The orderId to cancel.
+     * @param {string} listingId - The listingId to cancel.
      * @param {string} accountAddress - The address of the account cancelling the order.
      * @return {CancelOrderResponse} The unsigned cancel order transaction
      */
-    cancelOrder(orderId: string, accountAddress: string): Promise<CancelOrderResponse>;
+    cancelOrder(listingId: string, accountAddress: string): Promise<CancelOrderResponse>;
 }
 
 declare const module = "orderbook";

package/dist/orderbook.js

@@ -387,27 +387,108 @@ class AxiosHttpRequest extends BaseHttpRequest {
     }
 }
 
+class ListingsService {
+    httpRequest;
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * List all listings
+     * List all listings
+     * @returns ListListingsResult OK response.
+     * @throws ApiError
+     */
+    listListings({ chainName, status, sellItemContractAddress, buyItemContractAddress, sellItemTokenId, pageSize, sortBy, sortDirection, pageCursor, }) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/v1/chains/{chain_name}/orders/listings',
+            path: {
+                'chain_name': chainName,
+            },
+            query: {
+                'status': status,
+                'sell_item_contract_address': sellItemContractAddress,
+                'buy_item_contract_address': buyItemContractAddress,
+                'sell_item_token_id': sellItemTokenId,
+                'page_size': pageSize,
+                'sort_by': sortBy,
+                'sort_direction': sortDirection,
+                'page_cursor': pageCursor,
+            },
+            errors: {
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
+            },
+        });
+    }
+    /**
+     * Create a listing
+     * Create a listing
+     * @returns ListingResult Created response.
+     * @throws ApiError
+     */
+    createListing({ chainName, requestBody, }) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/v1/chains/{chain_name}/orders/listings',
+            path: {
+                'chain_name': chainName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
+            },
+        });
+    }
+    /**
+     * Get a single listing by ID
+     * Get a single listing by ID
+     * @returns ListingResult OK response.
+     * @throws ApiError
+     */
+    getListing({ chainName, listingId, }) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/v1/chains/{chain_name}/orders/listings/{listing_id}',
+            path: {
+                'chain_name': chainName,
+                'listing_id': listingId,
+            },
+            errors: {
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
+            },
+        });
+    }
+}
+
 class OrdersService {
     httpRequest;
     constructor(httpRequest) {
         this.httpRequest = httpRequest;
     }
     /**
-     * List all orders
-     * List all orders
-     * @returns ListOrdersResult OK response.
+     * List all listings
+     * List all listings
+     * @returns ListListingsResult OK response.
      * @throws ApiError
      */
-    listOrders({ chainId, status, sellItemContractAddress, sellItemTokenId, pageSize, sortBy, sortDirection, pageCursor, }) {
+    listListings({ chainName, status, sellItemContractAddress, buyItemContractAddress, sellItemTokenId, pageSize, sortBy, sortDirection, pageCursor, }) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/v1/chains/{chain_id}/orders',
+            url: '/v1/chains/{chain_name}/orders/listings',
             path: {
-                'chain_id': chainId,
+                'chain_name': chainName,
             },
             query: {
                 'status': status,
                 'sell_item_contract_address': sellItemContractAddress,
+                'buy_item_contract_address': buyItemContractAddress,
                 'sell_item_token_id': sellItemTokenId,
                 'page_size': pageSize,
                 'sort_by': sortBy,
@@ -415,58 +496,59 @@ class OrdersService {
                 'page_cursor': pageCursor,
             },
             errors: {
-                400: `Client error`,
-                404: `The specified resource was not found`,
-                500: `Internal server error`,
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
             },
         });
     }
     /**
-     * Create an order
-     * Create an order
-     * @returns OrderResult Created response.
+     * Create a listing
+     * Create a listing
+     * @returns ListingResult Created response.
      * @throws ApiError
      */
-    createOrder({ chainId, requestBody, }) {
+    createListing({ chainName, requestBody, }) {
         return this.httpRequest.request({
             method: 'POST',
-            url: '/v1/chains/{chain_id}/orders',
+            url: '/v1/chains/{chain_name}/orders/listings',
             path: {
-                'chain_id': chainId,
+                'chain_name': chainName,
             },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
-                400: `Client error`,
-                404: `The specified resource was not found`,
-                500: `Internal server error`,
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
             },
         });
     }
     /**
-     * Get a single order by ID
-     * Get a single order by ID
-     * @returns OrderResult OK response.
+     * Get a single listing by ID
+     * Get a single listing by ID
+     * @returns ListingResult OK response.
      * @throws ApiError
      */
-    getOrder({ chainId, orderId, }) {
+    getListing({ chainName, listingId, }) {
         return this.httpRequest.request({
             method: 'GET',
-            url: '/v1/chains/{chain_id}/orders/{order_id}',
+            url: '/v1/chains/{chain_name}/orders/listings/{listing_id}',
             path: {
-                'chain_id': chainId,
-                'order_id': orderId,
+                'chain_name': chainName,
+                'listing_id': listingId,
             },
             errors: {
-                400: `Client error`,
-                404: `The specified resource was not found`,
-                500: `Internal server error`,
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
             },
         });
     }
 }
 
 class OrderBookClient {
+    listings;
     orders;
     request;
     constructor(config, HttpRequest = AxiosHttpRequest) {
@@ -481,21 +563,11 @@ class OrderBookClient {
             HEADERS: config?.HEADERS,
             ENCODE_PATH: config?.ENCODE_PATH,
         });
+        this.listings = new ListingsService(this.request);
         this.orders = new OrdersService(this.request);
     }
 }
 
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var BuyItem;
-(function (BuyItem) {
-    (function (item_type) {
-        item_type["NATIVE"] = "NATIVE";
-        item_type["ERC20"] = "ERC20";
-    })(BuyItem.item_type || (BuyItem.item_type = {}));
-})(BuyItem || (BuyItem = {}));
-
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
@@ -532,20 +604,10 @@ var OrderStatus;
     OrderStatus["EXPIRED"] = "EXPIRED";
 })(OrderStatus || (OrderStatus = {}));
 
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-var SellItem;
-(function (SellItem) {
-    (function (item_type) {
-        item_type["ERC721"] = "ERC721";
-    })(SellItem.item_type || (SellItem.item_type = {}));
-})(SellItem || (SellItem = {}));
-
 /* eslint-disable */
 // TODO: Resolve these from seaport-js.
 // There is some bundling issue that is preventing this from working
-const SEAPORT_CONTRACT_NAME = 'Seaport';
+const SEAPORT_CONTRACT_NAME = 'ImmutableSeaport';
 const SEAPORT_CONTRACT_VERSION_V1_4 = '1.4';
 const EIP_712_ORDER_TYPE = {
     OrderComponents: [
@@ -626,32 +688,60 @@ async function prepareTransaction(transactionMethods) {
 }
 
 function mapImmutableOrderToSeaportOrderComponents(order, counter, zoneAddress) {
-    const considerationItems = order.buy.map((buyItem) => ({
-        startAmount: buyItem.start_amount,
-        endAmount: buyItem.start_amount,
-        itemType: buyItem.item_type === 'ERC20' ? ItemType.ERC20 : ItemType.NATIVE,
-        recipient: order.account_address,
-        token: buyItem.contract_address || constants.AddressZero,
-        identifierOrCriteria: '0',
-    }));
+    const considerationItems = order.buy.map((buyItem) => {
+        switch (buyItem.item_type) {
+            case 'NATIVE':
+                return {
+                    startAmount: buyItem.start_amount,
+                    endAmount: buyItem.start_amount,
+                    itemType: ItemType.NATIVE,
+                    recipient: order.account_address,
+                    token: constants.AddressZero,
+                    identifierOrCriteria: '0',
+                };
+            case 'ERC20':
+                return {
+                    startAmount: buyItem.start_amount,
+                    endAmount: buyItem.start_amount,
+                    itemType: ItemType.ERC20,
+                    recipient: order.account_address,
+                    token: buyItem.contract_address || constants.AddressZero,
+                    identifierOrCriteria: '0',
+                };
+            default: // ERC721
+                return {
+                    startAmount: '1',
+                    endAmount: '1',
+                    itemType: ItemType.ERC721,
+                    recipient: order.account_address,
+                    token: buyItem.contract_address || constants.AddressZero,
+                    identifierOrCriteria: '0',
+                };
+        }
+    });
     const fees = order.buy_fees.map((fee) => ({
         startAmount: fee.amount,
         endAmount: fee.amount,
         itemType: order.buy[0].item_type === 'ERC20' ? ItemType.ERC20 : ItemType.NATIVE,
         recipient: fee.recipient,
-        token: order.buy[0].contract_address || constants.AddressZero,
+        token: order.buy[0].item_type === 'ERC20'
+            ? order.buy[0].contract_address
+            : constants.AddressZero,
         identifierOrCriteria: '0',
     }));
     return {
         conduitKey: constants.HashZero,
         consideration: [...considerationItems, ...fees],
-        offer: order.sell.map((sellItem) => ({
-            startAmount: '1',
-            endAmount: '1',
-            itemType: ItemType.ERC721,
-            token: sellItem.contract_address,
-            identifierOrCriteria: sellItem.token_id,
-        })),
+        offer: order.sell.map((sellItem) => {
+            const erc721Item = sellItem;
+            return {
+                startAmount: '1',
+                endAmount: '1',
+                itemType: ItemType.ERC721,
+                token: erc721Item.contract_address,
+                identifierOrCriteria: erc721Item.token_id,
+            };
+        }),
         counter,
         endTime: Math.round(new Date(order.end_time).getTime() / 1000).toString(),
         startTime: Math.round(new Date(order.start_time).getTime() / 1000).toString(),
@@ -803,43 +893,53 @@ class SeaportFactory {
 
 class ImmutableApiClient {
     orderbookService;
-    chainId;
-    constructor(orderbookService, chainId) {
+    chainName;
+    seaportAddress;
+    constructor(orderbookService, chainName, seaportAddress) {
         this.orderbookService = orderbookService;
-        this.chainId = chainId;
+        this.chainName = chainName;
+        this.seaportAddress = seaportAddress;
     }
-    async getOrder(orderId) {
-        return this.orderbookService.getOrder({ chainId: this.chainId, orderId });
+    async getListing(listingId) {
+        return this.orderbookService.getListing({
+            chainName: this.chainName,
+            listingId,
+        });
     }
-    async listOrders(listOrderParams) {
-        return this.orderbookService.listOrders({
-            chainId: this.chainId,
+    async listListings(listOrderParams) {
+        return this.orderbookService.listListings({
+            chainName: this.chainName,
             ...listOrderParams,
         });
     }
-    async createOrder({ orderHash, orderComponents, offerer, orderSignature, }) {
+    async createListing({ orderHash, orderComponents, offerer, orderSignature, }) {
         if (orderComponents.offer.length !== 1) {
             throw new Error('Only one item can be listed at a time');
         }
         if (Number(orderComponents.offer[0].itemType) !== ItemType.ERC721) {
             throw new Error('Only ERC721 tokens can be listed');
         }
-        const considerationItemTypeTheSame = new Set([...orderComponents.consideration.map((c) => c.itemType)]).size === 1;
-        if (!considerationItemTypeTheSame) {
+        const orderTypes = [
+            ...orderComponents.consideration.map((c) => c.itemType),
+        ];
+        const isSameConsiderationType = new Set(orderTypes).size === 1;
+        if (!isSameConsiderationType) {
             throw new Error('All consideration items must be of the same type');
         }
-        return this.orderbookService.createOrder({
-            chainId: this.chainId,
+        return this.orderbookService.createListing({
+            chainName: this.chainName,
             requestBody: {
                 order_hash: orderHash,
                 account_address: offerer,
                 buy: [
                     {
-                        item_type: Number(orderComponents.consideration[0].itemType) === ItemType.NATIVE
-                            ? BuyItem.item_type.NATIVE
-                            : BuyItem.item_type.ERC20,
+                        item_type: Number(orderComponents.consideration[0].itemType)
+                            === ItemType.NATIVE
+                            ? 'NATIVE'
+                            : 'ERC20',
                         start_amount: orderComponents.consideration[0].startAmount,
-                    }
+                        contract_address: orderComponents.consideration[0].token,
+                    },
                 ],
                 buy_fees: orderComponents.consideration.length > 1
                     ? [
@@ -854,13 +954,18 @@ class ImmutableApiClient {
                 protocol_data: {
                     order_type: CreateOrderProtocolData.order_type.FULL_RESTRICTED,
                     zone_address: orderComponents.zone,
+                    seaport_address: this.seaportAddress,
+                    seaport_version: SEAPORT_CONTRACT_VERSION_V1_4,
+                    counter: orderComponents.counter.toString(),
                 },
                 salt: orderComponents.salt,
-                sell: [{
+                sell: [
+                    {
                         contract_address: orderComponents.offer[0].token,
                         token_id: orderComponents.offer[0].identifierOrCriteria,
-                        item_type: SellItem.item_type.ERC721,
-                    }],
+                        item_type: 'ERC721',
+                    },
+                ],
                 signature: orderSignature,
                 start_time: new Date(parseInt(`${orderComponents.startTime.toString()}000`, 10)).toISOString(),
             },
@@ -869,17 +974,19 @@ class ImmutableApiClient {
 }
 
 class ImmutableApiClientFactory {
-    chainId;
+    chainName;
+    seaportAddress;
     orderbookClient;
-    constructor(apiEndpoint, chainId) {
-        this.chainId = chainId;
+    constructor(apiEndpoint, chainName, seaportAddress) {
+        this.chainName = chainName;
+        this.seaportAddress = seaportAddress;
         this.orderbookClient = new OrderBookClient({
             // eslint-disable-next-line @typescript-eslint/naming-convention
             BASE: apiEndpoint,
         });
     }
     create() {
-        return new ImmutableApiClient(this.orderbookClient.orders, this.chainId);
+        return new ImmutableApiClient(this.orderbookClient.orders, this.chainName, this.seaportAddress);
     }
 }
 
@@ -1822,20 +1929,20 @@ class Orderbook {
             throw new Error('API endpoint must be provided as an override');
         }
         // TODO: Move chainId lookup to a map based on env. Just using override to get dev started
-        const chainId = config.overrides?.chainId;
-        if (!chainId) {
-            throw new Error('ChainID must be provided as an override');
+        const chainName = config.overrides?.chainName;
+        if (!chainName) {
+            throw new Error('chainName must be provided as an override');
         }
-        this.apiClient = new ImmutableApiClientFactory(apiEndpoint, chainId).create();
+        this.apiClient = new ImmutableApiClientFactory(apiEndpoint, chainName, this.config.seaportContractAddress).create();
         this.seaport = new SeaportFactory(this.config.seaportContractAddress, this.config.zoneContractAddress, this.config.provider).create();
     }
     /**
      * Get an order by ID
-     * @param {string} orderId - The orderId to find.
-     * @return {OrderResult} The returned order result.
+     * @param {string} listingId - The listingId to find.
+     * @return {ListingResult} The returned order result.
      */
-    getOrder(orderId) {
-        return this.apiClient.getOrder(orderId);
+    getListing(listingId) {
+        return this.apiClient.getListing(listingId);
     }
     /**
      * List orders. This method is used to get a list of orders filtered by conditions specified
@@ -1843,16 +1950,16 @@ class Orderbook {
      * @param {ListOrderParams} listOrderParams - Filtering, ordering and page parameters.
      * @return {Orders} The paged orders.
      */
-    listOrders(listOrderParams) {
-        return this.apiClient.listOrders(listOrderParams);
+    listListings(listOrderParams) {
+        return this.apiClient.listListings(listOrderParams);
     }
     /**
      * Get required transactions and messages for signing prior to creating a listing
-     * through the createOrder method
+     * through the createListing method
      * @param {PrepareListingParams} prepareListingParams - Details about the listing to be created.
      * @return {PrepareListingResponse} PrepareListingResponse includes
      * the unsigned approval transaction, the typed order message for signing and
-     * the order components that can be submitted to `createOrder` with a signature.
+     * the order components that can be submitted to `createListing` with a signature.
      */
     async prepareListing({ offerer, listingItem, considerationItem, orderExpiry, }) {
         const erc721 = new ERC721Factory(listingItem.contractAddress, this.config.provider).create();
@@ -1865,22 +1972,22 @@ class Orderbook {
     }
     /**
      * Create an order
-     * @param {CreateOrderParams} createOrderParams - create an order with the given params.
-     * @return {OrderResult} The result of the order created in the Immutable services.
+     * @param {CreateListingParams} createListingParams - create an order with the given params.
+     * @return {ListingResult} The result of the order created in the Immutable services.
      */
-    createOrder(createOrderParams) {
-        return this.apiClient.createOrder(createOrderParams);
+    createListing(createListingParams) {
+        return this.apiClient.createListing(createListingParams);
     }
     /**
      * Get unsigned transactions that can be submitted to fulfil an open order. If the approval
      * transaction exists it must be signed and submitted to the chain before the fulfilment
      * transaction can be submitted or it will be reverted.
-     * @param {string} orderId - The orderId to fulfil.
+     * @param {string} listingId - The listingId to fulfil.
      * @param {string} fulfillerAddress - The address of the account fulfilling the order.
-     * @return {FulfilOrderResponse} Approval and fulfilment transactions.
+     * @return {FulfillOrderResponse} Approval and fulfilment transactions.
      */
-    async fulfillOrder(orderId, fulfillerAddress) {
-        const orderResult = await this.apiClient.getOrder(orderId);
+    async fulfillOrder(listingId, fulfillerAddress) {
+        const orderResult = await this.apiClient.getListing(listingId);
         if (orderResult.result.status !== OrderStatus.ACTIVE) {
             throw new Error(`Cannot fulfil order that is not active. Current status: ${orderResult.result.status}`);
         }
@@ -1889,19 +1996,19 @@ class Orderbook {
     /**
      * Get an unsigned cancel order transaction. Orders can only be cancelled by
      * the account that created them.
-     * @param {string} orderId - The orderId to cancel.
+     * @param {string} listingId - The listingId to cancel.
      * @param {string} accountAddress - The address of the account cancelling the order.
      * @return {CancelOrderResponse} The unsigned cancel order transaction
      */
-    async cancelOrder(orderId, accountAddress) {
-        const orderResult = await this.apiClient.getOrder(orderId);
+    async cancelOrder(listingId, accountAddress) {
+        const orderResult = await this.apiClient.getListing(listingId);
         if (orderResult.result.status !== OrderStatus.ACTIVE
             && orderResult.result.status !== OrderStatus.INACTIVE
             && orderResult.result.status !== OrderStatus.PENDING) {
             throw new Error(`Cannot cancel order with status ${orderResult.result.status}`);
         }
         if (orderResult.result.account_address !== accountAddress.toLowerCase()) {
-            throw new Error(`Only account ${orderResult.result.account_address} can cancel order ${orderId}`);
+            throw new Error(`Only account ${orderResult.result.account_address} can cancel order ${listingId}`);
         }
         const cancelOrderTransaction = await this.seaport.cancelOrder(orderResult.result, accountAddress);
         return { unsignedCancelOrderTransaction: cancelOrderTransaction };

package/dist/passport.d.ts

@@ -10491,12 +10491,12 @@ interface PassportModuleConfiguration extends ModuleConfiguration<PassportOverri
 
 declare class Passport {
     private readonly authManager;
-    private readonly magicAdapter;
     private readonly config;
-    private readonly immutableXClient;
     private readonly confirmationScreen;
+    private readonly immutableXClient;
+    private readonly magicAdapter;
+    private readonly passportImxProviderFactory;
     constructor(passportModuleConfiguration: PassportModuleConfiguration);
-    private getImxProvider;
     connectImxSilent(): Promise<IMXProvider | null>;
     connectImx(): Promise<IMXProvider>;
     loginCallback(): Promise<void>;
@@ -10504,7 +10504,6 @@ declare class Passport {
     getUserInfo(): Promise<UserProfile | undefined>;
     getIdToken(): Promise<string | undefined>;
     getAccessToken(): Promise<string | undefined>;
-    private registerUser;
 }
 
 export { Passport, PassportError, PassportModuleConfiguration };