@testgorilla/tgo-coding-test 2.0.0 → 2.0.1

package/lib/models/test-cases.d.ts

@@ -0,0 +1,67 @@
+export type CustomTestCase = {
+    localId?: number;
+    name: string;
+    input?: string;
+    expectedOutput: string;
+    preloaded: boolean;
+};
+export type ExampleTestCase = CustomTestCase & {
+    id: number;
+};
+export type TestCaseResult = {
+    actualOutput: string;
+    logs: string;
+    status: TestCaseStatus;
+};
+export type AllowedModificationFields = {
+    input: string;
+    expectedOutput: string;
+};
+export declare enum TestCaseStatus {
+    Passed = "passed",
+    Error = "error",
+    Empty = "empty"
+}
+export interface TestCaseDeletionData {
+    index: number;
+    action: TestCaseDeletionAction;
+}
+export declare const enum TestCaseDeletionAction {
+    Try = "try",
+    Confirm = "confirm"
+}
+export interface LATFormattedTestCases {
+    input: string;
+    solution: string;
+}
+export interface SqlTestCase {
+    id?: number;
+    name: string;
+    category: CategorySqlTestCaseEnum;
+    /** Expected test case result */
+    result?: string;
+    initial_sql?: string;
+    /** Previous sql query for checking */
+    pre_sql?: string;
+    /** Post sql query for checking */
+    post_sql?: string;
+}
+export interface Testcase {
+    id?: number;
+    name: string;
+    input?: string;
+    solution?: string;
+    points?: number;
+}
+export interface GroupedTestCasesResult {
+    custom: {
+        failed: number;
+        passed: number;
+    };
+    example: {
+        failed: number;
+        passed: number;
+    };
+}
+type CategorySqlTestCaseEnum = 'user' | 'validation';
+export {};

package/lib/models/theme.d.ts

@@ -0,0 +1,4 @@
+export declare const enum Themes {
+    Default = "theme-default",
+    Dark = "theme-dark"
+}

package/lib/models/translations.d.ts

@@ -0,0 +1 @@
+export declare const ROOT_TRANSLATIONS_SCOPE = "CODING_QUESTION";

package/lib/models/view-mode.d.ts

@@ -0,0 +1,6 @@
+export declare enum ViewMode {
+    Full = "full",
+    IDEOnly = "ide",
+    RunnableIde = "runnable-ide",
+    RunnableIdeWithLangSelector = "runnable-ide-w-lang-selector"
+}

package/{src/lib/pipes/memoize-func.pipe.ts → lib/pipes/memoize-func.pipe.d.ts}

@@ -1,5 +1,5 @@
-import { Pipe, PipeTransform } from '@angular/core';
-
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
 /**
  *   USAGE:
  *   {{ argument | memoizeFunc : method [: context] }}
@@ -19,16 +19,8 @@ import { Pipe, PipeTransform } from '@angular/core';
  *   {{ argument | memoizeFunc : method.bind(this) }}
  *
  * */
-@Pipe({
-  name: 'memoizeFunc',
-  standalone: true,
-})
-export class MemoizeFuncPipe implements PipeTransform {
-  transform<T, K>(value: T, handler: (value: T) => K, context?: any): K {
-    if (context) {
-      return handler.call(context, value);
-    }
-
-    return handler(value);
-  }
+export declare class MemoizeFuncPipe implements PipeTransform {
+    transform<T, K>(value: T, handler: (value: T) => K, context?: any): K;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MemoizeFuncPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MemoizeFuncPipe, "memoizeFunc", true>;
 }

package/lib/services/candidate-coding-test-services/candidature-api.service.d.ts

@@ -0,0 +1,10 @@
+import { ApiService } from '../../../shared/index';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class CandidatureApiService {
+    private apiService;
+    constructor(apiService: ApiService);
+    getAvailableLanguages$(): Observable<number[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CandidatureApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CandidatureApiService>;
+}

package/lib/services/candidate-coding-test-services/coderunner-api.service.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+import { LATFormattedTestCases, SqlTestCase } from '../../models/test-cases';
+import { CoderunnerAttemptModel } from '../../models/coderunner-execution-results';
+import { CodeEvent, CodeEventResponse } from '../../models/code-event';
+import * as i0 from "@angular/core";
+export declare class CoderunnerApiService {
+    private readonly snackbarService;
+    private readonly apiService;
+    private readonly configService;
+    private readonly CR2Url;
+    runPublicTest$(code: string, testcases: LATFormattedTestCases[] | SqlTestCase[], language: string): Observable<CoderunnerAttemptModel>;
+    runPreviewTest$(test_result_id: number, code: string, testcases: LATFormattedTestCases[] | SqlTestCase[], language: string): Observable<CoderunnerAttemptModel>;
+    runNonPreviewTest$(question_id: number, question_result_id: number, code: string, testcases: LATFormattedTestCases[] | SqlTestCase[], language: string): Observable<CoderunnerAttemptModel>;
+    sendCodeEvent$(event: CodeEvent): Observable<CodeEventResponse>;
+    private handleError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoderunnerApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CoderunnerApiService>;
+}

package/lib/services/candidate-coding-test-services/coding-test-tour.service.d.ts

@@ -0,0 +1,22 @@
+import { GuidedTourService } from 'ngx-guided-tour';
+import * as i0 from "@angular/core";
+export declare const enum CodingTestTourMode {
+    PracticeQuestion = "practice",
+    RealQuestion = "real"
+}
+export declare class CodingTestTourService {
+    private guidedTourService;
+    private readonly translationContext;
+    private readonly guidedTourId;
+    private readonly MINIMUM_SCREEN_SIZE;
+    private activeGuidedTourIdSub$;
+    activeGuidedTourId$: import("rxjs").Observable<string>;
+    constructor(guidedTourService: GuidedTourService);
+    init(mode: CodingTestTourMode): void;
+    skipTour(): void;
+    private start;
+    private publishActiveGuidedTourId;
+    private getTour;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CodingTestTourService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CodingTestTourService>;
+}

package/lib/services/candidate-coding-test-services/coding-test.service.d.ts

@@ -0,0 +1,68 @@
+import { ApplicationTheme, DialogService, SnackbarService } from '@testgorilla/tgo-ui';
+import { MixpanelService, TestResultRead } from '../../../shared/index';
+import { ExampleTestCase, TestCaseDeletionData } from '../../models/test-cases';
+import { LibCodingTestService, ResetCodeAction } from '../lib-coding-test.service';
+import { Observable } from 'rxjs';
+import { CodeEventResponse } from '../../models/code-event';
+import { CodingTestsResultsModel } from '../../models/coderunner-execution-results';
+import { ProgrammingLanguage } from '../../models/programming-language';
+import { SqlTestCase, Testcase } from '../../models/test-cases';
+import { CoderunnerApiService } from './coderunner-api.service';
+import * as i0 from "@angular/core";
+export declare class CodingTestService {
+    private coderunnerApiService;
+    private libCodingTestService;
+    private mixpanel;
+    private snackBar;
+    private dialog;
+    readonly translationContext = "CODING_QUESTION.CODING_LIB.";
+    private codingTestResults;
+    private currentLanguage;
+    private codingTestResutsSubj$;
+    codingTestResults$: Observable<CodingTestsResultsModel>;
+    isTestResultsLoading: import("@angular/core").WritableSignal<boolean>;
+    private unsubscribe$;
+    private sqlTestCases;
+    private isSQLTest;
+    constructor(coderunnerApiService: CoderunnerApiService, libCodingTestService: LibCodingTestService, mixpanel: MixpanelService, snackBar: SnackbarService, dialog: DialogService);
+    private getBaseExampleTestCase;
+    transformToExampleLATtestCase: (testcase: Testcase, index: number) => ExampleTestCase;
+    transformToExampleSQLTestCase: (testcase: SqlTestCase, index: number) => ExampleTestCase;
+    setSqlTestCases(sqlTestCases: SqlTestCase[]): void;
+    getSqlTestCases(): SqlTestCase[];
+    handleResetCodeModal(applicationTheme: ApplicationTheme, companyColor: string): void;
+    listenDeleteCustomTestCases(): Observable<TestCaseDeletionData>;
+    handleDeleteTestCaseModal(index: number, applicationTheme: ApplicationTheme, companyColor: string): void;
+    handleLanguageChangeModal(questionResultId: number, selectedLanguage?: ProgrammingLanguage, applicationTheme?: ApplicationTheme, companyColor?: string): void;
+    setCurrentLanguageLAT(language: ProgrammingLanguage): void;
+    listenCodingTestChanges(): Observable<ResetCodeAction>;
+    runTest(resultId: number, code: string, isLAT?: boolean, isSQL?: boolean, publicPreview?: boolean, preview?: boolean, id?: number, testResultId?: number, testData?: TestResultRead): void;
+    sendCopypasteEvent$(code: string, copiedText: string, questionResultId: number): Observable<CodeEventResponse>;
+    sendAutosaveEvent$(code: string, questionResultId: number): Observable<CodeEventResponse>;
+    private sendLanguageChangeEvent$;
+    private getBaseEvent;
+    private sendCodeEvent$;
+    private countTestResults;
+    private handleTestCasesResult;
+    private getSQLrequest;
+    private runSql;
+    private getLATrequest;
+    setIsSQLTest(isSQL: boolean): void;
+    private runLAT;
+    private finalizeReq;
+    private getNoOutputCopies;
+    private getSendCodeEventStream$;
+    unsubscribeAll(): void;
+    resetRunTestSummary(): void;
+    trackConfigChanged(isPracticeQuestion?: boolean): void;
+    private getCoderunnerLogs;
+    private trackTestcasesRun;
+    private preRunTests;
+    private getMixpanelTestCasesData;
+    private getGroupedTestCaseResult;
+    private getMixpanelSettingsData;
+    private getMixpanelInstanceValue;
+    private publishTestResults;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CodingTestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CodingTestService>;
+}

package/{src/lib/services/candidate-coding-test-services/index.ts → lib/services/candidate-coding-test-services/index.d.ts}

@@ -1,4 +1,4 @@
 export * from './coding-test.service';
 export * from './coding-test-tour.service';
 export * from './candidature-api.service';
-export * from './coderunner-api.service';
+export * from './coderunner-api.service';

package/lib/services/coding-test-config.service.d.ts

@@ -0,0 +1,38 @@
+import * as i0 from "@angular/core";
+/**
+ * Service for accessing TGO Coding Test library configuration.
+ *
+ * This service provides a clean abstraction layer over the configuration
+ * injection token, allowing services to access configuration values
+ * without directly injecting the token.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   private readonly configService = inject(CodingTestConfigService);
+ *
+ *   doSomething() {
+ *     const endpoint = this.configService.getCoderunnerV2Endpoint();
+ *     // Use endpoint...
+ *   }
+ * }
+ * ```
+ */
+export declare class CodingTestConfigService {
+    private readonly config;
+    /**
+     * Gets the main API endpoint URL.
+     *
+     * @returns The base URL for the main API endpoint
+     */
+    getApiUrl(): string;
+    /**
+     * Gets the CodeRunner V2 API endpoint URL.
+     *
+     * @returns The base URL for the CodeRunner V2 API endpoint
+     */
+    getCoderunnerV2Endpoint(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CodingTestConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CodingTestConfigService>;
+}

package/lib/services/configurations.service.d.ts

@@ -0,0 +1,37 @@
+import { Observable } from 'rxjs';
+import { Config } from '../models/configs';
+import { Themes } from '../models/theme';
+import * as i0 from "@angular/core";
+export declare class ConfigurationsService {
+    private defaultConfigs;
+    private formattingOptions;
+    private codingAssistanceOptions;
+    private configSubj$;
+    config$: Observable<Config>;
+    private configFieldChangedSubj$;
+    configFieldChanged$: Observable<Partial<Config>>;
+    private currentConfig;
+    colorTheme$: Observable<Themes>;
+    private codeComponentDestroyed;
+    private configurationsPanelOpenSubj$;
+    configurationsPanelOpen$: Observable<boolean>;
+    setColorTheme(value: Themes): void;
+    setConfig(config: Config): void;
+    trackConfigChanged(changedField: Partial<Config>): void;
+    getInitialConfig(): Config;
+    openConfigPanel(): void;
+    closeConfigPanel(): void;
+    getFormattingOptions(): {
+        [key: string]: {
+            label: string;
+            value: Themes | number;
+        }[];
+    };
+    getCodingAssistanceOptions(): {
+        [key: string]: boolean;
+    };
+    getCodeComponentDestroyed(): boolean;
+    setCodeComponentDestroyed(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationsService>;
+}

package/lib/services/lib-coding-test.service.d.ts

@@ -0,0 +1,69 @@
+import { Observable } from 'rxjs';
+import { CodeEditorLanguages } from '../components/code-editor/helpers/code-editor-helper.model';
+import { LanguageChangeAction } from '../models/language-change-action';
+import { CustomTestCase, ExampleTestCase, TestCaseDeletionData } from '../models/test-cases';
+import { Themes } from '../models/theme';
+import * as i0 from "@angular/core";
+export declare const enum ResetCodeAction {
+    Try = "try",
+    Confirm = "confirm"
+}
+declare global {
+    interface Window {
+        monaco: any;
+        hljs: any;
+    }
+}
+export declare class LibCodingTestService {
+    private readonly configurationsService;
+    private codeResetSubj$;
+    codeReset$: Observable<ResetCodeAction>;
+    private codeChangeSubj$;
+    codeChange$: Observable<string>;
+    private isFullscreenSubj$;
+    isFullscreen$: Observable<boolean>;
+    private isBoilerplateLoadingSub$;
+    isBoilerplateLoading$: Observable<boolean>;
+    themeChanged$: Observable<Themes>;
+    private languageChangeSub$;
+    languageChange$: Observable<LanguageChangeAction>;
+    private testCaseDeletionSub$;
+    testCaseDeletion$: Observable<TestCaseDeletionData>;
+    private currentLanguageSub$;
+    currentLanguage$: Observable<CodeEditorLanguages>;
+    private clearSavedCodeSub$;
+    clearSavedCode$: Observable<boolean>;
+    private clearLastLangSub$;
+    clearLastLang$: Observable<boolean>;
+    private startGuidedTourSubj$;
+    startGuidedTour$: Observable<void>;
+    private testCases;
+    initCode: string;
+    private version;
+    configFieldChanged$: Observable<Partial<import("@testgorilla/tgo-coding-test").LibCodingConfig> | {
+        'Full screen': boolean;
+    }>;
+    setFullscreen(isEnabled: boolean): void;
+    resetCode(): void;
+    startGuidedTour(): void;
+    confirmReset(): void;
+    changeCurrentCode(code: string): void;
+    cancelLanguageChange(): void;
+    confirmLanguageChange(): void;
+    handleTestCaseDeletion(index: number): void;
+    confirmTestCaseDeletion(index: number): void;
+    changeCurrentLanguage(value: CodeEditorLanguages): void;
+    updateTestCases(testCases: (ExampleTestCase | CustomTestCase)[]): void;
+    getTestCases(): (ExampleTestCase | CustomTestCase)[];
+    getValidTestCases(): (ExampleTestCase | CustomTestCase)[];
+    getTestCasesCount(): number;
+    setVersion(version: string): void;
+    getVersion(): string;
+    setInitCode(code: string): void;
+    getInitCode(): string;
+    setBoilerplateLoadingStatus(value: boolean): void;
+    triggerClearSavedCode(): void;
+    clearLastLanguageSelected(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LibCodingTestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LibCodingTestService>;
+}

package/lib/services/storage.service.d.ts

@@ -0,0 +1,83 @@
+import { LocalStorageService } from 'ngx-webstorage';
+import { CodeEditorLanguages } from '../components/code-editor/helpers/code-editor-helper.model';
+import { Config } from '../models/configs';
+import { Modes } from '../models/mode';
+import { CustomTestCase, ExampleTestCase } from '../models/test-cases';
+import { ConfigurationsService } from './configurations.service';
+import { LibCodingTestService } from './lib-coding-test.service';
+import * as i0 from "@angular/core";
+export declare class StorageCodingService {
+    private storage;
+    private libCodingTestService;
+    private configurationsService;
+    private readonly CURRENT_STORAGE_VERSION;
+    private autoSavedData;
+    private readonly key;
+    private assessmentId;
+    private questionId;
+    private language;
+    private codeSaveEnabled;
+    private testCasesSaveEnabled;
+    private isLAT;
+    private currentMode;
+    private isPreview;
+    private codeChangeSubscription;
+    private configSubscription;
+    private isFullscreenSubscription;
+    private currentLanguageSubscription;
+    private isCodeComponentAlive;
+    private readonly MAX_STORAGE_AGE_DAYS;
+    private readonly MAX_QUESTION_DATA_AGE_DAYS;
+    private readonly MAX_ASSESSMENTS;
+    private readonly DEFAULT_MIGRATION_QUESTION_ID;
+    constructor(storage: LocalStorageService, libCodingTestService: LibCodingTestService, configurationsService: ConfigurationsService);
+    /**
+     * Performs a safety check on localStorage data.
+     * This is called at service initialization to ensure data integrity.
+     */
+    private performStorageSafetyCheck;
+    initializeSaving(): void;
+    setupAutoSavedData(language: CodeEditorLanguages, assessmentId: string, questionId: string, codeSaveEnabled: boolean, testCasesSaveEnabled: boolean, isLAT: boolean, mode: Modes): void;
+    private migrateFromV1ToV2;
+    private ensureDataStructure;
+    private updateLastModified;
+    /**
+     * Cleanup with a temporary age threshold
+     * @param maxAgeDays Maximum age in days for data to be considered valid
+     */
+    private cleanupWithReducedThreshold;
+    /**
+     * Unified method to clean up localStorage data with configurable intensity
+     * @param options Cleanup options to control the aggressiveness of the cleanup
+     */
+    private cleanupStorageData;
+    changeLanguage(language: CodeEditorLanguages): void;
+    /**
+     * Gets data from v1 schema format
+     * Used for backward compatibility when retrieving data
+     */
+    private getDataFromV1Schema;
+    getSavedCode(): string | null | undefined;
+    getLastLanguageLAT(): {
+        value: CodeEditorLanguages;
+        version: string;
+    } | null;
+    getSavedTestCases(): (ExampleTestCase | CustomTestCase)[] | null | undefined;
+    getSavedConfig(): Config | null;
+    getSavedFullScreenMode(): boolean | null;
+    clearSavedCode(): void;
+    clearLastLang(): void;
+    clearSavedTestCases(): void;
+    updateVersion(version: string): void;
+    updateTestCases(testCases: (ExampleTestCase | CustomTestCase)[]): void;
+    private storeData;
+    private retrieveData;
+    /**
+     * Manually triggers data cleanup and migration.
+     * Useful for handling large localStorage or migration when needed.
+     * This can be called from application startup or after major events.
+     */
+    performMaintenanceAndCleanup(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageCodingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageCodingService>;
+}

package/lib/services/test-cases.service.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+export declare class TestCasesService {
+    private lastTestCaseLocalId;
+    private activeTestCaseIndexSubj$;
+    activeTestCaseIndex$: import("rxjs").Observable<number>;
+    setActiveTestCase(index: number | null): void;
+    createTestCaseLocalId(): number;
+    updateTestCaseLocalId(value: number): void;
+    resetLastTestCaseLocalId(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TestCasesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TestCasesService>;
+}

package/lib/services/theme.service.d.ts

@@ -0,0 +1,17 @@
+import { LibCodingTestService } from './lib-coding-test.service';
+import * as i0 from "@angular/core";
+export declare class ThemeService {
+    private libCodingService;
+    private defaultCompanyColor;
+    private companyColorSubject;
+    private themeSubject;
+    themeColors$: import("rxjs").Observable<{
+        companyColor: string;
+        themeSpecificColor: string;
+    }>;
+    constructor(libCodingService: LibCodingTestService);
+    set companyColor(color: string);
+    private getAdjustedColorForTheme;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+}

package/lib/utils/additional-languages/erlang.d.ts

@@ -0,0 +1,37 @@
+export declare const erlangLanguage: {
+    defaultToken: string;
+    keywords: string[];
+    typeKeywords: string[];
+    operators: string[];
+    symbols: RegExp;
+    tokenizer: {
+        root: ((string | RegExp)[] | (RegExp | {
+            cases: {
+                '@keywords': string;
+                '@default': string;
+            };
+        })[] | {
+            include: string;
+        } | (RegExp | {
+            cases: {
+                '@operators': string;
+                '@default': string;
+            };
+        })[] | (RegExp | {
+            token: string;
+            bracket: string;
+            next: string;
+        })[])[];
+        string: ((string | RegExp)[] | (RegExp | {
+            token: string;
+            bracket: string;
+            next: string;
+        })[])[];
+        atom: ((string | RegExp)[] | (RegExp | {
+            token: string;
+            bracket: string;
+            next: string;
+        })[])[];
+        whitespace: (string | RegExp)[][];
+    };
+};

package/lib/utils/resize-element.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function resizeElement(element: Element): Observable<ResizeObserverEntry>;

package/lib/utils/time-to-ms.util.d.ts

@@ -0,0 +1 @@
+export declare function timeToMs(time: number, type?: 'days' | 'hours'): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testgorilla/tgo-coding-test",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "peerDependencies": {
     "@angular/animations": "^19.2.17",
     "@angular/common": "^19.2.17",
@@ -24,5 +24,19 @@
   "sideEffects": false,
   "license": "PROPRIETARY",
   "displayName": "Coding test",
-  "description": "Coding test component"
-}
+  "description": "Coding test component",
+  "module": "fesm2022/testgorilla-tgo-coding-test.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/testgorilla-tgo-coding-test.mjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/shared/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/components';
+export * from './lib/models';
+export * from './lib/services';
+export * from './test-mocks';

package/shared/lib/components/audio-animation/audio-animation.component.d.ts

@@ -0,0 +1,27 @@
+import { OnChanges, OnDestroy, WritableSignal } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AudioAnimationComponent implements OnChanges, OnDestroy {
+    volume: number;
+    fakeData: boolean;
+    private isAnimationRunning;
+    private animationFrameId;
+    private lastAnimationUpdate;
+    volumeSignal: WritableSignal<number>;
+    barHeightsSignal: import("@angular/core").Signal<{
+        'first-bar': string;
+        'second-bar': string;
+        'third-bar': string;
+    }>;
+    constructor();
+    ngOnChanges(): void;
+    private normalizeRealVolume;
+    private startAnimation;
+    private stopAnimation;
+    private getBarHeights;
+    private getFakeVolumeRange;
+    private getRealVolumeRange;
+    private getRandomHeight;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AudioAnimationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AudioAnimationComponent, "tgo-audio-animation", never, { "volume": { "alias": "volume"; "required": false; }; "fakeData": { "alias": "fakeData"; "required": false; }; }, {}, never, never, true, never>;
+}

package/shared/lib/components/audio-animation/index.d.ts

@@ -0,0 +1 @@
+export * from './audio-animation.component';

package/shared/lib/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './audio-animation';
+export * from './vimeo-video';

package/shared/lib/components/vimeo-video/index.d.ts

@@ -0,0 +1 @@
+export * from './vimeo-video.component';

package/shared/lib/components/vimeo-video/vimeo-video.component.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import Player from '@vimeo/player';
+import type { VimeoEmbedParameters } from '@vimeo/player/types/formats';
+import * as i0 from "@angular/core";
+type Options = VimeoEmbedParameters;
+export declare class VimeoVideoComponent implements OnInit, OnDestroy, OnChanges {
+    class: string;
+    videoUrl: string;
+    isPlaying: boolean;
+    options: Options;
+    videoEnded: EventEmitter<void>;
+    videoStarted: EventEmitter<void>;
+    vimeoPlayer?: Player;
+    private elRef;
+    ngOnInit(): Promise<void>;
+    ngOnDestroy(): Promise<void>;
+    ngOnChanges(simpleChanges: SimpleChanges): Promise<void>;
+    private removeVimeoPlayer;
+    private configureVimeoPlayer;
+    private playVideo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VimeoVideoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VimeoVideoComponent, "tgo-vimeo-video", never, { "videoUrl": { "alias": "videoUrl"; "required": false; }; "isPlaying": { "alias": "isPlaying"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "videoEnded": "videoEnded"; "videoStarted": "videoStarted"; }, never, never, true, never>;
+}
+export {};