@alphafi/alphafi-sdk 0.0.12 → 0.0.13

package/dist/sui-sdk/events/fetchAutoCompoundingEvents.d.ts

@@ -0,0 +1,5 @@
+import { PoolName } from "../../common/types";
+import { AutoCompoundingEventNode, FetchAutoCompoundingEventsParams } from "./types";
+export declare function fetchAutoCompoundingEvents(params: FetchAutoCompoundingEventsParams): Promise<AutoCompoundingEventNode[]>;
+export declare function calculateAprForInvestor(events: AutoCompoundingEventNode[]): Promise<number>;
+export declare function calculateAprForPools(events: AutoCompoundingEventNode[]): Promise<Record<PoolName, number>>;

package/dist/sui-sdk/events/fetchEvents.d.ts

@@ -0,0 +1,2 @@
+import { EventNode, FetchEventsParams } from "./types";
+export declare function fetchEvents(params: FetchEventsParams): Promise<EventNode[]>;

package/dist/sui-sdk/events/fetchLiquidityChangeEvents.d.ts

@@ -0,0 +1,2 @@
+import { FetchLiquidityChangeEventsParams, LiquidityChangeEventNode } from "./types";
+export declare function fetchLiquidityChangeEvents(params: FetchLiquidityChangeEventsParams): Promise<LiquidityChangeEventNode[]>;

package/dist/sui-sdk/events/fetchRebalanceEvents.d.ts

@@ -0,0 +1,4 @@
+import { PoolName, RebalanceHistoryType } from "../../common/types";
+import { FetchRebalanceEventsParams, RebalanceEventNode } from "./types";
+export declare function fetchRebalanceEvents(params: FetchRebalanceEventsParams): Promise<RebalanceEventNode[]>;
+export declare function calculateRebalanceHistoryFromEvents(events: RebalanceEventNode[]): Promise<Record<PoolName, RebalanceHistoryType[]>>;

package/dist/sui-sdk/events/parseData.d.ts

@@ -0,0 +1,3 @@
+import { LiquidityChangeEventNode } from "./types";
+export declare function parseHoldersFromLCEvents(events: LiquidityChangeEventNode[]): string[];
+export declare function parseXTokensFromLCEvent(events: LiquidityChangeEventNode[]): [string, string, string][];

package/dist/sui-sdk/events/types.d.ts

@@ -0,0 +1,93 @@
+import { PoolName } from "../../common/types";
+interface CommonEventAttributes {
+    type: string;
+    timestamp: number;
+}
+export interface CetusAutoCompoundingEvent {
+    compound_amount_a: bigint;
+    compound_amount_b: bigint;
+    current_liquidity: bigint;
+    fee_collected_a: bigint;
+    fee_collected_b: bigint;
+    free_balance_a: bigint;
+    free_balance_b: bigint;
+    investor_id: string;
+    total_amount_a: bigint;
+    total_amount_b: bigint;
+}
+export interface NaviAutoCompoundingEvent {
+    compound_amount: bigint;
+    fee_collected: bigint;
+    investor_id: string;
+    location: number;
+    total_amount: bigint;
+}
+export interface NaviLoopAutoCompoundingEvent extends NaviAutoCompoundingEvent {
+    cur_total_debt: bigint;
+    accrued_interest: bigint;
+}
+export interface RebalanceEvent {
+    investor_id: string;
+    lower_tick_after: string;
+    upper_tick_after: string;
+    sqrt_price_after: string;
+    amount_a_before: string;
+    amount_b_before: string;
+    amount_a_after: string;
+    amount_b_after: string;
+}
+export interface AlphaAutoCompoundingEvent {
+    amount: string;
+    investor_id: string;
+}
+export interface CetusLiquidityChangeEvent {
+    amount_a: string;
+    amount_b: string;
+    event_type: number;
+    fee_collected_a: string;
+    fee_collected_b: string;
+    pool_id: string;
+    sender: string;
+    tokens_invested: string;
+    total_amount_a: string;
+    total_amount_b: string;
+    user_total_x_token_balance: string;
+    x_token_supply: string;
+}
+export interface NaviLiquidityChangeEvent {
+    amount: string;
+    event_type: number;
+    fee_collected: string;
+    pool_id: string;
+    sender: string;
+    tokens_invested: string;
+    user_total_x_token_balance: string;
+    x_token_supply: string;
+}
+export interface AlphaLiquidityChangeEvent {
+    amount: string;
+    event_type: number;
+    fee_collected: string;
+    pool_id: string;
+    sender: string;
+    tokens_invested: string;
+    user_total_x_token_balance: string;
+    x_token_supply: string;
+}
+export type AutoCompoundingEventNode = (CetusAutoCompoundingEvent & CommonEventAttributes) | (NaviAutoCompoundingEvent & CommonEventAttributes) | (NaviLoopAutoCompoundingEvent & CommonEventAttributes) | (AlphaAutoCompoundingEvent & CommonEventAttributes);
+export type RebalanceEventNode = RebalanceEvent & CommonEventAttributes;
+export type LiquidityChangeEventNode = (CetusLiquidityChangeEvent & CommonEventAttributes) | (NaviLiquidityChangeEvent & CommonEventAttributes) | (AlphaLiquidityChangeEvent & CommonEventAttributes);
+export type EventNode = AutoCompoundingEventNode | RebalanceEventNode | LiquidityChangeEventNode;
+export type FetchAutoCompoundingEventsParams = {
+    startTime?: number;
+    endTime?: number;
+    poolNames?: PoolName[];
+};
+export type FetchRebalanceEventsParams = FetchAutoCompoundingEventsParams;
+export type FetchLiquidityChangeEventsParams = FetchAutoCompoundingEventsParams;
+export type FetchEventsParams = {
+    eventTypes: string[];
+    startTime?: number;
+    endTime?: number;
+};
+export {};

package/dist/sui-sdk/functions/fetchTableData.d.ts

@@ -0,0 +1,49 @@
+export interface LockedAlphaObject {
+    name: {
+        type: string;
+        value: string;
+    };
+    bcsName: string;
+    type: string;
+    objectType: string;
+    objectId: string;
+    version: string;
+    digest: string;
+}
+export interface LockedAlphaItem {
+    objectId: string;
+    version: string;
+    digest: string;
+    type: string;
+    owner: {
+        ObjectOwner: string;
+    };
+    previousTransaction: string;
+    storageRebate: string;
+    content: {
+        dataType: string;
+        type: string;
+        hasPublicTransfer: boolean;
+        fields: {
+            id: {
+                id: string;
+            };
+            name: string;
+            value: {
+                type: string;
+                fields: {
+                    next: string;
+                    prev: string;
+                    value: string;
+                };
+            };
+        };
+    };
+}
+export type AlphaUnlocks = {
+    address: string;
+    tokens: string;
+    timestampMs: number;
+};
+export declare function getTableDataXtokens(owner: string, table: string): Promise<AlphaUnlocks[] | undefined>;
+export declare function getUnlocksData(owner_table: [string, string][]): Promise<AlphaUnlocks[]>;

package/dist/sui-sdk/functions/fetchUserVaultBalances.d.ts

@@ -0,0 +1,2 @@
+import { AlphaFiVaultBalance, PoolName } from "../../common/types";
+export declare function fetchUserVaultBalances(address: string, poolName: PoolName): Promise<AlphaFiVaultBalance | undefined>;

package/dist/sui-sdk/functions/fetchUserVaults.d.ts

@@ -0,0 +1,2 @@
+import { AlphaFiVault } from "../..";
+export declare function fetchUserVaults(address: string): Promise<AlphaFiVault[]>;

package/dist/sui-sdk/functions/getPortfolioAmounts.d.ts

@@ -0,0 +1,32 @@
+import { SuiClient } from "@mysten/sui/client";
+import { PoolName } from "../..";
+export declare function getAlphaPortfolioAmount(poolName: PoolName, options: {
+    suiClient: SuiClient;
+    address: string;
+    isLocked?: boolean;
+}): Promise<string | undefined>;
+export declare function getAlphaPortfolioAmountInUSD(poolName: PoolName, options: {
+    suiClient: SuiClient;
+    address: string;
+    isLocked?: boolean;
+}): Promise<string | undefined>;
+export declare function getPortfolioAmount(poolName: PoolName, options: {
+    suiClient: SuiClient;
+    address: string;
+    isLocked?: boolean;
+}, ignoreCache?: boolean): Promise<[number, number] | undefined>;
+export declare function getDoubleAssetPortfolioAmountInUSD(poolName: PoolName, options: {
+    suiClient: SuiClient;
+    address: string;
+    isLocked?: boolean;
+}, ignoreCache?: boolean): Promise<string | undefined>;
+export declare function getSingleAssetPortfolioAmount(poolName: PoolName, options: {
+    suiClient: SuiClient;
+    address: string;
+    isLocked?: boolean;
+}, ignoreCache?: boolean): Promise<number>;
+export declare function getSingleAssetPortfolioAmountInUSD(poolName: PoolName, options: {
+    suiClient: SuiClient;
+    address: string;
+    isLocked?: boolean;
+}, ignoreCache?: boolean): Promise<string | undefined>;

package/dist/sui-sdk/functions/getReceipts.d.ts

@@ -0,0 +1,8 @@
+import { AlphaPoolType, CetusInvestor, CetusPoolType, PoolName, PoolType, Receipt } from "../..";
+import Decimal from "decimal.js";
+export declare function getReceipts(poolName: string, address: string, ignoreCache?: boolean): Promise<Receipt[]>;
+export declare function getPoolExchangeRate(poolName: PoolName, ignoreCache?: boolean): Promise<Decimal | undefined>;
+export declare function getCoinAmountsFromLiquidity(poolName: PoolName, liquidity: number): Promise<[number, number]>;
+export declare function getPool(poolName: string, ignoreCache?: boolean): Promise<PoolType | AlphaPoolType | undefined>;
+export declare function getCetusPool(poolName: string, ignoreCache?: boolean): Promise<CetusPoolType | undefined>;
+export declare function getCetusInvestor(poolName: PoolName, ignoreCache?: boolean): Promise<CetusInvestor | undefined>;

package/dist/sui-sdk/transactions/constants.d.ts

@@ -0,0 +1,3 @@
+import { TransactionFilter } from "@mysten/sui/dist/cjs/client";
+export declare const nonAlphaDepositFilters: TransactionFilter[];
+export declare const alphaDepositFilters: TransactionFilter[];

package/dist/sui-sdk/transactions/fetchTransactions.d.ts

@@ -0,0 +1,3 @@
+import { SuiTransactionBlockResponse } from "@mysten/sui/client";
+import { FetchTransactionParams } from "./types";
+export declare function fetchTransactions(params: FetchTransactionParams): Promise<SuiTransactionBlockResponse[]>;

package/dist/sui-sdk/transactions/types.d.ts

@@ -0,0 +1,7 @@
+import { TransactionFilter } from "@mysten/sui/client";
+export type FetchTransactionParams = {
+    startTime: number;
+    endTime: number;
+    filter: TransactionFilter[];
+    sort: "ascending" | "descending";
+};

package/dist/types.d.ts

@@ -0,0 +1,212 @@
+import { CoinName, DoubleAssetPoolNames, PoolName, SingleAssetPoolNames, AlphaFiVaultBalance } from "./common/types";
+export type GetUserTokensFromTransactionsParams = {
+    poolNames?: string[];
+    startTime?: number;
+    endTime?: number;
+    owners?: string[];
+};
+export type GetUserTokensInUsdFromTransactionsParams = {
+    poolNames?: string[];
+    startTime?: number;
+    endTime?: number;
+    owners?: string[];
+    userTokensHoldings?: [string, string, string][];
+};
+export type AlphaReceiptFields = {
+    id: {
+        id: string;
+    };
+    image_url: string;
+    last_acc_reward_per_xtoken: {
+        type: string;
+        fields: {
+            contents: [
+                {
+                    type: string;
+                    fields: {
+                        key: {
+                            type: string;
+                            fields: {
+                                name: string;
+                            };
+                        };
+                        value: string;
+                    };
+                }
+            ];
+        };
+    };
+    locked_balance: {
+        type: string;
+        fields: {
+            head: string;
+            id: {
+                id: string;
+            };
+            size: string;
+            tail: string;
+        };
+    };
+    name: string;
+    owner: string;
+    pending_rewards: {
+        type: string;
+        fields: {
+            contents: [
+                {
+                    type: string;
+                    fields: {
+                        key: {
+                            type: string;
+                            fields: {
+                                name: string;
+                            };
+                        };
+                        value: string;
+                    };
+                }
+            ];
+        };
+    };
+    pool_id: string;
+    unlocked_xtokens: string;
+    xTokenBalance: string;
+};
+export type OtherReceiptFields = {
+    id: {
+        id: string;
+    };
+    image_url: string;
+    last_acc_reward_per_xtoken: {
+        fields: {
+            contents: [
+                {
+                    fields: {
+                        key: {
+                            fields: {
+                                name: string;
+                            };
+                            type: string;
+                        };
+                        value: string;
+                    };
+                    type: string;
+                }
+            ];
+        };
+        type: string;
+    };
+    name: string;
+    owner: string;
+    pending_rewards: {
+        fields: {
+            contents: [
+                {
+                    fields: {
+                        key: {
+                            fields: {
+                                name: string;
+                            };
+                            type: string;
+                        };
+                        value: string;
+                    };
+                    type: string;
+                }
+            ];
+        };
+        type: string;
+    };
+    pool_id: string;
+    xTokenBalance: string;
+};
+export type GetHoldersParams = {
+    poolNames?: string[];
+    startTime?: number;
+    endTime?: number;
+};
+export type GetTokenHoldingsParams = {
+    poolNames?: PoolName[];
+    startTime?: number;
+    endTime?: number;
+};
+export type LiquidityToUsdParams = {
+    liquidity: string;
+    poolName: string;
+    ticksCetusMap: {
+        [pool: string]: {
+            lower: string;
+            upper: string;
+        };
+    };
+    sqrtPriceCetusMap: Map<PoolName, string>;
+    tokenPriceMap: Map<CoinName, string>;
+};
+export type LiquidityToTokensParams = {
+    liquidity: string;
+    poolName: string;
+    ticksCetusMap: {
+        [pool: string]: {
+            lower: string;
+            upper: string;
+        };
+    };
+    sqrtPriceCetusMap: Map<PoolName, string>;
+};
+export type UserUsdHoldings = {
+    user: string;
+    poolName: PoolName;
+    usdHoldings: string;
+};
+export type UserPoolLiquidity = {
+    user: string;
+    poolName: string;
+    liquidity: string;
+};
+export type UserPoolTokenHoldings = SingleAssetTokenHoldings | DoubleAssetTokenHoldings;
+export type SingleAssetTokenHoldings = {
+    user: string;
+    poolName: SingleAssetPoolNames;
+    tokens: string;
+};
+export type DoubleAssetTokenHoldings = {
+    user: string;
+    poolName: DoubleAssetPoolNames;
+    tokenAmountA: string;
+    tokenAmountB: string;
+};
+export type MultiGetVaultBalancesParams = {
+    poolNames?: PoolName[];
+    startTime?: number;
+    endTime?: number;
+};
+export type SingleGetVaultBalancesParams = {
+    address?: string;
+    poolName?: PoolName;
+};
+export type GetVaultBalanceParams = SingleGetVaultBalancesParams | MultiGetVaultBalancesParams;
+export type HoldingsObj = {
+    owner: string;
+    poolName: PoolName;
+    holding: string;
+};
+export type VaultBalance = AlphaFiVaultBalance | undefined | AlphaFiMultiVaultBalance[];
+export type AlphaFiMultiVaultBalance = SingleAssetMultiVaultBalance | DoubleAssetMultiVaultBalance;
+export type SingleAssetMultiVaultBalance = {
+    owner: string;
+    poolName: PoolName;
+    tokens: string;
+    tokensInUsd: string;
+};
+export type DoubleAssetMultiVaultBalance = {
+    owner: string;
+    poolName: PoolName;
+    tokenA: string;
+    tokenB: string;
+    tokensInUsd: string;
+};
+export type GetVaultBalanceForActiveUsersParams = {
+    poolNames?: PoolName[];
+    startTime?: number;
+    endTime?: number;
+};

package/dist/utils/clmm/prices.d.ts

@@ -0,0 +1,19 @@
+import { SdkOptions, Pool, CalculateRatesResult } from "@cetusprotocol/cetus-sui-clmm-sdk";
+import { Transaction } from "@mysten/sui/transactions";
+import { Coin } from "../../common/types";
+import { CetusSwapOptions, CreatePoolOptions } from "./types";
+export declare function getAlphaPrice(ignoreCache?: boolean): Promise<number | undefined>;
+export declare function getUSDYPrice(): Promise<number | undefined>;
+export declare function getBUCKPrice(): Promise<number | undefined>;
+export declare function getPriceFromCetus(coinType: string): Promise<string>;
+export declare class CetusGateway {
+    private cetusSDK;
+    constructor(sdkOptions: SdkOptions);
+    getPools(pairs: {
+        coinA?: Coin;
+        coinB?: Coin;
+    }[]): Promise<Pool[]>;
+    getPrice(options: CetusSwapOptions): Promise<CalculateRatesResult>;
+    getTransaction(options: CetusSwapOptions): Promise<Transaction>;
+    createPoolTransactionBlock(options: CreatePoolOptions): Promise<Transaction>;
+}

package/dist/utils/clmm/tokenAmountFromLiquidity.d.ts

@@ -0,0 +1,10 @@
+import BigNumber from "bignumber.js";
+import BN from "bn.js";
+export declare function signedShiftRight(n0: BN, shiftBy: number, bitWidth: number): BN;
+export declare function tickIndexToSqrtPricePositive(tick: number): BigNumber;
+export declare function tickIndexToSqrtPriceNegative(tickIndex: number): BigNumber;
+export declare function tickIndexToSqrtPriceX64(tickIndex: number): BigNumber;
+export declare function getTokenAmountsFromLiquidity(liquidity: BigNumber, tickCurrentIndex: number, tickLowerIndex: number, tickUpperIndex: number, roundUp: boolean): {
+    tokenAmountA: BigNumber;
+    tokenAmountB: BigNumber;
+};

package/dist/utils/clmm/types.d.ts

@@ -0,0 +1,24 @@
+import { CoinName, CoinPair } from "../../common/types";
+import BN from "bn.js";
+export type CetusSwapOptions = SwapOptions;
+export type TickSpacing = 2 | 10 | 60 | 200;
+export type CreatePoolOptions = {
+    tickSpacing: TickSpacing;
+    initializePrice: number;
+    imageUrl: string;
+    coinNameA: CoinName;
+    coinNameB: CoinName;
+    amount: number;
+    isAmountA: boolean;
+};
+export type SwapOptions = {
+    pair: CoinPair;
+    senderAddress: string;
+    slippage: number;
+} & ({
+    inAmount: BN;
+    outAmount?: never;
+} | {
+    outAmount: BN;
+    inAmount?: never;
+});

package/dist/utils/constants.d.ts

@@ -0,0 +1,2 @@
+import { PythPriceFeed } from "../common/pyth";
+export declare const pythPriceFeed: PythPriceFeed;

package/dist/utils/getHoldersFromTransactionsUtils.d.ts

@@ -0,0 +1,5 @@
+import { SuiObjectResponse } from "@mysten/sui/dist/cjs/client";
+import { LiquidityToUsdParams } from "../types";
+export declare function parseTokensFromReceipts(receipts: SuiObjectResponse[]): Promise<[string, string, string][]>;
+export declare function liquidityToUsd(params: LiquidityToUsdParams): string | undefined;
+export declare function mergeDuplicateHoldings(userTokens: [string, string, string][]): [string, string, string][];

package/dist/utils/getReceipts.d.ts

@@ -0,0 +1,3 @@
+import { SuiObjectResponse } from "@mysten/sui/client";
+import { GetReceiptParams } from "./types";
+export declare function getReceipts(params: GetReceiptParams): Promise<SuiObjectResponse[]>;

package/dist/utils/hop.d.ts

@@ -0,0 +1,15 @@
+import { HopApiOptions } from "@hop.ag/sdk";
+import { GetQuoteResponse } from "@hop.ag/sdk/dist/cjs/sdk/routes/quote";
+import { SwapOptions } from "../common/types";
+import { Transaction } from "@mysten/sui/transactions";
+export type HopSwapOptions = SwapOptions;
+export declare const hopSDKOptions: HopApiOptions;
+export declare class HopGateway {
+    private hopAPI;
+    constructor(sdkOptions: HopApiOptions);
+    getQuote(options: HopSwapOptions, debug?: boolean): Promise<GetQuoteResponse>;
+    getTransactionBlock(options: HopSwapOptions, quote: GetQuoteResponse, debug?: boolean, transaction?: Transaction | undefined): Promise<Transaction>;
+}
+export declare function getBlubPrice(): Promise<number | undefined>;
+export declare function getFudPrice(): Promise<number | undefined>;
+export declare function getWsolPrice(): Promise<number | undefined>;

package/dist/utils/prices.d.ts

@@ -0,0 +1,6 @@
+import { PythPriceIdPair } from "../common/pyth";
+export declare function getLatestPrices(pairs: PythPriceIdPair[]): Promise<(string | undefined)[]>;
+export declare function getLatestTokenPricePairs(pairs: PythPriceIdPair[]): Promise<{
+    [key: string]: string | undefined;
+}>;
+export declare function getLatestPrice(pair: PythPriceIdPair): Promise<string | undefined>;

package/dist/utils/simpleCache.d.ts

@@ -0,0 +1,9 @@
+export declare class SimpleCache<T> {
+    private cache;
+    private defaultTTL;
+    constructor(defaultTTL?: number);
+    get(key: string): T | null;
+    set(key: string, value: T, ttl?: number): void;
+    delete(key: string): void;
+    clear(): void;
+}

package/dist/utils/types.d.ts

@@ -0,0 +1,4 @@
+export type GetReceiptParams = {
+    poolNames?: string[];
+    owners: string[];
+};

package/dist/utils/userHoldings.d.ts

@@ -0,0 +1,5 @@
+import { DoubleAssetTokenHoldings, HoldingsObj, SingleAssetTokenHoldings, LiquidityToTokensParams } from "../types";
+export declare function multiXTokensToLiquidity(xTokensHoldings: HoldingsObj[]): Promise<HoldingsObj[]>;
+export declare function multiLiquidityToTokens(holdings: HoldingsObj[]): Promise<(SingleAssetTokenHoldings | DoubleAssetTokenHoldings)[]>;
+export declare function liquidityToTokens(params: LiquidityToTokensParams): string | [string, string];
+export declare function multiTokensToUsd(tokensHoldings: (SingleAssetTokenHoldings | DoubleAssetTokenHoldings)[]): Promise<HoldingsObj[]>;

package/dist/vaultFunctions.d.ts

@@ -0,0 +1,4 @@
+import { LpBreakdownType, PoolName } from "./common/types";
+export declare function alphaLpBreakdown(poolName: PoolName): Promise<LpBreakdownType>;
+export declare function cetusLpBreakdown(poolName: PoolName): Promise<LpBreakdownType>;
+export declare function lastAutocompoundTime(poolName: PoolName): Promise<string>;

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@alphafi/alphafi-sdk",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "AlphaFi SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
   "scripts": {
     "buildNoPrettier": "npm run lint && webpack && npm link",
     "build": "npm run prettier && npm run lint && webpack && npm link",

package/.envrc

@@ -1 +0,0 @@
-export AWS_PROFILE=alphafi-mgmt-admin

package/.eslintrc.json

@@ -1,21 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "extends": [
-    "plugin:@typescript-eslint/recommended",
-    "plugin:import/errors",
-    "plugin:import/warnings",
-    "plugin:import/typescript",
-    "plugin:prettier/recommended" // Adds Prettier plugin recommendations at the end
-  ],
-  "parserOptions": {
-    "ecmaVersion": 2020,
-    "sourceType": "module"
-  },
-  "rules": {
-    "@typescript-eslint/no-explicit-any": "off",
-    "prettier/prettier": "error" // Ensures that Prettier mismatches are shown as errors
-  },
-  "plugins": [
-    "prettier" // Ensure this plugin is installed and included
-  ]
-}

package/.github/workflows/static.yml

@@ -1,51 +0,0 @@
-# Simple workflow for deploying docs to GitHub Pages
-name: Deploy Documentation to GitHub Pages
-
-on:
-  # Runs on pushes targeting the default branch
-  push:
-    branches: ["main"]
-
-  # Allows you to run this workflow manually from the Actions tab
-  workflow_dispatch:
-
-# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
-# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
-concurrency:
-  group: "pages"
-  cancel-in-progress: false
-
-jobs:
-  # Single deploy job since we're just deploying
-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - name: Install dependencies
-        run: npm install
-      - name: Generate Documentation
-        run: npm run docs
-      - name: Setup Pages
-        uses: actions/configure-pages@v5
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          # Upload entire repository
-          path: "./docs"
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4