@0xsequence/marketplace-sdk 0.8.10 → 0.8.11

package/src/react/_internal/api/marketplace.gen.ts

@@ -5,18 +5,19 @@
 //
 // webrpc-gen -schema=marketplace.ridl -target=typescript -client -out=./clients/marketplace.gen.ts
 
-export const WebrpcHeader = "Webrpc"
+export const WebrpcHeader = "Webrpc";
 
-export const WebrpcHeaderValue = "webrpc@v0.25.1;gen-typescript@v0.17.0;marketplace-api@v0.0.0-27c5a642f4eb523c04af2f1a45e4a2ab1f370fcd"
+export const WebrpcHeaderValue =
+  "webrpc@v0.25.1;gen-typescript@v0.17.0;marketplace-api@v0.0.0-27c5a642f4eb523c04af2f1a45e4a2ab1f370fcd";
 
 // WebRPC description and code-gen version
-export const WebRPCVersion = "v1"
+export const WebRPCVersion = "v1";
 
 // Schema version of your RIDL schema
-export const WebRPCSchemaVersion = ""
+export const WebRPCSchemaVersion = "";
 
 // Schema hash generated from your RIDL schema
-export const WebRPCSchemaHash = "27c5a642f4eb523c04af2f1a45e4a2ab1f370fcd"
+export const WebRPCSchemaHash = "27c5a642f4eb523c04af2f1a45e4a2ab1f370fcd";
 
 type WebrpcGenVersions = {
   webrpcGenVersion: string;
@@ -70,1728 +71,2391 @@ function parseWebrpcGenVersions(header: string): WebrpcGenVersions {
 // Types
 //
 
-
 export interface TokenMetadata {
-  tokenId: string
-  name: string
-  description?: string
-  image?: string
-  video?: string
-  audio?: string
-  properties?: {[key: string]: any}
-  attributes: Array<{[key: string]: any}>
-  image_data?: string
-  external_url?: string
-  background_color?: string
-  animation_url?: string
-  decimals?: number
-  updatedAt?: string
-  assets?: Array<Asset>
+  tokenId: string;
+  name: string;
+  description?: string;
+  image?: string;
+  video?: string;
+  audio?: string;
+  properties?: { [key: string]: any };
+  attributes: Array<{ [key: string]: any }>;
+  image_data?: string;
+  external_url?: string;
+  background_color?: string;
+  animation_url?: string;
+  decimals?: number;
+  updatedAt?: string;
+  assets?: Array<Asset>;
 }
 
 export interface Asset {
-  id: number
-  collectionId: number
-  tokenId: string
-  url?: string
-  metadataField: string
-  name?: string
-  filesize?: number
-  mimeType?: string
-  width?: number
-  height?: number
-  updatedAt?: string
+  id: number;
+  collectionId: number;
+  tokenId: string;
+  url?: string;
+  metadataField: string;
+  name?: string;
+  filesize?: number;
+  mimeType?: string;
+  width?: number;
+  height?: number;
+  updatedAt?: string;
 }
 
 export enum SortOrder {
-  DESC = 'DESC',
-  ASC = 'ASC'
+  DESC = "DESC",
+  ASC = "ASC",
 }
 
 export enum PropertyType {
-  INT = 'INT',
-  STRING = 'STRING',
-  ARRAY = 'ARRAY',
-  GENERIC = 'GENERIC'
+  INT = "INT",
+  STRING = "STRING",
+  ARRAY = "ARRAY",
+  GENERIC = "GENERIC",
 }
 
 export enum MarketplaceKind {
-  unknown = 'unknown',
-  sequence_marketplace_v1 = 'sequence_marketplace_v1',
-  sequence_marketplace_v2 = 'sequence_marketplace_v2',
-  blur = 'blur',
-  zerox = 'zerox',
-  opensea = 'opensea',
-  looks_rare = 'looks_rare',
-  x2y2 = 'x2y2',
-  alienswap = 'alienswap',
-  payment_processor = 'payment_processor',
-  mintify = 'mintify',
-  magic_eden = 'magic_eden'
+  unknown = "unknown",
+  sequence_marketplace_v1 = "sequence_marketplace_v1",
+  sequence_marketplace_v2 = "sequence_marketplace_v2",
+  blur = "blur",
+  zerox = "zerox",
+  opensea = "opensea",
+  looks_rare = "looks_rare",
+  x2y2 = "x2y2",
+  alienswap = "alienswap",
+  payment_processor = "payment_processor",
+  mintify = "mintify",
+  magic_eden = "magic_eden",
 }
 
 export enum OrderbookKind {
-  unknown = 'unknown',
-  sequence_marketplace_v1 = 'sequence_marketplace_v1',
-  sequence_marketplace_v2 = 'sequence_marketplace_v2',
-  blur = 'blur',
-  opensea = 'opensea',
-  looks_rare = 'looks_rare',
-  reservoir = 'reservoir',
-  x2y2 = 'x2y2'
+  unknown = "unknown",
+  sequence_marketplace_v1 = "sequence_marketplace_v1",
+  sequence_marketplace_v2 = "sequence_marketplace_v2",
+  blur = "blur",
+  opensea = "opensea",
+  looks_rare = "looks_rare",
+  reservoir = "reservoir",
+  x2y2 = "x2y2",
 }
 
 export enum SourceKind {
-  unknown = 'unknown',
-  external = 'external',
-  sequence_marketplace_v1 = 'sequence_marketplace_v1',
-  sequence_marketplace_v2 = 'sequence_marketplace_v2'
+  unknown = "unknown",
+  external = "external",
+  sequence_marketplace_v1 = "sequence_marketplace_v1",
+  sequence_marketplace_v2 = "sequence_marketplace_v2",
 }
 
 export enum OrderSide {
-  unknown = 'unknown',
-  listing = 'listing',
-  offer = 'offer'
+  unknown = "unknown",
+  listing = "listing",
+  offer = "offer",
 }
 
 export enum OrderStatus {
-  unknown = 'unknown',
-  active = 'active',
-  inactive = 'inactive',
-  expired = 'expired',
-  cancelled = 'cancelled',
-  filled = 'filled',
-  decimals_missing = 'decimals_missing'
+  unknown = "unknown",
+  active = "active",
+  inactive = "inactive",
+  expired = "expired",
+  cancelled = "cancelled",
+  filled = "filled",
+  decimals_missing = "decimals_missing",
 }
 
 export enum ContractType {
-  UNKNOWN = 'UNKNOWN',
-  ERC20 = 'ERC20',
-  ERC721 = 'ERC721',
-  ERC1155 = 'ERC1155'
+  UNKNOWN = "UNKNOWN",
+  ERC20 = "ERC20",
+  ERC721 = "ERC721",
+  ERC1155 = "ERC1155",
+  LAOSERC721 = "LAOSERC721", //TODO: This needs to be validated with the new builder return
 }
 
 export enum CollectionPriority {
-  unknown = 'unknown',
-  low = 'low',
-  normal = 'normal',
-  high = 'high'
+  unknown = "unknown",
+  low = "low",
+  normal = "normal",
+  high = "high",
 }
 
 export enum CollectionStatus {
-  unknown = 'unknown',
-  created = 'created',
-  syncing_contract_metadata = 'syncing_contract_metadata',
-  synced_contract_metadata = 'synced_contract_metadata',
-  syncing_metadata = 'syncing_metadata',
-  synced_metadata = 'synced_metadata',
-  syncing_tokens = 'syncing_tokens',
-  synced_tokens = 'synced_tokens',
-  syncing_orders = 'syncing_orders',
-  active = 'active',
-  failed = 'failed',
-  inactive = 'inactive',
-  incompatible_type = 'incompatible_type'
+  unknown = "unknown",
+  created = "created",
+  syncing_contract_metadata = "syncing_contract_metadata",
+  synced_contract_metadata = "synced_contract_metadata",
+  syncing_metadata = "syncing_metadata",
+  synced_metadata = "synced_metadata",
+  syncing_tokens = "syncing_tokens",
+  synced_tokens = "synced_tokens",
+  syncing_orders = "syncing_orders",
+  active = "active",
+  failed = "failed",
+  inactive = "inactive",
+  incompatible_type = "incompatible_type",
 }
 
 export enum ProjectStatus {
-  unknown = 'unknown',
-  active = 'active',
-  inactive = 'inactive'
+  unknown = "unknown",
+  active = "active",
+  inactive = "inactive",
 }
 
 export enum CollectibleStatus {
-  unknown = 'unknown',
-  active = 'active',
-  inactive = 'inactive'
+  unknown = "unknown",
+  active = "active",
+  inactive = "inactive",
 }
 
 export enum CurrencyStatus {
-  unknown = 'unknown',
-  created = 'created',
-  syncing_metadata = 'syncing_metadata',
-  active = 'active',
-  failed = 'failed'
+  unknown = "unknown",
+  created = "created",
+  syncing_metadata = "syncing_metadata",
+  active = "active",
+  failed = "failed",
 }
 
 export enum WalletKind {
-  unknown = 'unknown',
-  sequence = 'sequence'
+  unknown = "unknown",
+  sequence = "sequence",
 }
 
 export enum StepType {
-  unknown = 'unknown',
-  tokenApproval = 'tokenApproval',
-  buy = 'buy',
-  sell = 'sell',
-  createListing = 'createListing',
-  createOffer = 'createOffer',
-  signEIP712 = 'signEIP712',
-  signEIP191 = 'signEIP191',
-  cancel = 'cancel'
+  unknown = "unknown",
+  tokenApproval = "tokenApproval",
+  buy = "buy",
+  sell = "sell",
+  createListing = "createListing",
+  createOffer = "createOffer",
+  signEIP712 = "signEIP712",
+  signEIP191 = "signEIP191",
+  cancel = "cancel",
 }
 
 export enum TransactionCrypto {
-  none = 'none',
-  partially = 'partially',
-  all = 'all'
+  none = "none",
+  partially = "partially",
+  all = "all",
 }
 
 export enum TransactionNFTCheckoutProvider {
-  unknown = 'unknown',
-  sardine = 'sardine',
-  transak = 'transak'
+  unknown = "unknown",
+  sardine = "sardine",
+  transak = "transak",
 }
 
 export enum TransactionOnRampProvider {
-  unknown = 'unknown',
-  sardine = 'sardine',
-  transak = 'transak'
+  unknown = "unknown",
+  sardine = "sardine",
+  transak = "transak",
 }
 
 export enum TransactionSwapProvider {
-  unknown = 'unknown',
-  zerox = 'zerox'
+  unknown = "unknown",
+  zerox = "zerox",
 }
 
 export enum ExecuteType {
-  unknown = 'unknown',
-  order = 'order'
+  unknown = "unknown",
+  order = "order",
 }
 
 export enum ActivityAction {
-  unknown = 'unknown',
-  listing = 'listing',
-  offer = 'offer',
-  mint = 'mint',
-  sale = 'sale',
-  listingCancel = 'listingCancel',
-  offerCancel = 'offerCancel',
-  transfer = 'transfer'
+  unknown = "unknown",
+  listing = "listing",
+  offer = "offer",
+  mint = "mint",
+  sale = "sale",
+  listingCancel = "listingCancel",
+  offerCancel = "offerCancel",
+  transfer = "transfer",
 }
 
 export interface Page {
-  page: number
-  pageSize: number
-  more?: boolean
-  sort?: Array<SortBy>
+  page: number;
+  pageSize: number;
+  more?: boolean;
+  sort?: Array<SortBy>;
 }
 
 export interface SortBy {
-  column: string
-  order: SortOrder
+  column: string;
+  order: SortOrder;
 }
 
 export interface Filter {
-  text?: string
-  properties?: Array<PropertyFilter>
+  text?: string;
+  properties?: Array<PropertyFilter>;
 }
 
 export interface PropertyFilter {
-  name: string
-  type: PropertyType
-  min?: number
-  max?: number
-  values?: Array<any>
+  name: string;
+  type: PropertyType;
+  min?: number;
+  max?: number;
+  values?: Array<any>;
 }
 
 export interface CollectiblesFilter {
-  includeEmpty: boolean
-  searchText?: string
-  properties?: Array<PropertyFilter>
-  marketplaces?: Array<MarketplaceKind>
-  inAccounts?: Array<string>
-  notInAccounts?: Array<string>
-  ordersCreatedBy?: Array<string>
-  ordersNotCreatedBy?: Array<string>
-  inCurrencyAddresses?: Array<string>
-  notInCurrencyAddresses?: Array<string>
+  includeEmpty: boolean;
+  searchText?: string;
+  properties?: Array<PropertyFilter>;
+  marketplaces?: Array<MarketplaceKind>;
+  inAccounts?: Array<string>;
+  notInAccounts?: Array<string>;
+  ordersCreatedBy?: Array<string>;
+  ordersNotCreatedBy?: Array<string>;
+  inCurrencyAddresses?: Array<string>;
+  notInCurrencyAddresses?: Array<string>;
 }
 
 export interface Order {
-  orderId: string
-  marketplace: MarketplaceKind
-  side: OrderSide
-  status: OrderStatus
-  chainId: number
-  originName: string
-  collectionContractAddress: string
-  tokenId?: string
-  createdBy: string
-  priceAmount: string
-  priceAmountFormatted: string
-  priceAmountNet: string
-  priceAmountNetFormatted: string
-  priceCurrencyAddress: string
-  priceDecimals: number
-  priceUSD: number
-  priceUSDFormatted: string
-  quantityInitial: string
-  quantityInitialFormatted: string
-  quantityRemaining: string
-  quantityRemainingFormatted: string
-  quantityAvailable: string
-  quantityAvailableFormatted: string
-  quantityDecimals: number
-  feeBps: number
-  feeBreakdown: Array<FeeBreakdown>
-  validFrom: string
-  validUntil: string
-  blockNumber: number
-  orderCreatedAt?: string
-  orderUpdatedAt?: string
-  createdAt: string
-  updatedAt: string
-  deletedAt?: string
+  orderId: string;
+  marketplace: MarketplaceKind;
+  side: OrderSide;
+  status: OrderStatus;
+  chainId: number;
+  originName: string;
+  collectionContractAddress: string;
+  tokenId?: string;
+  createdBy: string;
+  priceAmount: string;
+  priceAmountFormatted: string;
+  priceAmountNet: string;
+  priceAmountNetFormatted: string;
+  priceCurrencyAddress: string;
+  priceDecimals: number;
+  priceUSD: number;
+  priceUSDFormatted: string;
+  quantityInitial: string;
+  quantityInitialFormatted: string;
+  quantityRemaining: string;
+  quantityRemainingFormatted: string;
+  quantityAvailable: string;
+  quantityAvailableFormatted: string;
+  quantityDecimals: number;
+  feeBps: number;
+  feeBreakdown: Array<FeeBreakdown>;
+  validFrom: string;
+  validUntil: string;
+  blockNumber: number;
+  orderCreatedAt?: string;
+  orderUpdatedAt?: string;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string;
 }
 
 export interface FeeBreakdown {
-  kind: string
-  recipientAddress: string
-  bps: number
+  kind: string;
+  recipientAddress: string;
+  bps: number;
 }
 
 export interface CollectibleOrder {
-  metadata: TokenMetadata
-  order?: Order
-  listing?: Order
-  offer?: Order
+  metadata: TokenMetadata;
+  order?: Order;
+  listing?: Order;
+  offer?: Order;
 }
 
 export interface OrderFilter {
-  createdBy?: Array<string>
-  marketplace?: Array<MarketplaceKind>
-  currencies?: Array<string>
+  createdBy?: Array<string>;
+  marketplace?: Array<MarketplaceKind>;
+  currencies?: Array<string>;
 }
 
 export interface Collection {
-  status: CollectionStatus
-  chainId: number
-  contractAddress: string
-  contractType: ContractType
-  priority: CollectionPriority
-  tokenQuantityDecimals: number
-  config: CollectionConfig
-  createdAt: string
-  updatedAt: string
-  deletedAt?: string
+  status: CollectionStatus;
+  chainId: number;
+  contractAddress: string;
+  contractType: ContractType;
+  priority: CollectionPriority;
+  tokenQuantityDecimals: number;
+  config: CollectionConfig;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string;
 }
 
 export interface CollectionConfig {
-  lastSynced: {[key: string]: CollectionLastSynced}
-  collectiblesSynced: string
-  activitiesSynced: string
-  activitiesSyncedContinuity: string
+  lastSynced: { [key: string]: CollectionLastSynced };
+  collectiblesSynced: string;
+  activitiesSynced: string;
+  activitiesSyncedContinuity: string;
 }
 
 export interface CollectionLastSynced {
-  allOrders: string
-  newOrders: string
+  allOrders: string;
+  newOrders: string;
 }
 
 export interface Project {
-  projectId: number
-  chainId: number
-  contractAddress: string
-  status: ProjectStatus
-  createdAt: string
-  updatedAt: string
-  deletedAt?: string
+  projectId: number;
+  chainId: number;
+  contractAddress: string;
+  status: ProjectStatus;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string;
 }
 
 export interface Collectible {
-  chainId: number
-  contractAddress: string
-  status: CollectibleStatus
-  tokenId: string
-  decimals: number
-  createdAt: string
-  updatedAt: string
-  deletedAt?: string
+  chainId: number;
+  contractAddress: string;
+  status: CollectibleStatus;
+  tokenId: string;
+  decimals: number;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string;
 }
 
 export interface Currency {
-  chainId: number
-  contractAddress: string
-  status: CurrencyStatus
-  name: string
-  symbol: string
-  decimals: number
-  imageUrl: string
-  exchangeRate: number
-  defaultChainCurrency: boolean
-  nativeCurrency: boolean
-  createdAt: string
-  updatedAt: string
-  deletedAt?: string
+  chainId: number;
+  contractAddress: string;
+  status: CurrencyStatus;
+  name: string;
+  symbol: string;
+  decimals: number;
+  imageUrl: string;
+  exchangeRate: number;
+  defaultChainCurrency: boolean;
+  nativeCurrency: boolean;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string;
 }
 
 export interface OrderData {
-  orderId: string
-  quantity: string
-  tokenId?: string
+  orderId: string;
+  quantity: string;
+  tokenId?: string;
 }
 
 export interface AdditionalFee {
-  amount: string
-  receiver: string
+  amount: string;
+  receiver: string;
 }
 
 export interface Step {
-  id: StepType
-  data: string
-  to: string
-  value: string
-  price: string
-  signature?: Signature
-  post?: PostRequest
-  executeType?: ExecuteType
+  id: StepType;
+  data: string;
+  to: string;
+  value: string;
+  price: string;
+  signature?: Signature;
+  post?: PostRequest;
+  executeType?: ExecuteType;
 }
 
 export interface PostRequest {
-  endpoint: string
-  method: string
-  body: any
+  endpoint: string;
+  method: string;
+  body: any;
 }
 
 export interface CreateReq {
-  tokenId: string
-  quantity: string
-  expiry: string
-  currencyAddress: string
-  pricePerToken: string
+  tokenId: string;
+  quantity: string;
+  expiry: string;
+  currencyAddress: string;
+  pricePerToken: string;
 }
 
 export interface GetOrdersInput {
-  contractAddress: string
-  orderId: string
-  marketplace: MarketplaceKind
+  contractAddress: string;
+  orderId: string;
+  marketplace: MarketplaceKind;
 }
 
 export interface Signature {
-  domain: Domain
-  types: any
-  primaryType: string
-  value: any
+  domain: Domain;
+  types: any;
+  primaryType: string;
+  value: any;
 }
 
 export interface Domain {
-  name: string
-  version: string
-  chainId: number
-  verifyingContract: string
+  name: string;
+  version: string;
+  chainId: number;
+  verifyingContract: string;
 }
 
 export interface CheckoutOptionsMarketplaceOrder {
-  contractAddress: string
-  orderId: string
-  marketplace: MarketplaceKind
+  contractAddress: string;
+  orderId: string;
+  marketplace: MarketplaceKind;
 }
 
 export interface CheckoutOptionsItem {
-  tokenId: string
-  quantity: string
+  tokenId: string;
+  quantity: string;
 }
 
 export interface CheckoutOptions {
-  crypto: TransactionCrypto
-  swap: Array<TransactionSwapProvider>
-  nftCheckout: Array<TransactionNFTCheckoutProvider>
-  onRamp: Array<TransactionOnRampProvider>
+  crypto: TransactionCrypto;
+  swap: Array<TransactionSwapProvider>;
+  nftCheckout: Array<TransactionNFTCheckoutProvider>;
+  onRamp: Array<TransactionOnRampProvider>;
 }
 
 export interface Activity {
-  chainId: number
-  contractAddress: string
-  tokenId: string
-  action: ActivityAction
-  txHash: string
-  from: string
-  to?: string
-  quantity: string
-  quantityDecimals: number
-  priceAmount?: string
-  priceAmountFormatted?: string
-  priceCurrencyAddress?: string
-  priceDecimals?: number
-  activityCreatedAt: string
-  uniqueHash: string
-  createdAt: string
-  updatedAt: string
-  deletedAt?: string
+  chainId: number;
+  contractAddress: string;
+  tokenId: string;
+  action: ActivityAction;
+  txHash: string;
+  from: string;
+  to?: string;
+  quantity: string;
+  quantityDecimals: number;
+  priceAmount?: string;
+  priceAmountFormatted?: string;
+  priceCurrencyAddress?: string;
+  priceDecimals?: number;
+  activityCreatedAt: string;
+  uniqueHash: string;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string;
 }
 
 export interface Admin {
-  createCollection(args: CreateCollectionArgs, headers?: object, signal?: AbortSignal): Promise<CreateCollectionReturn>
-  getCollection(args: GetCollectionArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectionReturn>
-  updateCollection(args: UpdateCollectionArgs, headers?: object, signal?: AbortSignal): Promise<UpdateCollectionReturn>
-  listCollections(args: ListCollectionsArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectionsReturn>
-  deleteCollection(args: DeleteCollectionArgs, headers?: object, signal?: AbortSignal): Promise<DeleteCollectionReturn>
+  createCollection(
+    args: CreateCollectionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<CreateCollectionReturn>;
+  getCollection(
+    args: GetCollectionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectionReturn>;
+  updateCollection(
+    args: UpdateCollectionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<UpdateCollectionReturn>;
+  listCollections(
+    args: ListCollectionsArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectionsReturn>;
+  deleteCollection(
+    args: DeleteCollectionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<DeleteCollectionReturn>;
   /**
    * determine what should happen here
    */
-  syncCollection(args: SyncCollectionArgs, headers?: object, signal?: AbortSignal): Promise<SyncCollectionReturn>
-  createCurrency(args: CreateCurrencyArgs, headers?: object, signal?: AbortSignal): Promise<CreateCurrencyReturn>
-  createCurrencies(args: CreateCurrenciesArgs, headers?: object, signal?: AbortSignal): Promise<CreateCurrenciesReturn>
-  updateCurrency(args: UpdateCurrencyArgs, headers?: object, signal?: AbortSignal): Promise<UpdateCurrencyReturn>
-  listCurrencies(headers?: object, signal?: AbortSignal): Promise<ListCurrenciesReturn>
-  deleteCurrency(args: DeleteCurrencyArgs, headers?: object, signal?: AbortSignal): Promise<DeleteCurrencyReturn>
+  syncCollection(
+    args: SyncCollectionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SyncCollectionReturn>;
+  createCurrency(
+    args: CreateCurrencyArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<CreateCurrencyReturn>;
+  createCurrencies(
+    args: CreateCurrenciesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<CreateCurrenciesReturn>;
+  updateCurrency(
+    args: UpdateCurrencyArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<UpdateCurrencyReturn>;
+  listCurrencies(
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCurrenciesReturn>;
+  deleteCurrency(
+    args: DeleteCurrencyArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<DeleteCurrencyReturn>;
 }
 
 export interface CreateCollectionArgs {
-  projectId: number
-  contractAddress: string
+  projectId: number;
+  contractAddress: string;
 }
 
 export interface CreateCollectionReturn {
-  collection: Collection  
+  collection: Collection;
 }
 export interface GetCollectionArgs {
-  projectId: number
-  contractAddress: string
+  projectId: number;
+  contractAddress: string;
 }
 
 export interface GetCollectionReturn {
-  collection: Collection  
+  collection: Collection;
 }
 export interface UpdateCollectionArgs {
-  collection: Collection
+  collection: Collection;
 }
 
 export interface UpdateCollectionReturn {
-  collection: Collection  
+  collection: Collection;
 }
 export interface ListCollectionsArgs {
-  projectId: number
-  page?: Page
+  projectId: number;
+  page?: Page;
 }
 
 export interface ListCollectionsReturn {
-  collections: Array<Collection>
-  page?: Page  
+  collections: Array<Collection>;
+  page?: Page;
 }
 export interface DeleteCollectionArgs {
-  projectId: number
-  contractAddress: string
+  projectId: number;
+  contractAddress: string;
 }
 
 export interface DeleteCollectionReturn {
-  collection: Collection  
+  collection: Collection;
 }
 export interface SyncCollectionArgs {
-  projectId: number
-  contractAddress: string
+  projectId: number;
+  contractAddress: string;
 }
 
 export interface SyncCollectionReturn {
-  collection: Collection  
+  collection: Collection;
 }
 export interface CreateCurrencyArgs {
-  currency: Currency
+  currency: Currency;
 }
 
 export interface CreateCurrencyReturn {
-  currency: Currency  
+  currency: Currency;
 }
 export interface CreateCurrenciesArgs {
-  currencies: Array<Currency>
+  currencies: Array<Currency>;
 }
 
 export interface CreateCurrenciesReturn {
-  currency: {[key: string]: Currency}  
+  currency: { [key: string]: Currency };
 }
 export interface UpdateCurrencyArgs {
-  currency: Currency
+  currency: Currency;
 }
 
 export interface UpdateCurrencyReturn {
-  currency: Currency  
-}
-export interface ListCurrenciesArgs {
+  currency: Currency;
 }
+export interface ListCurrenciesArgs {}
 
 export interface ListCurrenciesReturn {
-  currencies: Array<Currency>  
+  currencies: Array<Currency>;
 }
 export interface DeleteCurrencyArgs {
-  chainId: number
-  contractAddress: string
+  chainId: number;
+  contractAddress: string;
 }
 
 export interface DeleteCurrencyReturn {
-  currency: Currency  
+  currency: Currency;
 }
 
 export interface Marketplace {
-  listCurrencies(headers?: object, signal?: AbortSignal): Promise<ListCurrenciesReturn>
-  getCollectionDetail(args: GetCollectionDetailArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectionDetailReturn>
-  getCollectible(args: GetCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectibleReturn>
-  getLowestPriceOfferForCollectible(args: GetLowestPriceOfferForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetLowestPriceOfferForCollectibleReturn>
-  getHighestPriceOfferForCollectible(args: GetHighestPriceOfferForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetHighestPriceOfferForCollectibleReturn>
-  getLowestPriceListingForCollectible(args: GetLowestPriceListingForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetLowestPriceListingForCollectibleReturn>
-  getHighestPriceListingForCollectible(args: GetHighestPriceListingForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetHighestPriceListingForCollectibleReturn>
-  listListingsForCollectible(args: ListListingsForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<ListListingsForCollectibleReturn>
-  listOffersForCollectible(args: ListOffersForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<ListOffersForCollectibleReturn>
-  getCountOfListingsForCollectible(args: GetCountOfListingsForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetCountOfListingsForCollectibleReturn>
-  getCountOfOffersForCollectible(args: GetCountOfOffersForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetCountOfOffersForCollectibleReturn>
+  listCurrencies(
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCurrenciesReturn>;
+  getCollectionDetail(
+    args: GetCollectionDetailArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectionDetailReturn>;
+  getCollectible(
+    args: GetCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectibleReturn>;
+  getLowestPriceOfferForCollectible(
+    args: GetLowestPriceOfferForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetLowestPriceOfferForCollectibleReturn>;
+  getHighestPriceOfferForCollectible(
+    args: GetHighestPriceOfferForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetHighestPriceOfferForCollectibleReturn>;
+  getLowestPriceListingForCollectible(
+    args: GetLowestPriceListingForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetLowestPriceListingForCollectibleReturn>;
+  getHighestPriceListingForCollectible(
+    args: GetHighestPriceListingForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetHighestPriceListingForCollectibleReturn>;
+  listListingsForCollectible(
+    args: ListListingsForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListListingsForCollectibleReturn>;
+  listOffersForCollectible(
+    args: ListOffersForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListOffersForCollectibleReturn>;
+  getCountOfListingsForCollectible(
+    args: GetCountOfListingsForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCountOfListingsForCollectibleReturn>;
+  getCountOfOffersForCollectible(
+    args: GetCountOfOffersForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCountOfOffersForCollectibleReturn>;
   /**
    * @deprecated Please use GetLowestPriceOfferForCollectible instead.
    */
-  getCollectibleLowestOffer(args: GetCollectibleLowestOfferArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectibleLowestOfferReturn>
+  getCollectibleLowestOffer(
+    args: GetCollectibleLowestOfferArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectibleLowestOfferReturn>;
   /**
    * @deprecated Please use GetHighestPriceOfferForCollectible instead.
    */
-  getCollectibleHighestOffer(args: GetCollectibleHighestOfferArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectibleHighestOfferReturn>
+  getCollectibleHighestOffer(
+    args: GetCollectibleHighestOfferArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectibleHighestOfferReturn>;
   /**
    * @deprecated Please use GetLowestPriceListingForCollectible instead.
    */
-  getCollectibleLowestListing(args: GetCollectibleLowestListingArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectibleLowestListingReturn>
+  getCollectibleLowestListing(
+    args: GetCollectibleLowestListingArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectibleLowestListingReturn>;
   /**
    * @deprecated Please use GetHighestPriceListingForCollectible instead.
    */
-  getCollectibleHighestListing(args: GetCollectibleHighestListingArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectibleHighestListingReturn>
+  getCollectibleHighestListing(
+    args: GetCollectibleHighestListingArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectibleHighestListingReturn>;
   /**
    * @deprecated Please use ListListingsForCollectible instead.
    */
-  listCollectibleListings(args: ListCollectibleListingsArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectibleListingsReturn>
+  listCollectibleListings(
+    args: ListCollectibleListingsArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectibleListingsReturn>;
   /**
    * @deprecated Please use ListOffersForCollectible instead.
    */
-  listCollectibleOffers(args: ListCollectibleOffersArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectibleOffersReturn>
+  listCollectibleOffers(
+    args: ListCollectibleOffersArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectibleOffersReturn>;
   /**
    * checkout process
    */
-  generateBuyTransaction(args: GenerateBuyTransactionArgs, headers?: object, signal?: AbortSignal): Promise<GenerateBuyTransactionReturn>
-  generateSellTransaction(args: GenerateSellTransactionArgs, headers?: object, signal?: AbortSignal): Promise<GenerateSellTransactionReturn>
-  generateListingTransaction(args: GenerateListingTransactionArgs, headers?: object, signal?: AbortSignal): Promise<GenerateListingTransactionReturn>
-  generateOfferTransaction(args: GenerateOfferTransactionArgs, headers?: object, signal?: AbortSignal): Promise<GenerateOfferTransactionReturn>
-  generateCancelTransaction(args: GenerateCancelTransactionArgs, headers?: object, signal?: AbortSignal): Promise<GenerateCancelTransactionReturn>
+  generateBuyTransaction(
+    args: GenerateBuyTransactionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateBuyTransactionReturn>;
+  generateSellTransaction(
+    args: GenerateSellTransactionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateSellTransactionReturn>;
+  generateListingTransaction(
+    args: GenerateListingTransactionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateListingTransactionReturn>;
+  generateOfferTransaction(
+    args: GenerateOfferTransactionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateOfferTransactionReturn>;
+  generateCancelTransaction(
+    args: GenerateCancelTransactionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateCancelTransactionReturn>;
   /**
    * only used in a case of external transactions ( when we create off-chain transactions ) for instance opensea market
    */
-  execute(args: ExecuteArgs, headers?: object, signal?: AbortSignal): Promise<ExecuteReturn>
+  execute(
+    args: ExecuteArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ExecuteReturn>;
   /**
    * list of collectibles with best order for each collectible, by default this only returns collectibles with an order
    */
-  listCollectibles(args: ListCollectiblesArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectiblesReturn>
-  getCountOfAllCollectibles(args: GetCountOfAllCollectiblesArgs, headers?: object, signal?: AbortSignal): Promise<GetCountOfAllCollectiblesReturn>
-  getCountOfFilteredCollectibles(args: GetCountOfFilteredCollectiblesArgs, headers?: object, signal?: AbortSignal): Promise<GetCountOfFilteredCollectiblesReturn>
-  getFloorOrder(args: GetFloorOrderArgs, headers?: object, signal?: AbortSignal): Promise<GetFloorOrderReturn>
-  listCollectionActivities(args: ListCollectionActivitiesArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectionActivitiesReturn>
-  listCollectibleActivities(args: ListCollectibleActivitiesArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectibleActivitiesReturn>
-  listCollectiblesWithLowestListing(args: ListCollectiblesWithLowestListingArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectiblesWithLowestListingReturn>
-  listCollectiblesWithHighestOffer(args: ListCollectiblesWithHighestOfferArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectiblesWithHighestOfferReturn>
-  syncOrder(args: SyncOrderArgs, headers?: object, signal?: AbortSignal): Promise<SyncOrderReturn>
-  syncOrders(args: SyncOrdersArgs, headers?: object, signal?: AbortSignal): Promise<SyncOrdersReturn>
-  getOrders(args: GetOrdersArgs, headers?: object, signal?: AbortSignal): Promise<GetOrdersReturn>
-  checkoutOptionsMarketplace(args: CheckoutOptionsMarketplaceArgs, headers?: object, signal?: AbortSignal): Promise<CheckoutOptionsMarketplaceReturn>
-  checkoutOptionsSalesContract(args: CheckoutOptionsSalesContractArgs, headers?: object, signal?: AbortSignal): Promise<CheckoutOptionsSalesContractReturn>
-}
-
-export interface ListCurrenciesArgs {
-}
+  listCollectibles(
+    args: ListCollectiblesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectiblesReturn>;
+  getCountOfAllCollectibles(
+    args: GetCountOfAllCollectiblesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCountOfAllCollectiblesReturn>;
+  getCountOfFilteredCollectibles(
+    args: GetCountOfFilteredCollectiblesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCountOfFilteredCollectiblesReturn>;
+  getFloorOrder(
+    args: GetFloorOrderArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetFloorOrderReturn>;
+  listCollectionActivities(
+    args: ListCollectionActivitiesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectionActivitiesReturn>;
+  listCollectibleActivities(
+    args: ListCollectibleActivitiesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectibleActivitiesReturn>;
+  listCollectiblesWithLowestListing(
+    args: ListCollectiblesWithLowestListingArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectiblesWithLowestListingReturn>;
+  listCollectiblesWithHighestOffer(
+    args: ListCollectiblesWithHighestOfferArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectiblesWithHighestOfferReturn>;
+  syncOrder(
+    args: SyncOrderArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SyncOrderReturn>;
+  syncOrders(
+    args: SyncOrdersArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SyncOrdersReturn>;
+  getOrders(
+    args: GetOrdersArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetOrdersReturn>;
+  checkoutOptionsMarketplace(
+    args: CheckoutOptionsMarketplaceArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<CheckoutOptionsMarketplaceReturn>;
+  checkoutOptionsSalesContract(
+    args: CheckoutOptionsSalesContractArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<CheckoutOptionsSalesContractReturn>;
+}
+
+export interface ListCurrenciesArgs {}
 
 export interface ListCurrenciesReturn {
-  currencies: Array<Currency>  
+  currencies: Array<Currency>;
 }
 export interface GetCollectionDetailArgs {
-  contractAddress: string
+  contractAddress: string;
 }
 
 export interface GetCollectionDetailReturn {
-  collection: Collection  
+  collection: Collection;
 }
 export interface GetCollectibleArgs {
-  contractAddress: string
-  tokenId: string
+  contractAddress: string;
+  tokenId: string;
 }
 
 export interface GetCollectibleReturn {
-  metadata: TokenMetadata  
+  metadata: TokenMetadata;
 }
 export interface GetLowestPriceOfferForCollectibleArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
 }
 
 export interface GetLowestPriceOfferForCollectibleReturn {
-  order: Order  
+  order: Order;
 }
 export interface GetHighestPriceOfferForCollectibleArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
 }
 
 export interface GetHighestPriceOfferForCollectibleReturn {
-  order: Order  
+  order: Order;
 }
 export interface GetLowestPriceListingForCollectibleArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
 }
 
 export interface GetLowestPriceListingForCollectibleReturn {
-  order: Order  
+  order: Order;
 }
 export interface GetHighestPriceListingForCollectibleArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
 }
 
 export interface GetHighestPriceListingForCollectibleReturn {
-  order: Order  
+  order: Order;
 }
 export interface ListListingsForCollectibleArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
-  page?: Page
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
+  page?: Page;
 }
 
 export interface ListListingsForCollectibleReturn {
-  listings: Array<Order>
-  page?: Page  
+  listings: Array<Order>;
+  page?: Page;
 }
 export interface ListOffersForCollectibleArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
-  page?: Page
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
+  page?: Page;
 }
 
 export interface ListOffersForCollectibleReturn {
-  offers: Array<Order>
-  page?: Page  
+  offers: Array<Order>;
+  page?: Page;
 }
 export interface GetCountOfListingsForCollectibleArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
 }
 
 export interface GetCountOfListingsForCollectibleReturn {
-  count: number  
+  count: number;
 }
 export interface GetCountOfOffersForCollectibleArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
 }
 
 export interface GetCountOfOffersForCollectibleReturn {
-  count: number  
+  count: number;
 }
 export interface GetCollectibleLowestOfferArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
 }
 
 export interface GetCollectibleLowestOfferReturn {
-  order?: Order  
+  order?: Order;
 }
 export interface GetCollectibleHighestOfferArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
 }
 
 export interface GetCollectibleHighestOfferReturn {
-  order?: Order  
+  order?: Order;
 }
 export interface GetCollectibleLowestListingArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
 }
 
 export interface GetCollectibleLowestListingReturn {
-  order?: Order  
+  order?: Order;
 }
 export interface GetCollectibleHighestListingArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
 }
 
 export interface GetCollectibleHighestListingReturn {
-  order?: Order  
+  order?: Order;
 }
 export interface ListCollectibleListingsArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
-  page?: Page
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
+  page?: Page;
 }
 
 export interface ListCollectibleListingsReturn {
-  listings: Array<Order>
-  page?: Page  
+  listings: Array<Order>;
+  page?: Page;
 }
 export interface ListCollectibleOffersArgs {
-  contractAddress: string
-  tokenId: string
-  filter?: OrderFilter
-  page?: Page
+  contractAddress: string;
+  tokenId: string;
+  filter?: OrderFilter;
+  page?: Page;
 }
 
 export interface ListCollectibleOffersReturn {
-  offers: Array<Order>
-  page?: Page  
+  offers: Array<Order>;
+  page?: Page;
 }
 export interface GenerateBuyTransactionArgs {
-  collectionAddress: string
-  buyer: string
-  marketplace: MarketplaceKind
-  ordersData: Array<OrderData>
-  additionalFees: Array<AdditionalFee>
-  walletType?: WalletKind
+  collectionAddress: string;
+  buyer: string;
+  marketplace: MarketplaceKind;
+  ordersData: Array<OrderData>;
+  additionalFees: Array<AdditionalFee>;
+  walletType?: WalletKind;
 }
 
 export interface GenerateBuyTransactionReturn {
-  steps: Array<Step>  
+  steps: Array<Step>;
 }
 export interface GenerateSellTransactionArgs {
-  collectionAddress: string
-  seller: string
-  marketplace: MarketplaceKind
-  ordersData: Array<OrderData>
-  additionalFees: Array<AdditionalFee>
-  walletType?: WalletKind
+  collectionAddress: string;
+  seller: string;
+  marketplace: MarketplaceKind;
+  ordersData: Array<OrderData>;
+  additionalFees: Array<AdditionalFee>;
+  walletType?: WalletKind;
 }
 
 export interface GenerateSellTransactionReturn {
-  steps: Array<Step>  
+  steps: Array<Step>;
 }
 export interface GenerateListingTransactionArgs {
-  collectionAddress: string
-  owner: string
-  contractType: ContractType
-  orderbook: OrderbookKind
-  listing: CreateReq
-  walletType?: WalletKind
+  collectionAddress: string;
+  owner: string;
+  contractType: ContractType;
+  orderbook: OrderbookKind;
+  listing: CreateReq;
+  walletType?: WalletKind;
 }
 
 export interface GenerateListingTransactionReturn {
-  steps: Array<Step>  
+  steps: Array<Step>;
 }
 export interface GenerateOfferTransactionArgs {
-  collectionAddress: string
-  maker: string
-  contractType: ContractType
-  orderbook: OrderbookKind
-  offer: CreateReq
-  walletType?: WalletKind
+  collectionAddress: string;
+  maker: string;
+  contractType: ContractType;
+  orderbook: OrderbookKind;
+  offer: CreateReq;
+  walletType?: WalletKind;
 }
 
 export interface GenerateOfferTransactionReturn {
-  steps: Array<Step>  
+  steps: Array<Step>;
 }
 export interface GenerateCancelTransactionArgs {
-  collectionAddress: string
-  maker: string
-  marketplace: MarketplaceKind
-  orderId: string
+  collectionAddress: string;
+  maker: string;
+  marketplace: MarketplaceKind;
+  orderId: string;
 }
 
 export interface GenerateCancelTransactionReturn {
-  steps: Array<Step>  
+  steps: Array<Step>;
 }
 export interface ExecuteArgs {
-  signature: string 
+  signature: string;
   //executeType: ExecuteType  is deprecated, but we cant hide it in webrpc for now
-  method: string
-  endpoint: string
-  body: any
+  method: string;
+  endpoint: string;
+  body: any;
 }
 
 export interface ExecuteReturn {
-  orderId: string  
+  orderId: string;
 }
 export interface ListCollectiblesArgs {
-  side: OrderSide
-  contractAddress: string
-  filter?: CollectiblesFilter
-  page?: Page
+  side: OrderSide;
+  contractAddress: string;
+  filter?: CollectiblesFilter;
+  page?: Page;
 }
 
 export interface ListCollectiblesReturn {
-  collectibles: Array<CollectibleOrder>
-  page?: Page  
+  collectibles: Array<CollectibleOrder>;
+  page?: Page;
 }
 export interface GetCountOfAllCollectiblesArgs {
-  contractAddress: string
+  contractAddress: string;
 }
 
 export interface GetCountOfAllCollectiblesReturn {
-  count: number  
+  count: number;
 }
 export interface GetCountOfFilteredCollectiblesArgs {
-  side: OrderSide
-  contractAddress: string
-  filter?: CollectiblesFilter
+  side: OrderSide;
+  contractAddress: string;
+  filter?: CollectiblesFilter;
 }
 
 export interface GetCountOfFilteredCollectiblesReturn {
-  count: number  
+  count: number;
 }
 export interface GetFloorOrderArgs {
-  contractAddress: string
-  filter?: CollectiblesFilter
+  contractAddress: string;
+  filter?: CollectiblesFilter;
 }
 
 export interface GetFloorOrderReturn {
-  collectible: CollectibleOrder  
+  collectible: CollectibleOrder;
 }
 export interface ListCollectionActivitiesArgs {
-  contractAddress: string
-  page?: Page
+  contractAddress: string;
+  page?: Page;
 }
 
 export interface ListCollectionActivitiesReturn {
-  activities: Array<Activity>
-  page?: Page  
+  activities: Array<Activity>;
+  page?: Page;
 }
 export interface ListCollectibleActivitiesArgs {
-  contractAddress: string
-  tokenId: string
-  page?: Page
+  contractAddress: string;
+  tokenId: string;
+  page?: Page;
 }
 
 export interface ListCollectibleActivitiesReturn {
-  activities: Array<Activity>
-  page?: Page  
+  activities: Array<Activity>;
+  page?: Page;
 }
 export interface ListCollectiblesWithLowestListingArgs {
-  contractAddress: string
-  filter?: CollectiblesFilter
-  page?: Page
+  contractAddress: string;
+  filter?: CollectiblesFilter;
+  page?: Page;
 }
 
 export interface ListCollectiblesWithLowestListingReturn {
-  collectibles: Array<CollectibleOrder>
-  page?: Page  
+  collectibles: Array<CollectibleOrder>;
+  page?: Page;
 }
 export interface ListCollectiblesWithHighestOfferArgs {
-  contractAddress: string
-  filter?: CollectiblesFilter
-  page?: Page
+  contractAddress: string;
+  filter?: CollectiblesFilter;
+  page?: Page;
 }
 
 export interface ListCollectiblesWithHighestOfferReturn {
-  collectibles: Array<CollectibleOrder>
-  page?: Page  
+  collectibles: Array<CollectibleOrder>;
+  page?: Page;
 }
 export interface SyncOrderArgs {
-  order: Order
+  order: Order;
 }
 
-export interface SyncOrderReturn {  
-}
+export interface SyncOrderReturn {}
 export interface SyncOrdersArgs {
-  orders: Array<Order>
+  orders: Array<Order>;
 }
 
-export interface SyncOrdersReturn {  
-}
+export interface SyncOrdersReturn {}
 export interface GetOrdersArgs {
-  input: Array<GetOrdersInput>
-  page?: Page
+  input: Array<GetOrdersInput>;
+  page?: Page;
 }
 
 export interface GetOrdersReturn {
-  orders: Array<Order>
-  page?: Page  
+  orders: Array<Order>;
+  page?: Page;
 }
 export interface CheckoutOptionsMarketplaceArgs {
-  wallet: string
-  orders: Array<CheckoutOptionsMarketplaceOrder>
-  additionalFee: number
+  wallet: string;
+  orders: Array<CheckoutOptionsMarketplaceOrder>;
+  additionalFee: number;
 }
 
 export interface CheckoutOptionsMarketplaceReturn {
-  options: CheckoutOptions  
+  options: CheckoutOptions;
 }
 export interface CheckoutOptionsSalesContractArgs {
-  wallet: string
-  contractAddress: string
-  collectionAddress: string
-  items: Array<CheckoutOptionsItem>
+  wallet: string;
+  contractAddress: string;
+  collectionAddress: string;
+  items: Array<CheckoutOptionsItem>;
 }
 
 export interface CheckoutOptionsSalesContractReturn {
-  options: CheckoutOptions  
+  options: CheckoutOptions;
 }
 
-
-  
 //
 // Client
 //
 export class Admin implements Admin {
-  protected hostname: string
-  protected fetch: Fetch
-  protected path = '/rpc/Admin/'
+  protected hostname: string;
+  protected fetch: Fetch;
+  protected path = "/rpc/Admin/";
 
   constructor(hostname: string, fetch: Fetch) {
-    this.hostname = hostname.replace(/\/*$/, '')
-    this.fetch = (input: RequestInfo, init?: RequestInit) => fetch(input, init)
+    this.hostname = hostname.replace(/\/*$/, "");
+    this.fetch = (input: RequestInfo, init?: RequestInit) => fetch(input, init);
   }
 
   private url(name: string): string {
-    return this.hostname + this.path + name
+    return this.hostname + this.path + name;
   }
-  
-  createCollection = (args: CreateCollectionArgs, headers?: object, signal?: AbortSignal): Promise<CreateCollectionReturn> => {
+
+  createCollection = (
+    args: CreateCollectionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<CreateCollectionReturn> => {
     return this.fetch(
-      this.url('CreateCollection'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          collection: <Collection>(_data.collection),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCollection = (args: GetCollectionArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectionReturn> => {
+      this.url("CreateCollection"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            collection: <Collection>_data.collection,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getCollection = (
+    args: GetCollectionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectionReturn> => {
     return this.fetch(
-      this.url('GetCollection'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          collection: <Collection>(_data.collection),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  updateCollection = (args: UpdateCollectionArgs, headers?: object, signal?: AbortSignal): Promise<UpdateCollectionReturn> => {
+      this.url("GetCollection"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            collection: <Collection>_data.collection,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  updateCollection = (
+    args: UpdateCollectionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<UpdateCollectionReturn> => {
     return this.fetch(
-      this.url('UpdateCollection'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          collection: <Collection>(_data.collection),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listCollections = (args: ListCollectionsArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectionsReturn> => {
+      this.url("UpdateCollection"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            collection: <Collection>_data.collection,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  listCollections = (
+    args: ListCollectionsArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectionsReturn> => {
     return this.fetch(
-      this.url('ListCollections'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          collections: <Array<Collection>>(_data.collections),
-          page: <Page>(_data.page),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  deleteCollection = (args: DeleteCollectionArgs, headers?: object, signal?: AbortSignal): Promise<DeleteCollectionReturn> => {
+      this.url("ListCollections"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            collections: <Array<Collection>>_data.collections,
+            page: <Page>_data.page,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  deleteCollection = (
+    args: DeleteCollectionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<DeleteCollectionReturn> => {
     return this.fetch(
-      this.url('DeleteCollection'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          collection: <Collection>(_data.collection),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  syncCollection = (args: SyncCollectionArgs, headers?: object, signal?: AbortSignal): Promise<SyncCollectionReturn> => {
+      this.url("DeleteCollection"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            collection: <Collection>_data.collection,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  syncCollection = (
+    args: SyncCollectionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SyncCollectionReturn> => {
     return this.fetch(
-      this.url('SyncCollection'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          collection: <Collection>(_data.collection),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  createCurrency = (args: CreateCurrencyArgs, headers?: object, signal?: AbortSignal): Promise<CreateCurrencyReturn> => {
+      this.url("SyncCollection"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            collection: <Collection>_data.collection,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  createCurrency = (
+    args: CreateCurrencyArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<CreateCurrencyReturn> => {
     return this.fetch(
-      this.url('CreateCurrency'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          currency: <Currency>(_data.currency),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  createCurrencies = (args: CreateCurrenciesArgs, headers?: object, signal?: AbortSignal): Promise<CreateCurrenciesReturn> => {
+      this.url("CreateCurrency"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            currency: <Currency>_data.currency,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  createCurrencies = (
+    args: CreateCurrenciesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<CreateCurrenciesReturn> => {
     return this.fetch(
-      this.url('CreateCurrencies'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          currency: <{[key: string]: Currency}>(_data.currency),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  updateCurrency = (args: UpdateCurrencyArgs, headers?: object, signal?: AbortSignal): Promise<UpdateCurrencyReturn> => {
+      this.url("CreateCurrencies"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            currency: <{ [key: string]: Currency }>_data.currency,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  updateCurrency = (
+    args: UpdateCurrencyArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<UpdateCurrencyReturn> => {
     return this.fetch(
-      this.url('UpdateCurrency'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          currency: <Currency>(_data.currency),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listCurrencies = (headers?: object, signal?: AbortSignal): Promise<ListCurrenciesReturn> => {
+      this.url("UpdateCurrency"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            currency: <Currency>_data.currency,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  listCurrencies = (
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCurrenciesReturn> => {
     return this.fetch(
-      this.url('ListCurrencies'),
+      this.url("ListCurrencies"),
       createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          currencies: <Array<Currency>>(_data.currencies),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  deleteCurrency = (args: DeleteCurrencyArgs, headers?: object, signal?: AbortSignal): Promise<DeleteCurrencyReturn> => {
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            currencies: <Array<Currency>>_data.currencies,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  deleteCurrency = (
+    args: DeleteCurrencyArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<DeleteCurrencyReturn> => {
     return this.fetch(
-      this.url('DeleteCurrency'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          currency: <Currency>(_data.currency),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
+      this.url("DeleteCurrency"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            currency: <Currency>_data.currency,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
 }
 export class Marketplace implements Marketplace {
-  protected hostname: string
-  protected fetch: Fetch
-  protected path = '/rpc/Marketplace/'
+  protected hostname: string;
+  protected fetch: Fetch;
+  protected path = "/rpc/Marketplace/";
 
   constructor(hostname: string, fetch: Fetch) {
-    this.hostname = hostname.replace(/\/*$/, '')
-    this.fetch = (input: RequestInfo, init?: RequestInit) => fetch(input, init)
+    this.hostname = hostname.replace(/\/*$/, "");
+    this.fetch = (input: RequestInfo, init?: RequestInit) => fetch(input, init);
   }
 
   private url(name: string): string {
-    return this.hostname + this.path + name
+    return this.hostname + this.path + name;
   }
-  
-  listCurrencies = (headers?: object, signal?: AbortSignal): Promise<ListCurrenciesReturn> => {
+
+  listCurrencies = (
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCurrenciesReturn> => {
     return this.fetch(
-      this.url('ListCurrencies'),
+      this.url("ListCurrencies"),
       createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          currencies: <Array<Currency>>(_data.currencies),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCollectionDetail = (args: GetCollectionDetailArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectionDetailReturn> => {
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            currencies: <Array<Currency>>_data.currencies,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getCollectionDetail = (
+    args: GetCollectionDetailArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectionDetailReturn> => {
     return this.fetch(
-      this.url('GetCollectionDetail'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          collection: <Collection>(_data.collection),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCollectible = (args: GetCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectibleReturn> => {
+      this.url("GetCollectionDetail"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            collection: <Collection>_data.collection,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getCollectible = (
+    args: GetCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectibleReturn> => {
     return this.fetch(
-      this.url('GetCollectible'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          metadata: <TokenMetadata>(_data.metadata),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getLowestPriceOfferForCollectible = (args: GetLowestPriceOfferForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetLowestPriceOfferForCollectibleReturn> => {
+      this.url("GetCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            metadata: <TokenMetadata>_data.metadata,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getLowestPriceOfferForCollectible = (
+    args: GetLowestPriceOfferForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetLowestPriceOfferForCollectibleReturn> => {
     return this.fetch(
-      this.url('GetLowestPriceOfferForCollectible'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          order: <Order>(_data.order),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getHighestPriceOfferForCollectible = (args: GetHighestPriceOfferForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetHighestPriceOfferForCollectibleReturn> => {
+      this.url("GetLowestPriceOfferForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            order: <Order>_data.order,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getHighestPriceOfferForCollectible = (
+    args: GetHighestPriceOfferForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetHighestPriceOfferForCollectibleReturn> => {
     return this.fetch(
-      this.url('GetHighestPriceOfferForCollectible'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          order: <Order>(_data.order),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getLowestPriceListingForCollectible = (args: GetLowestPriceListingForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetLowestPriceListingForCollectibleReturn> => {
+      this.url("GetHighestPriceOfferForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            order: <Order>_data.order,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getLowestPriceListingForCollectible = (
+    args: GetLowestPriceListingForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetLowestPriceListingForCollectibleReturn> => {
     return this.fetch(
-      this.url('GetLowestPriceListingForCollectible'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          order: <Order>(_data.order),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getHighestPriceListingForCollectible = (args: GetHighestPriceListingForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetHighestPriceListingForCollectibleReturn> => {
+      this.url("GetLowestPriceListingForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            order: <Order>_data.order,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getHighestPriceListingForCollectible = (
+    args: GetHighestPriceListingForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetHighestPriceListingForCollectibleReturn> => {
     return this.fetch(
-      this.url('GetHighestPriceListingForCollectible'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          order: <Order>(_data.order),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listListingsForCollectible = (args: ListListingsForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<ListListingsForCollectibleReturn> => {
+      this.url("GetHighestPriceListingForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            order: <Order>_data.order,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  listListingsForCollectible = (
+    args: ListListingsForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListListingsForCollectibleReturn> => {
     return this.fetch(
-      this.url('ListListingsForCollectible'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          listings: <Array<Order>>(_data.listings),
-          page: <Page>(_data.page),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listOffersForCollectible = (args: ListOffersForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<ListOffersForCollectibleReturn> => {
+      this.url("ListListingsForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            listings: <Array<Order>>_data.listings,
+            page: <Page>_data.page,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  listOffersForCollectible = (
+    args: ListOffersForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListOffersForCollectibleReturn> => {
     return this.fetch(
-      this.url('ListOffersForCollectible'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          offers: <Array<Order>>(_data.offers),
-          page: <Page>(_data.page),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCountOfListingsForCollectible = (args: GetCountOfListingsForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetCountOfListingsForCollectibleReturn> => {
+      this.url("ListOffersForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            offers: <Array<Order>>_data.offers,
+            page: <Page>_data.page,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getCountOfListingsForCollectible = (
+    args: GetCountOfListingsForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCountOfListingsForCollectibleReturn> => {
     return this.fetch(
-      this.url('GetCountOfListingsForCollectible'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          count: <number>(_data.count),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCountOfOffersForCollectible = (args: GetCountOfOffersForCollectibleArgs, headers?: object, signal?: AbortSignal): Promise<GetCountOfOffersForCollectibleReturn> => {
+      this.url("GetCountOfListingsForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            count: <number>_data.count,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getCountOfOffersForCollectible = (
+    args: GetCountOfOffersForCollectibleArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCountOfOffersForCollectibleReturn> => {
     return this.fetch(
-      this.url('GetCountOfOffersForCollectible'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          count: <number>(_data.count),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCollectibleLowestOffer = (args: GetCollectibleLowestOfferArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectibleLowestOfferReturn> => {
+      this.url("GetCountOfOffersForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            count: <number>_data.count,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getCollectibleLowestOffer = (
+    args: GetCollectibleLowestOfferArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectibleLowestOfferReturn> => {
     return this.fetch(
-      this.url('GetCollectibleLowestOffer'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          order: <Order>(_data.order),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCollectibleHighestOffer = (args: GetCollectibleHighestOfferArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectibleHighestOfferReturn> => {
+      this.url("GetCollectibleLowestOffer"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            order: <Order>_data.order,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getCollectibleHighestOffer = (
+    args: GetCollectibleHighestOfferArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectibleHighestOfferReturn> => {
     return this.fetch(
-      this.url('GetCollectibleHighestOffer'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          order: <Order>(_data.order),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCollectibleLowestListing = (args: GetCollectibleLowestListingArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectibleLowestListingReturn> => {
+      this.url("GetCollectibleHighestOffer"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            order: <Order>_data.order,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getCollectibleLowestListing = (
+    args: GetCollectibleLowestListingArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectibleLowestListingReturn> => {
     return this.fetch(
-      this.url('GetCollectibleLowestListing'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          order: <Order>(_data.order),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCollectibleHighestListing = (args: GetCollectibleHighestListingArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectibleHighestListingReturn> => {
+      this.url("GetCollectibleLowestListing"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            order: <Order>_data.order,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getCollectibleHighestListing = (
+    args: GetCollectibleHighestListingArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectibleHighestListingReturn> => {
     return this.fetch(
-      this.url('GetCollectibleHighestListing'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          order: <Order>(_data.order),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listCollectibleListings = (args: ListCollectibleListingsArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectibleListingsReturn> => {
+      this.url("GetCollectibleHighestListing"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            order: <Order>_data.order,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  listCollectibleListings = (
+    args: ListCollectibleListingsArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectibleListingsReturn> => {
     return this.fetch(
-      this.url('ListCollectibleListings'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          listings: <Array<Order>>(_data.listings),
-          page: <Page>(_data.page),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listCollectibleOffers = (args: ListCollectibleOffersArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectibleOffersReturn> => {
+      this.url("ListCollectibleListings"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            listings: <Array<Order>>_data.listings,
+            page: <Page>_data.page,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  listCollectibleOffers = (
+    args: ListCollectibleOffersArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectibleOffersReturn> => {
     return this.fetch(
-      this.url('ListCollectibleOffers'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          offers: <Array<Order>>(_data.offers),
-          page: <Page>(_data.page),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  generateBuyTransaction = (args: GenerateBuyTransactionArgs, headers?: object, signal?: AbortSignal): Promise<GenerateBuyTransactionReturn> => {
+      this.url("ListCollectibleOffers"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            offers: <Array<Order>>_data.offers,
+            page: <Page>_data.page,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  generateBuyTransaction = (
+    args: GenerateBuyTransactionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateBuyTransactionReturn> => {
     return this.fetch(
-      this.url('GenerateBuyTransaction'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          steps: <Array<Step>>(_data.steps),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  generateSellTransaction = (args: GenerateSellTransactionArgs, headers?: object, signal?: AbortSignal): Promise<GenerateSellTransactionReturn> => {
+      this.url("GenerateBuyTransaction"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            steps: <Array<Step>>_data.steps,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  generateSellTransaction = (
+    args: GenerateSellTransactionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateSellTransactionReturn> => {
     return this.fetch(
-      this.url('GenerateSellTransaction'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          steps: <Array<Step>>(_data.steps),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  generateListingTransaction = (args: GenerateListingTransactionArgs, headers?: object, signal?: AbortSignal): Promise<GenerateListingTransactionReturn> => {
+      this.url("GenerateSellTransaction"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            steps: <Array<Step>>_data.steps,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  generateListingTransaction = (
+    args: GenerateListingTransactionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateListingTransactionReturn> => {
     return this.fetch(
-      this.url('GenerateListingTransaction'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          steps: <Array<Step>>(_data.steps),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  generateOfferTransaction = (args: GenerateOfferTransactionArgs, headers?: object, signal?: AbortSignal): Promise<GenerateOfferTransactionReturn> => {
+      this.url("GenerateListingTransaction"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            steps: <Array<Step>>_data.steps,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  generateOfferTransaction = (
+    args: GenerateOfferTransactionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateOfferTransactionReturn> => {
     return this.fetch(
-      this.url('GenerateOfferTransaction'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          steps: <Array<Step>>(_data.steps),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  generateCancelTransaction = (args: GenerateCancelTransactionArgs, headers?: object, signal?: AbortSignal): Promise<GenerateCancelTransactionReturn> => {
+      this.url("GenerateOfferTransaction"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            steps: <Array<Step>>_data.steps,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  generateCancelTransaction = (
+    args: GenerateCancelTransactionArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateCancelTransactionReturn> => {
     return this.fetch(
-      this.url('GenerateCancelTransaction'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          steps: <Array<Step>>(_data.steps),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  execute = (args: ExecuteArgs, headers?: object, signal?: AbortSignal): Promise<ExecuteReturn> => {
+      this.url("GenerateCancelTransaction"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            steps: <Array<Step>>_data.steps,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  execute = (
+    args: ExecuteArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ExecuteReturn> => {
     return this.fetch(
-      this.url('Execute'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          orderId: <string>(_data.orderId),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listCollectibles = (args: ListCollectiblesArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectiblesReturn> => {
+      this.url("Execute"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            orderId: <string>_data.orderId,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  listCollectibles = (
+    args: ListCollectiblesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectiblesReturn> => {
     return this.fetch(
-      this.url('ListCollectibles'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          collectibles: <Array<CollectibleOrder>>(_data.collectibles),
-          page: <Page>(_data.page),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCountOfAllCollectibles = (args: GetCountOfAllCollectiblesArgs, headers?: object, signal?: AbortSignal): Promise<GetCountOfAllCollectiblesReturn> => {
+      this.url("ListCollectibles"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            collectibles: <Array<CollectibleOrder>>_data.collectibles,
+            page: <Page>_data.page,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getCountOfAllCollectibles = (
+    args: GetCountOfAllCollectiblesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCountOfAllCollectiblesReturn> => {
     return this.fetch(
-      this.url('GetCountOfAllCollectibles'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          count: <number>(_data.count),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCountOfFilteredCollectibles = (args: GetCountOfFilteredCollectiblesArgs, headers?: object, signal?: AbortSignal): Promise<GetCountOfFilteredCollectiblesReturn> => {
+      this.url("GetCountOfAllCollectibles"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            count: <number>_data.count,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getCountOfFilteredCollectibles = (
+    args: GetCountOfFilteredCollectiblesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCountOfFilteredCollectiblesReturn> => {
     return this.fetch(
-      this.url('GetCountOfFilteredCollectibles'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          count: <number>(_data.count),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getFloorOrder = (args: GetFloorOrderArgs, headers?: object, signal?: AbortSignal): Promise<GetFloorOrderReturn> => {
+      this.url("GetCountOfFilteredCollectibles"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            count: <number>_data.count,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getFloorOrder = (
+    args: GetFloorOrderArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetFloorOrderReturn> => {
     return this.fetch(
-      this.url('GetFloorOrder'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          collectible: <CollectibleOrder>(_data.collectible),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listCollectionActivities = (args: ListCollectionActivitiesArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectionActivitiesReturn> => {
+      this.url("GetFloorOrder"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            collectible: <CollectibleOrder>_data.collectible,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  listCollectionActivities = (
+    args: ListCollectionActivitiesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectionActivitiesReturn> => {
     return this.fetch(
-      this.url('ListCollectionActivities'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          activities: <Array<Activity>>(_data.activities),
-          page: <Page>(_data.page),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listCollectibleActivities = (args: ListCollectibleActivitiesArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectibleActivitiesReturn> => {
+      this.url("ListCollectionActivities"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            activities: <Array<Activity>>_data.activities,
+            page: <Page>_data.page,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  listCollectibleActivities = (
+    args: ListCollectibleActivitiesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectibleActivitiesReturn> => {
     return this.fetch(
-      this.url('ListCollectibleActivities'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          activities: <Array<Activity>>(_data.activities),
-          page: <Page>(_data.page),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listCollectiblesWithLowestListing = (args: ListCollectiblesWithLowestListingArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectiblesWithLowestListingReturn> => {
+      this.url("ListCollectibleActivities"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            activities: <Array<Activity>>_data.activities,
+            page: <Page>_data.page,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  listCollectiblesWithLowestListing = (
+    args: ListCollectiblesWithLowestListingArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectiblesWithLowestListingReturn> => {
     return this.fetch(
-      this.url('ListCollectiblesWithLowestListing'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          collectibles: <Array<CollectibleOrder>>(_data.collectibles),
-          page: <Page>(_data.page),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listCollectiblesWithHighestOffer = (args: ListCollectiblesWithHighestOfferArgs, headers?: object, signal?: AbortSignal): Promise<ListCollectiblesWithHighestOfferReturn> => {
+      this.url("ListCollectiblesWithLowestListing"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            collectibles: <Array<CollectibleOrder>>_data.collectibles,
+            page: <Page>_data.page,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  listCollectiblesWithHighestOffer = (
+    args: ListCollectiblesWithHighestOfferArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListCollectiblesWithHighestOfferReturn> => {
     return this.fetch(
-      this.url('ListCollectiblesWithHighestOffer'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          collectibles: <Array<CollectibleOrder>>(_data.collectibles),
-          page: <Page>(_data.page),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  syncOrder = (args: SyncOrderArgs, headers?: object, signal?: AbortSignal): Promise<SyncOrderReturn> => {
+      this.url("ListCollectiblesWithHighestOffer"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            collectibles: <Array<CollectibleOrder>>_data.collectibles,
+            page: <Page>_data.page,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  syncOrder = (
+    args: SyncOrderArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SyncOrderReturn> => {
     return this.fetch(
-      this.url('SyncOrder'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {}
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  syncOrders = (args: SyncOrdersArgs, headers?: object, signal?: AbortSignal): Promise<SyncOrdersReturn> => {
+      this.url("SyncOrder"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {};
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  syncOrders = (
+    args: SyncOrdersArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SyncOrdersReturn> => {
     return this.fetch(
-      this.url('SyncOrders'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {}
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getOrders = (args: GetOrdersArgs, headers?: object, signal?: AbortSignal): Promise<GetOrdersReturn> => {
+      this.url("SyncOrders"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {};
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  getOrders = (
+    args: GetOrdersArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetOrdersReturn> => {
     return this.fetch(
-      this.url('GetOrders'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          orders: <Array<Order>>(_data.orders),
-          page: <Page>(_data.page),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  checkoutOptionsMarketplace = (args: CheckoutOptionsMarketplaceArgs, headers?: object, signal?: AbortSignal): Promise<CheckoutOptionsMarketplaceReturn> => {
+      this.url("GetOrders"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            orders: <Array<Order>>_data.orders,
+            page: <Page>_data.page,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  checkoutOptionsMarketplace = (
+    args: CheckoutOptionsMarketplaceArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<CheckoutOptionsMarketplaceReturn> => {
     return this.fetch(
-      this.url('CheckoutOptionsMarketplace'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          options: <CheckoutOptions>(_data.options),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  checkoutOptionsSalesContract = (args: CheckoutOptionsSalesContractArgs, headers?: object, signal?: AbortSignal): Promise<CheckoutOptionsSalesContractReturn> => {
+      this.url("CheckoutOptionsMarketplace"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            options: <CheckoutOptions>_data.options,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
+
+  checkoutOptionsSalesContract = (
+    args: CheckoutOptionsSalesContractArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<CheckoutOptionsSalesContractReturn> => {
     return this.fetch(
-      this.url('CheckoutOptionsSalesContract'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          options: <CheckoutOptions>(_data.options),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
+      this.url("CheckoutOptionsSalesContract"),
+      createHTTPRequest(args, headers, signal)
+    ).then(
+      (res) => {
+        return buildResponse(res).then((_data) => {
+          return {
+            options: <CheckoutOptions>_data.options,
+          };
+        });
+      },
+      (error) => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ""}`,
+        });
+      }
+    );
+  };
 }
 
-  const createHTTPRequest = (body: object = {}, headers: object = {}, signal: AbortSignal | null = null): object => {
-  const reqHeaders: {[key: string]: string} = { ...headers, 'Content-Type': 'application/json' }
-  reqHeaders[WebrpcHeader] = WebrpcHeaderValue
+const createHTTPRequest = (
+  body: object = {},
+  headers: object = {},
+  signal: AbortSignal | null = null
+): object => {
+  const reqHeaders: { [key: string]: string } = {
+    ...headers,
+    "Content-Type": "application/json",
+  };
+  reqHeaders[WebrpcHeader] = WebrpcHeaderValue;
 
   return {
-    method: 'POST',
+    method: "POST",
     headers: reqHeaders,
     body: JSON.stringify(body || {}),
-    signal
-  }
-}
+    signal,
+  };
+};
 
 const buildResponse = (res: Response): Promise<any> => {
-  return res.text().then(text => {
-    let data
+  return res.text().then((text) => {
+    let data;
     try {
-      data = JSON.parse(text)
-    } catch(error) {
-      let message = ''
-      if (error instanceof Error)  {
-        message = error.message
+      data = JSON.parse(text);
+    } catch (error) {
+      let message = "";
+      if (error instanceof Error) {
+        message = error.message;
       }
       throw WebrpcBadResponseError.new({
         status: res.status,
-        cause: `JSON.parse(): ${message}: response text: ${text}`},
-      )
+        cause: `JSON.parse(): ${message}: response text: ${text}`,
+      });
     }
     if (!res.ok) {
-      const code: number = (typeof data.code === 'number') ? data.code : 0
-      throw (webrpcErrorByCode[code] || WebrpcError).new(data)
+      const code: number = typeof data.code === "number" ? data.code : 0;
+      throw (webrpcErrorByCode[code] || WebrpcError).new(data);
     }
-    return data
-  })
-}
+    return data;
+  });
+};
 
 //
 // Errors
 //
 
 export class WebrpcError extends Error {
-  name: string
-  code: number
-  message: string
-  status: number
-  cause?: string
+  name: string;
+  code: number;
+  message: string;
+  status: number;
+  cause?: string;
 
   /** @deprecated Use message instead of msg. Deprecated in webrpc v0.11.0. */
-  msg: string
-
-  constructor(name: string, code: number, message: string, status: number, cause?: string) {
-    super(message)
-    this.name = name || 'WebrpcError'
-    this.code = typeof code === 'number' ? code : 0
-    this.message = message || `endpoint error ${this.code}`
-    this.msg = this.message
-    this.status = typeof status === 'number' ? status : 0
-    this.cause = cause
-    Object.setPrototypeOf(this, WebrpcError.prototype)
+  msg: string;
+
+  constructor(
+    name: string,
+    code: number,
+    message: string,
+    status: number,
+    cause?: string
+  ) {
+    super(message);
+    this.name = name || "WebrpcError";
+    this.code = typeof code === "number" ? code : 0;
+    this.message = message || `endpoint error ${this.code}`;
+    this.msg = this.message;
+    this.status = typeof status === "number" ? status : 0;
+    this.cause = cause;
+    Object.setPrototypeOf(this, WebrpcError.prototype);
   }
 
   static new(payload: any): WebrpcError {
-    return new this(payload.error, payload.code, payload.message || payload.msg, payload.status, payload.cause)
+    return new this(
+      payload.error,
+      payload.code,
+      payload.message || payload.msg,
+      payload.status,
+      payload.cause
+    );
   }
 }
 
@@ -1799,331 +2463,329 @@ export class WebrpcError extends Error {
 
 export class WebrpcEndpointError extends WebrpcError {
   constructor(
-    name: string = 'WebrpcEndpoint',
+    name: string = "WebrpcEndpoint",
     code: number = 0,
     message: string = `endpoint error`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcEndpointError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcEndpointError.prototype);
   }
 }
 
 export class WebrpcRequestFailedError extends WebrpcError {
   constructor(
-    name: string = 'WebrpcRequestFailed',
+    name: string = "WebrpcRequestFailed",
     code: number = -1,
     message: string = `request failed`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcRequestFailedError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcRequestFailedError.prototype);
   }
 }
 
 export class WebrpcBadRouteError extends WebrpcError {
   constructor(
-    name: string = 'WebrpcBadRoute',
+    name: string = "WebrpcBadRoute",
     code: number = -2,
     message: string = `bad route`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcBadRouteError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadRouteError.prototype);
   }
 }
 
 export class WebrpcBadMethodError extends WebrpcError {
   constructor(
-    name: string = 'WebrpcBadMethod',
+    name: string = "WebrpcBadMethod",
     code: number = -3,
     message: string = `bad method`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcBadMethodError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadMethodError.prototype);
   }
 }
 
 export class WebrpcBadRequestError extends WebrpcError {
   constructor(
-    name: string = 'WebrpcBadRequest',
+    name: string = "WebrpcBadRequest",
     code: number = -4,
     message: string = `bad request`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcBadRequestError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadRequestError.prototype);
   }
 }
 
 export class WebrpcBadResponseError extends WebrpcError {
   constructor(
-    name: string = 'WebrpcBadResponse',
+    name: string = "WebrpcBadResponse",
     code: number = -5,
     message: string = `bad response`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcBadResponseError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadResponseError.prototype);
   }
 }
 
 export class WebrpcServerPanicError extends WebrpcError {
   constructor(
-    name: string = 'WebrpcServerPanic',
+    name: string = "WebrpcServerPanic",
     code: number = -6,
     message: string = `server panic`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcServerPanicError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcServerPanicError.prototype);
   }
 }
 
 export class WebrpcInternalErrorError extends WebrpcError {
   constructor(
-    name: string = 'WebrpcInternalError',
+    name: string = "WebrpcInternalError",
     code: number = -7,
     message: string = `internal error`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcInternalErrorError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcInternalErrorError.prototype);
   }
 }
 
 export class WebrpcClientDisconnectedError extends WebrpcError {
   constructor(
-    name: string = 'WebrpcClientDisconnected',
+    name: string = "WebrpcClientDisconnected",
     code: number = -8,
     message: string = `client disconnected`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcClientDisconnectedError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcClientDisconnectedError.prototype);
   }
 }
 
 export class WebrpcStreamLostError extends WebrpcError {
   constructor(
-    name: string = 'WebrpcStreamLost',
+    name: string = "WebrpcStreamLost",
     code: number = -9,
     message: string = `stream lost`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcStreamLostError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcStreamLostError.prototype);
   }
 }
 
 export class WebrpcStreamFinishedError extends WebrpcError {
   constructor(
-    name: string = 'WebrpcStreamFinished',
+    name: string = "WebrpcStreamFinished",
     code: number = -10,
     message: string = `stream finished`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcStreamFinishedError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcStreamFinishedError.prototype);
   }
 }
 
-
 // Schema errors
 
 export class UnauthorizedError extends WebrpcError {
   constructor(
-    name: string = 'Unauthorized',
+    name: string = "Unauthorized",
     code: number = 1000,
     message: string = `Unauthorized access`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, UnauthorizedError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, UnauthorizedError.prototype);
   }
 }
 
 export class PermissionDeniedError extends WebrpcError {
   constructor(
-    name: string = 'PermissionDenied',
+    name: string = "PermissionDenied",
     code: number = 1001,
     message: string = `Permission denied`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, PermissionDeniedError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, PermissionDeniedError.prototype);
   }
 }
 
 export class SessionExpiredError extends WebrpcError {
   constructor(
-    name: string = 'SessionExpired',
+    name: string = "SessionExpired",
     code: number = 1002,
     message: string = `Session expired`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, SessionExpiredError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, SessionExpiredError.prototype);
   }
 }
 
 export class MethodNotFoundError extends WebrpcError {
   constructor(
-    name: string = 'MethodNotFound',
+    name: string = "MethodNotFound",
     code: number = 1003,
     message: string = `Method not found`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, MethodNotFoundError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, MethodNotFoundError.prototype);
   }
 }
 
 export class TimeoutError extends WebrpcError {
   constructor(
-    name: string = 'Timeout',
+    name: string = "Timeout",
     code: number = 2000,
     message: string = `Request timed out`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, TimeoutError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, TimeoutError.prototype);
   }
 }
 
 export class InvalidArgumentError extends WebrpcError {
   constructor(
-    name: string = 'InvalidArgument',
+    name: string = "InvalidArgument",
     code: number = 2001,
     message: string = `Invalid argument`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, InvalidArgumentError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, InvalidArgumentError.prototype);
   }
 }
 
 export class NotFoundError extends WebrpcError {
   constructor(
-    name: string = 'NotFound',
+    name: string = "NotFound",
     code: number = 3000,
     message: string = `Resource not found`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, NotFoundError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, NotFoundError.prototype);
   }
 }
 
 export class UserNotFoundError extends WebrpcError {
   constructor(
-    name: string = 'UserNotFound',
+    name: string = "UserNotFound",
     code: number = 3001,
     message: string = `User not found`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, UserNotFoundError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, UserNotFoundError.prototype);
   }
 }
 
 export class ProjectNotFoundError extends WebrpcError {
   constructor(
-    name: string = 'ProjectNotFound',
+    name: string = "ProjectNotFound",
     code: number = 3002,
     message: string = `Project not found`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, ProjectNotFoundError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, ProjectNotFoundError.prototype);
   }
 }
 
 export class InvalidTierError extends WebrpcError {
   constructor(
-    name: string = 'InvalidTier',
+    name: string = "InvalidTier",
     code: number = 3003,
     message: string = `Invalid subscription tier`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, InvalidTierError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, InvalidTierError.prototype);
   }
 }
 
 export class ProjectLimitReachedError extends WebrpcError {
   constructor(
-    name: string = 'ProjectLimitReached',
+    name: string = "ProjectLimitReached",
     code: number = 3005,
     message: string = `Project limit reached`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, ProjectLimitReachedError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, ProjectLimitReachedError.prototype);
   }
 }
 
 export class NotImplementedError extends WebrpcError {
   constructor(
-    name: string = 'NotImplemented',
+    name: string = "NotImplemented",
     code: number = 9999,
     message: string = `Not Implemented`,
     status: number = 0,
     cause?: string
   ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, NotImplementedError.prototype)
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, NotImplementedError.prototype);
   }
 }
 
-
 export enum errors {
-  WebrpcEndpoint = 'WebrpcEndpoint',
-  WebrpcRequestFailed = 'WebrpcRequestFailed',
-  WebrpcBadRoute = 'WebrpcBadRoute',
-  WebrpcBadMethod = 'WebrpcBadMethod',
-  WebrpcBadRequest = 'WebrpcBadRequest',
-  WebrpcBadResponse = 'WebrpcBadResponse',
-  WebrpcServerPanic = 'WebrpcServerPanic',
-  WebrpcInternalError = 'WebrpcInternalError',
-  WebrpcClientDisconnected = 'WebrpcClientDisconnected',
-  WebrpcStreamLost = 'WebrpcStreamLost',
-  WebrpcStreamFinished = 'WebrpcStreamFinished',
-  Unauthorized = 'Unauthorized',
-  PermissionDenied = 'PermissionDenied',
-  SessionExpired = 'SessionExpired',
-  MethodNotFound = 'MethodNotFound',
-  Timeout = 'Timeout',
-  InvalidArgument = 'InvalidArgument',
-  NotFound = 'NotFound',
-  UserNotFound = 'UserNotFound',
-  ProjectNotFound = 'ProjectNotFound',
-  InvalidTier = 'InvalidTier',
-  ProjectLimitReached = 'ProjectLimitReached',
-  NotImplemented = 'NotImplemented',
+  WebrpcEndpoint = "WebrpcEndpoint",
+  WebrpcRequestFailed = "WebrpcRequestFailed",
+  WebrpcBadRoute = "WebrpcBadRoute",
+  WebrpcBadMethod = "WebrpcBadMethod",
+  WebrpcBadRequest = "WebrpcBadRequest",
+  WebrpcBadResponse = "WebrpcBadResponse",
+  WebrpcServerPanic = "WebrpcServerPanic",
+  WebrpcInternalError = "WebrpcInternalError",
+  WebrpcClientDisconnected = "WebrpcClientDisconnected",
+  WebrpcStreamLost = "WebrpcStreamLost",
+  WebrpcStreamFinished = "WebrpcStreamFinished",
+  Unauthorized = "Unauthorized",
+  PermissionDenied = "PermissionDenied",
+  SessionExpired = "SessionExpired",
+  MethodNotFound = "MethodNotFound",
+  Timeout = "Timeout",
+  InvalidArgument = "InvalidArgument",
+  NotFound = "NotFound",
+  UserNotFound = "UserNotFound",
+  ProjectNotFound = "ProjectNotFound",
+  InvalidTier = "InvalidTier",
+  ProjectLimitReached = "ProjectLimitReached",
+  NotImplemented = "NotImplemented",
 }
 
 export enum WebrpcErrorCodes {
@@ -2176,6 +2838,9 @@ export const webrpcErrorByCode: { [code: number]: any } = {
   [3003]: InvalidTierError,
   [3005]: ProjectLimitReachedError,
   [9999]: NotImplementedError,
-}
+};
 
-export type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>
+export type Fetch = (
+  input: RequestInfo,
+  init?: RequestInit
+) => Promise<Response>;