triangle-utils 1.3.4 → 1.4.1

package/dist/src/UtilsBedrock.d.ts

@@ -0,0 +1,8 @@
+export declare class UtilsBedrock {
+    private readonly bedrock;
+    private readonly text_decoder;
+    constructor(region: string);
+    llama_invoke(model_id: string, prompt: string, temperature?: number, max_gen_len?: number, top_p?: number): Promise<string | undefined>;
+    gpt_converse(model_id: string, prompt: string, temperature?: number, max_gen_len?: number, top_p?: number): Promise<string | undefined>;
+    titan_invoke(text: string): Promise<number[] | undefined>;
+}

package/dist/src/{Utils_Bedrock.js → UtilsBedrock.js}

@@ -1,9 +1,9 @@
 import { BedrockRuntime } from "@aws-sdk/client-bedrock-runtime";
-export class Utils_Bedrock {
+export class UtilsBedrock {
     bedrock;
     text_decoder;
-    constructor(config) {
-        this.bedrock = new BedrockRuntime({ region: config.region });
+    constructor(region) {
+        this.bedrock = new BedrockRuntime({ region: region });
         this.text_decoder = new TextDecoder();
     }
     async llama_invoke(model_id, prompt, temperature = 0.5, max_gen_len = 512, top_p = 0.9) {
@@ -74,7 +74,10 @@ export class Utils_Bedrock {
                     contentType: "application/json"
                 });
                 const response = JSON.parse(this.text_decoder.decode(output.body));
-                return response.embedding;
+                if (response.embedding !== undefined && Array.isArray(response.embedding) && response.embedding.every((i) => typeof i === "number")) {
+                    const embedding = response.embedding;
+                    return embedding;
+                }
             }
             catch (error) {
                 if (error instanceof Error) {

package/dist/src/UtilsBee.d.ts

@@ -0,0 +1,8 @@
+export declare class UtilsBee {
+    private readonly bee;
+    private readonly text_decoder;
+    constructor(scraping_bee_api_key: string | undefined);
+    get(url: string, params?: Record<string, string | number | boolean>): Promise<string | undefined>;
+    google_search(query: string, news?: boolean): Promise<Record<string, any>[] | undefined>;
+    youtube_search(query: string, options?: {}): Promise<Record<string, any>[] | undefined>;
+}

package/dist/src/{Utils_Bee.js → UtilsBee.js}

@@ -1,11 +1,9 @@
 import { ScrapingBeeClient } from "scrapingbee";
-export class Utils_Bee {
-    config;
+export class UtilsBee {
     bee;
     text_decoder;
-    constructor(config) {
-        this.config = config;
-        this.bee = config.scraping_bee_api_key !== undefined ? new ScrapingBeeClient(config.scraping_bee_api_key) : undefined;
+    constructor(scraping_bee_api_key) {
+        this.bee = scraping_bee_api_key !== undefined ? new ScrapingBeeClient(scraping_bee_api_key) : undefined;
         this.text_decoder = new TextDecoder();
     }
     async get(url, params = {}) {
@@ -14,7 +12,7 @@ export class Utils_Bee {
         }
         for (let i = 0; i < 3; i++) {
             try {
-                const response = await this.bee.get({
+                const response = await this.bee.htmlApi({
                     url: url,
                     params: params
                 });
@@ -51,12 +49,19 @@ export class Utils_Bee {
                     console.log("Failed to Google:", response.status);
                     continue;
                 }
-                const data = response.data;
+                const data = JSON.parse(response.data.toString("utf-8"));
+                if (data.news_results === undefined || data.organic_results === undefined) {
+                    continue;
+                }
                 const results = news ? data.news_results : data.organic_results;
                 if (results === undefined) {
                     console.log("Failed to Google.");
                     continue;
                 }
+                if (!Array.isArray(results)) {
+                    console.log("Results are not an array.");
+                    return;
+                }
                 return results;
             }
             catch {
@@ -80,7 +85,7 @@ export class Utils_Bee {
                     console.log("Failed to YouTube Search:", response.status);
                     continue;
                 }
-                const data = response.data;
+                const data = JSON.parse(response.data.toString("utf-8"));
                 const results = data.results;
                 if (results === undefined) {
                     console.log("Failed to YouTube Search.");

package/dist/src/UtilsCognito.d.ts

@@ -0,0 +1,12 @@
+export declare class UtilsCognito {
+    private readonly cognito;
+    constructor(region: string);
+    admin_get_user(user_pool_id: string, username: string): Promise<import("@aws-sdk/client-cognito-identity-provider").AdminGetUserCommandOutput | undefined>;
+    admin_create_user(user_pool_id: string, username: string, user_id: string): Promise<Error | import("@aws-sdk/client-cognito-identity-provider").AdminCreateUserCommandOutput>;
+    admin_reset_password(user_pool_id: string, username: string): Promise<Error | import("@aws-sdk/client-cognito-identity-provider").AdminCreateUserCommandOutput>;
+    get_user_id(token: string): Promise<string | undefined>;
+    get_new_token(client_id: string, client_secret: string, refresh_token: string): Promise<string | undefined>;
+    sign_out(token: string): Promise<void>;
+    admin_disable_user(user_pool_id: string, username: string): Promise<void>;
+    admin_delete_user(user_pool_id: string, username: string): Promise<void>;
+}

package/dist/src/UtilsCognito.js

@@ -0,0 +1,110 @@
+import { CognitoIdentityProvider, NotAuthorizedException } from "@aws-sdk/client-cognito-identity-provider";
+export class UtilsCognito {
+    cognito;
+    constructor(region) {
+        this.cognito = new CognitoIdentityProvider({ region: region });
+    }
+    async admin_get_user(user_pool_id, username) {
+        try {
+            return await this.cognito.adminGetUser({
+                UserPoolId: user_pool_id,
+                Username: username
+            });
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    async admin_create_user(user_pool_id, username, user_id) {
+        try {
+            return await this.cognito.adminCreateUser({
+                UserPoolId: user_pool_id,
+                Username: username,
+                UserAttributes: [
+                    { Name: "preferred_username", Value: user_id },
+                    { Name: "email_verified", Value: "true" }
+                ]
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                return new Error(error.toString().replace("Exception: ", ""));
+            }
+            return new Error();
+        }
+    }
+    async admin_reset_password(user_pool_id, username) {
+        const user = await this.admin_get_user(user_pool_id, username);
+        if (user === undefined) {
+            return new Error("User does not exist.");
+        }
+        try {
+            return await this.cognito.adminCreateUser({
+                UserPoolId: user_pool_id,
+                Username: username,
+                MessageAction: "RESEND"
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                return new Error(error.toString().replace("Exception: ", ""));
+            }
+            return new Error();
+        }
+    }
+    async get_user_id(token) {
+        try {
+            const user_info = await this.cognito.getUser({
+                AccessToken: token
+            });
+            const user_attributes = user_info.UserAttributes;
+            if (user_attributes === undefined) {
+                return undefined;
+            }
+            const user_attribute = user_attributes.filter(attribute => attribute.Name === "preferred_username")[0];
+            const user_id = user_attribute.Value;
+            return user_id;
+        }
+        catch (error) {
+            if (error instanceof NotAuthorizedException) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    async get_new_token(client_id, client_secret, refresh_token) {
+        try {
+            const response = await this.cognito.getTokensFromRefreshToken({
+                ClientId: client_id,
+                ClientSecret: client_secret,
+                RefreshToken: refresh_token
+            });
+            const new_auth_result = response.AuthenticationResult;
+            if (new_auth_result === undefined) {
+                return undefined;
+            }
+            const new_token = new_auth_result.AccessToken;
+            return new_token;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    async sign_out(token) {
+        await this.cognito.globalSignOut({
+            AccessToken: token
+        });
+    }
+    async admin_disable_user(user_pool_id, username) {
+        await this.cognito.adminDisableUser({
+            UserPoolId: user_pool_id,
+            Username: username,
+        });
+    }
+    async admin_delete_user(user_pool_id, username) {
+        await this.cognito.adminDeleteUser({
+            UserPoolId: user_pool_id,
+            Username: username,
+        });
+    }
+}

package/dist/src/{Utils_DynamoDB.d.ts → UtilsDynamoDB.d.ts}

@@ -1,8 +1,6 @@
-import { DynamoDB } from "@aws-sdk/client-dynamodb";
-import { Config } from "./types/Config.js";
-export declare class Utils_DynamoDB {
-    readonly dynamodb: DynamoDB;
-    constructor(config: Config);
+export declare class UtilsDynamoDB {
+    private readonly dynamodb;
+    constructor(region: string);
     scan(table: string, options?: {
         filters?: Record<string, any>;
         undefined_attribute_names?: string[];
@@ -19,8 +17,8 @@ export declare class Utils_DynamoDB {
     query_prefix(table: string, primary_key: Record<string, any>, secondary_key_prefix: Record<string, string>, options?: {
         reverse?: boolean;
         compile?: boolean;
-    }): Promise<Record<string, any>[] | undefined>;
-    query_range(table: string, primary_key: Record<string, any>, secondary_key_range: Record<string, string | number[]>, options?: {
+    }): Promise<Record<string, any>[]>;
+    query_range(table: string, primary_key: Record<string, any>, secondary_key_range: Record<string, (string | number)[]>, options?: {
         reverse?: boolean;
         compile?: boolean;
     }): Promise<Record<string, any>[]>;
@@ -28,7 +26,7 @@ export declare class Utils_DynamoDB {
     append(table: string, key: Record<string, any>, attributes: Record<string, any[]>): Promise<void>;
     add(table: string, key: Record<string, any>, attributes: Record<string, any[]>): Promise<void>;
     remove(table: string, key: Record<string, any>, attributes: string[]): Promise<void>;
-    create(table: string, key: Record<string, any>, attributes?: Record<string, any[]>): Promise<void>;
+    create(table: string, key: Record<string, any>, attributes?: Record<string, any>): Promise<void>;
     delete(table: string, key: Record<string, any>): Promise<void>;
     duplicate_attribute(table: string, attribute_name: string, new_attribute_name: string): Promise<void>;
     remove_attribute(table: string, attribute_name: string): Promise<void>;

package/dist/src/{Utils_DynamoDB.js → UtilsDynamoDB.js}

@@ -1,22 +1,22 @@
 import { DynamoDB } from "@aws-sdk/client-dynamodb";
-function convert_output(dynamoobject) {
-    if (dynamoobject.S !== undefined) {
-        return dynamoobject.S;
+function convert_output(dynamodb_output) {
+    if (dynamodb_output.S !== undefined) {
+        return dynamodb_output.S;
     }
-    else if (dynamoobject.N !== undefined) {
-        return Number(dynamoobject.N);
+    else if (dynamodb_output.N !== undefined) {
+        return Number(dynamodb_output.N);
     }
-    else if (dynamoobject.L !== undefined) {
-        return dynamoobject.L.map((a) => convert_output(a));
+    else if (dynamodb_output.L !== undefined) {
+        return dynamodb_output.L.map((a) => convert_output(a));
     }
-    else if (dynamoobject.SS !== undefined) {
-        return new Set(dynamoobject.SS);
+    else if (dynamodb_output.SS !== undefined) {
+        return new Set(dynamodb_output.SS);
     }
-    else if (dynamoobject.M !== undefined) {
-        return Object.fromEntries(Object.entries(dynamoobject.M).map(([key, value]) => [key, convert_output(value)]));
+    else if (dynamodb_output.M !== undefined) {
+        return Object.fromEntries(Object.entries(dynamodb_output.M).map(([key, value]) => [key, convert_output(value)]));
     }
-    else if (dynamoobject.BOOL !== undefined) {
-        return dynamoobject.BOOL;
+    else if (dynamodb_output.BOOL !== undefined) {
+        return dynamodb_output.BOOL;
     }
     return undefined;
 }
@@ -82,10 +82,10 @@ async function compile_pages(request, f, compile = true) {
         last_eval_key = response.LastEvaluatedKey;
     }
 }
-export class Utils_DynamoDB {
+export class UtilsDynamoDB {
     dynamodb;
-    constructor(config) {
-        this.dynamodb = new DynamoDB({ region: config.region });
+    constructor(region) {
+        this.dynamodb = new DynamoDB({ region: region });
     }
     async scan(table, options = {}) {
         const filters = options.filters !== undefined ? options.filters : {};
@@ -201,12 +201,12 @@ export class Utils_DynamoDB {
         const reverse = options.reverse !== undefined ? options.reverse : false;
         const compile = options.compile !== undefined ? options.compile : true;
         if (Object.keys(primary_key).length !== 1 || Object.keys(secondary_key_prefix).length !== 1) {
-            return undefined;
+            return [];
         }
         const converted_primary_value = convert_input(Object.values(primary_key)[0]);
         const converted_secondary_prefix_value = convert_input(Object.values(secondary_key_prefix)[0]);
         if (converted_primary_value === undefined || converted_secondary_prefix_value === undefined) {
-            return undefined;
+            return [];
         }
         const request = {
             TableName: table,

package/dist/src/UtilsMisc.d.ts

@@ -0,0 +1,32 @@
+import * as nodemailer from "nodemailer";
+import { TriangleUtilsConfig } from "./types/TriangleUtilsConfig.js";
+interface Encryption {
+    iv: string;
+    ciphertext: string;
+}
+export declare class UtilsMisc {
+    readonly config: TriangleUtilsConfig;
+    readonly transporter: nodemailer.Transporter<import("nodemailer/lib/smtp-transport").SentMessageInfo, import("nodemailer/lib/smtp-transport").Options> | undefined;
+    constructor(config: TriangleUtilsConfig);
+    send_email(recipient: string, subject: string, text: string): Promise<boolean>;
+    admin_alert(text: string): Promise<boolean>;
+    safe_run(f: () => Promise<any>): Promise<void>;
+    iterate<T>(inputs: T[], f: (input: T) => Promise<any>, concurrency?: number, print_indices?: boolean): Promise<void>;
+    static wait(duration: number): Promise<unknown>;
+    static get_current_time(): string;
+    static get_current_milliseconds(): number;
+    static sha256(input: string): Promise<string>;
+    static encrypt(secret_key: string, text: string): Encryption;
+    static decrypt(secret_key: string, encryption: Encryption): string;
+    static get_secret_hash(username: string, cognito_client_id: string, cognito_client_secret: string): string;
+    static get_chunk_indices(text_length: number, max_length?: number, overlap?: number): [number, number][];
+    static chunkify(text: string, max_length?: number, overlap?: number): {
+        chunk_index: [number, number];
+        chunk_text: string;
+    }[];
+    static chunkify_lined(text: string, max_length?: number, overlap?: number): {
+        chunk_index: [number, number];
+        chunk_text: string;
+    }[];
+}
+export {};

package/dist/src/UtilsMisc.js

@@ -0,0 +1,156 @@
+import * as nodemailer from "nodemailer";
+import * as crypto from "crypto";
+export class UtilsMisc {
+    config;
+    transporter;
+    constructor(config) {
+        this.config = config;
+        if (config.google_email !== undefined && config.google_app_password !== undefined) {
+            this.transporter = nodemailer.createTransport({
+                service: "Gmail",
+                host: "smtp.gmail.com",
+                port: 465,
+                secure: true,
+                auth: {
+                    user: config.google_email,
+                    pass: config.google_app_password,
+                }
+            });
+        }
+    }
+    async send_email(recipient, subject, text) {
+        if (this.transporter === undefined) {
+            return false;
+        }
+        for (let i = 0; i < 3; i++) {
+            try {
+                await this.transporter.sendMail({
+                    from: this.config.alerts_email,
+                    to: recipient,
+                    subject: subject,
+                    text: text
+                });
+                return true;
+            }
+            catch (error) {
+                console.log("EMAIL ERROR", error);
+            }
+        }
+        return false;
+    }
+    async admin_alert(text) {
+        console.log("ADMIN ALERT:", text);
+        return await this.send_email(this.config.google_email, "ADMIN ALERT", text);
+    }
+    async safe_run(f) {
+        try {
+            await f();
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                return;
+            }
+            if (error.stack !== undefined) {
+                await this.admin_alert(error.stack.toString());
+            }
+            else {
+                await this.admin_alert(error.toString());
+            }
+        }
+    }
+    async iterate(inputs, f, concurrency = 1, print_indices = false) {
+        let index = 0;
+        let iterators = [];
+        for (let i = 0; i < concurrency; i++) {
+            iterators.push((async () => {
+                while (index < inputs.length) {
+                    index += 1;
+                    if (print_indices) {
+                        console.log(i + ":" + (index - 1) + "/" + inputs.length);
+                    }
+                    await this.safe_run(() => f(inputs[index - 1]));
+                }
+            })());
+        }
+        await Promise.all(iterators);
+    }
+    static async wait(duration) {
+        return new Promise(resolve => setTimeout(resolve, duration));
+    }
+    static get_current_time() {
+        return (new Date()).toISOString();
+    }
+    static get_current_milliseconds() {
+        return (new Date()).getTime();
+    }
+    static async sha256(input) {
+        const text_encoder = new TextEncoder();
+        const input_buffer = text_encoder.encode(input);
+        const hash_buffer = await crypto.subtle.digest("SHA-256", input_buffer);
+        const hash_array = Array.from(new Uint8Array(hash_buffer));
+        const hash = hash_array.map(b => b.toString(16).padStart(2, "0")).join("");
+        return hash;
+    }
+    static encrypt(secret_key, text) {
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv("aes-256-cbc", Buffer.from(secret_key, "hex"), iv);
+        let ciphertext = cipher.update(text, "utf8", "hex");
+        ciphertext += cipher.final("hex");
+        return {
+            iv: iv.toString("hex"),
+            ciphertext: ciphertext
+        };
+    }
+    static decrypt(secret_key, encryption) {
+        const iv = encryption.iv;
+        const ciphertext = encryption.ciphertext;
+        const decipher = crypto.createDecipheriv("aes-256-cbc", Buffer.from(secret_key, "hex"), Buffer.from(iv, "hex"));
+        let text = decipher.update(ciphertext, "hex", "utf8");
+        text += decipher.final("utf8");
+        return text;
+    }
+    static get_secret_hash(username, cognito_client_id, cognito_client_secret) {
+        const secret_hash = crypto.createHmac("sha256", cognito_client_secret)
+            .update(username + cognito_client_id)
+            .digest("base64");
+        return secret_hash;
+    }
+    static get_chunk_indices(text_length, max_length = 2500, overlap = 50) {
+        const num_chunks = Math.ceil((text_length + overlap) / max_length);
+        const chunk_length = Math.ceil((text_length - overlap) / num_chunks + overlap);
+        const chunk_indices = [];
+        for (let i = 0; i < num_chunks; i++) {
+            chunk_indices.push([
+                (chunk_length - overlap) * i,
+                (chunk_length - overlap) * i + chunk_length
+            ]);
+        }
+        return chunk_indices;
+    }
+    static chunkify(text, max_length = 2500, overlap = 50) {
+        const chunk_indices = this.get_chunk_indices(text.length, max_length, overlap);
+        const chunks = chunk_indices.map(chunk_index => ({
+            chunk_index: chunk_index,
+            chunk_text: text.substring(...chunk_index)
+        }));
+        return chunks;
+    }
+    static chunkify_lined(text, max_length = 2500, overlap = 50) {
+        const chunk_indices = this.get_chunk_indices(text.length, max_length, overlap);
+        const lined_chunk_indices = [];
+        for (const chunk_index of chunk_indices) {
+            const lined_chunk_index = [
+                text.lastIndexOf("\n", chunk_index[0]) + 1,
+                text.indexOf("\n", chunk_index[1]) + 1
+            ];
+            if (lined_chunk_index[1] < lined_chunk_index[0]) {
+                lined_chunk_index[1] += text.length;
+            }
+            lined_chunk_indices.push(lined_chunk_index);
+        }
+        return lined_chunk_indices.map(chunk_index => ({
+            chunk_index: chunk_index,
+            chunk_text: text.substring(...chunk_index)
+        }));
+    }
+}

package/dist/src/{Utils_S3.d.ts → UtilsS3.d.ts}

@@ -1,8 +1,6 @@
-import { S3 } from "@aws-sdk/client-s3";
-import { Config } from "./types/Config.js";
-export declare class Utils_S3 {
-    readonly s3: S3;
-    constructor(config: Config);
+export declare class UtilsS3 {
+    private readonly s3;
+    constructor(region: string);
     file_exists(s3_filename: string): Promise<boolean | undefined>;
     get_file(s3_filename: string): Promise<string | undefined>;
     create_file(s3_filename: string, content: string | Buffer, options?: {

package/dist/src/{Utils_S3.js → UtilsS3.js}

@@ -9,10 +9,10 @@ function parse_s3_filename(s3_filename) {
     const filename = bucket_filename.split("/").slice(1).join("/");
     return { Bucket: bucket, Key: filename };
 }
-export class Utils_S3 {
+export class UtilsS3 {
     s3;
-    constructor(config) {
-        this.s3 = new S3({ region: config.region });
+    constructor(region) {
+        this.s3 = new S3({ region: region });
     }
     async file_exists(s3_filename) {
         const s3_key = parse_s3_filename(s3_filename);

package/dist/src/{Utils_S3Vectors.d.ts → UtilsS3Vectors.d.ts}

@@ -1,13 +1,11 @@
-import { S3Vectors } from "@aws-sdk/client-s3vectors";
-import { Config } from "./types/Config.js";
-interface Vector {
+export interface Vector {
     key: string;
     data: number[];
     metadata: any;
 }
-export declare class Utils_S3Vectors {
-    readonly s3vectors: S3Vectors;
-    constructor(config: Config);
+export declare class UtilsS3Vectors {
+    private readonly s3vectors;
+    constructor(region: string);
     scan(vector_bucket: string, vector_index: string): Promise<string[]>;
     get(vector_bucket: string, vector_index: string, vector_key: string): Promise<Vector | undefined>;
     batch_get(vector_bucket: string, vector_index: string, vector_keys: string[]): Promise<(Vector | undefined)[]>;
@@ -15,6 +13,5 @@ export declare class Utils_S3Vectors {
     batch_create(vector_bucket: string, vector_index: string, vectors: Vector[]): Promise<void>;
     delete(vector_bucket: string, vector_index: string, vector_key: string): Promise<void>;
     batch_delete(vector_bucket: string, vector_index: string, vector_keys: string[]): Promise<void>;
-    query(vector_bucket: string, vector_index: string, data: number[], num_vectors: number, filters?: Record<string, any>): Promise<import("@aws-sdk/client-s3vectors").QueryOutputVector[] | undefined>;
+    query(vector_bucket: string, vector_index: string, data: number[], num_vectors: number, filters?: Record<string, any> | undefined): Promise<import("@aws-sdk/client-s3vectors").QueryOutputVector[] | undefined>;
 }
-export {};

package/dist/src/{Utils_S3Vectors.js → UtilsS3Vectors.js}

@@ -1,8 +1,8 @@
 import { S3Vectors } from "@aws-sdk/client-s3vectors";
-export class Utils_S3Vectors {
+export class UtilsS3Vectors {
     s3vectors;
-    constructor(config) {
-        this.s3vectors = new S3Vectors({ region: config.region });
+    constructor(region) {
+        this.s3vectors = new S3Vectors({ region: region });
     }
     async scan(vector_bucket, vector_index) {
         const vector_keys = [];
@@ -114,7 +114,7 @@ export class Utils_S3Vectors {
             });
         }
     }
-    async query(vector_bucket, vector_index, data, num_vectors, filters = {}) {
+    async query(vector_bucket, vector_index, data, num_vectors, filters = undefined) {
         const response = await this.s3vectors.queryVectors({
             vectorBucketName: vector_bucket,
             indexName: vector_index,

package/dist/src/UtilsYoutube.d.ts

@@ -0,0 +1,6 @@
+import { youtube_v3 } from "googleapis";
+export declare class UtilsYoutube {
+    readonly youtube: youtube_v3.Youtube | undefined;
+    constructor(youtube_api_key: string | undefined);
+    batch_get_videos(video_ids: string[], attributes?: string[]): Promise<youtube_v3.Schema$Video[] | undefined>;
+}

package/dist/src/{Utils_Youtube.js → UtilsYoutube.js}

@@ -1,14 +1,15 @@
 import { youtube_v3 } from "googleapis";
-export class Utils_Youtube {
-    config;
+export class UtilsYoutube {
     youtube;
-    constructor(config) {
-        this.config = config;
-        this.youtube = new youtube_v3.Youtube({
-            auth: config.youtube_api_key
-        });
+    constructor(youtube_api_key) {
+        this.youtube = youtube_api_key !== undefined ? new youtube_v3.Youtube({
+            auth: youtube_api_key
+        }) : undefined;
     }
     async batch_get_videos(video_ids, attributes = ["snippet", "contentDetails"]) {
+        if (this.youtube === undefined) {
+            return undefined;
+        }
         for (let i = 0; i < 3; i++) {
             try {
                 const response = await this.youtube.videos.list({

package/dist/src/index.d.ts

@@ -0,0 +1,28 @@
+import { TriangleUtilsConfig } from "./types/TriangleUtilsConfig.js";
+import { UtilsDynamoDB } from "./UtilsDynamoDB.js";
+import { UtilsS3 } from "./UtilsS3.js";
+import { UtilsBedrock } from "./UtilsBedrock.js";
+import { UtilsBee } from "./UtilsBee.js";
+import { UtilsS3Vectors } from "./UtilsS3Vectors.js";
+import { UtilsCognito } from "./UtilsCognito.js";
+import { UtilsMisc } from "./UtilsMisc.js";
+import { UtilsYoutube } from "./UtilsYoutube.js";
+export declare class TriangleUtils extends UtilsMisc {
+    readonly dynamodb: UtilsDynamoDB;
+    readonly s3: UtilsS3;
+    readonly s3vectors: UtilsS3Vectors;
+    readonly bedrock: UtilsBedrock;
+    readonly cognito: UtilsCognito;
+    readonly bee: UtilsBee;
+    readonly youtube: UtilsYoutube;
+    constructor(config: TriangleUtilsConfig);
+}
+export * from "./types/TriangleUtilsConfig.js";
+export * from "./UtilsMisc.js";
+export * from "./UtilsDynamoDB.js";
+export * from "./UtilsS3.js";
+export * from "./UtilsBedrock.js";
+export * from "./UtilsBee.js";
+export * from "./UtilsS3Vectors.js";
+export * from "./UtilsCognito.js";
+export * from "./UtilsYoutube.js";