@xxmachina/components 0.0.0-PLACEHOLDER

package/services/query/index.d.ts

@@ -0,0 +1,42 @@
+import { HttpClient } from '@angular/common/http';
+import { Query } from '@xxmachina/common/domain/models';
+import { QueryConfigService } from '@xxmachina/common/services/query/config';
+import { GraphqlService } from '@xxmachina/common/services/graphql';
+import { Observable } from 'rxjs';
+import { QueryResolverService } from '@ng-atomic/common/services/query-resolver';
+import { QueryService as QueryService$1 } from '@xxmachina/common/services/query';
+import * as i0 from '@angular/core';
+
+/**
+ * @deprecated use `QueryService`('@xxmachina/common/services/query/query.service') instead
+ */
+declare class QueryService {
+    protected readonly http: HttpClient;
+    protected readonly graphql: GraphqlService;
+    protected readonly resolver: QueryResolverService<any>;
+    /**
+     * @deprecated
+     * */
+    protected readonly config: QueryConfigService;
+    readonly query: QueryService$1;
+    getSchema(endpoint: string, options?: {
+        headers?: Record<string, string>;
+    }): Observable<Object>;
+    subscribeSchema(endpoint: string, options: {
+        headers?: Record<string, string>;
+    }): Observable<any>;
+    /** @deprecated use `QueryServie#subscribe`('@xxmachina/common/services/query/query.service') instead */
+    subscribeQuery(query: {
+        type: 'graphql';
+        graphql: Omit<Query['graphql'], 'variablesJson' | 'headersJson' | 'transformerTs'> & Partial<Pick<Query['graphql'], 'transformerTs'>>;
+    }): Observable<Record<string, any>>;
+    generate(instructions: string, options?: {
+        baseUrl: string;
+    }): Promise<{
+        query: string;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryService>;
+}
+
+export { QueryService };

package/services/recording/index.d.ts

@@ -0,0 +1,20 @@
+import * as _angular_core from '@angular/core';
+import dayjs from 'dayjs';
+import { Observable } from 'rxjs';
+
+declare class RecordingService {
+    constructor();
+    readonly stream: _angular_core.WritableSignal<MediaStream>;
+    readonly recorder: _angular_core.Signal<MediaRecorder>;
+    readonly isRecording$: Observable<boolean>;
+    readonly isRecording: _angular_core.Signal<boolean>;
+    readonly recordedChunks: _angular_core.WritableSignal<Blob[]>;
+    readonly startTime: _angular_core.WritableSignal<dayjs.Dayjs>;
+    stopStream(): Promise<void>;
+    start(stream?: MediaStream): Promise<void>;
+    stop(): Promise<Blob>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RecordingService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RecordingService>;
+}
+
+export { RecordingService };

package/services/schedule/index.d.ts

@@ -0,0 +1,26 @@
+import { HttpClient } from '@angular/common/http';
+import { Schedule } from '@xxmachina/common/domain/models';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare class ScheduleService {
+    http: HttpClient;
+    list(): Observable<Schedule[]>;
+    create(schedule: Schedule): Promise<Schedule>;
+    update(schedule: Partial<Schedule> & {
+        id: string;
+        calendarId?: string;
+    }): Promise<void>;
+    delete(schedule: Partial<Schedule> & {
+        id: string;
+        calendarId?: string;
+    }): Promise<void>;
+    makeConference(schedule: Partial<Schedule> & {
+        id: string;
+        calendarId?: string;
+    }): Promise<Schedule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScheduleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScheduleService>;
+}
+
+export { ScheduleService };

package/services/thread/index.d.ts

@@ -0,0 +1,30 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare class ThreadService {
+    readonly http: HttpClient;
+    getThread(id: string): Observable<Object>;
+    create(): Promise<{
+        id: string;
+    }>;
+    listMessages(threadId: string): Observable<any[]>;
+    createMessage(message: {
+        threadId: string;
+        role: 'user';
+        content: string;
+    }): Promise<Object>;
+    run(assistantId: string, threadId: string): Promise<{
+        id: string;
+    }>;
+    submitToolOutputs(threadId: string, runId: string, toolOutputs: any[]): Promise<any>;
+    retrieveRun(threadId: string, runId: string): Promise<any>;
+    retrieveRunSteps(threadId: string, runId: string): Observable<any>;
+    observeSteps(threadId: string, runId: string): Observable<'dealing' | 'message_creating' | 'function_calling' | 'done'>;
+    watchSteps(threadId: string, runId: string, onStatusChanged: (status: string) => void): Promise<void>;
+    watch(threadId: string, runId: string, onFunctionCalled: (toolCall: any) => Promise<object> | object, onCompleted: () => void, onError: (error: any) => void): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThreadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThreadService>;
+}
+
+export { ThreadService };

package/services/transformer/index.d.ts

@@ -0,0 +1,19 @@
+import { Transformer, Spec } from '@xxmachina/common/domain/models';
+import { QuickJsService } from '@xxmachina/common/infra/external/quick-js';
+import * as i0 from '@angular/core';
+
+declare class TransformerService {
+    readonly quickJs: QuickJsService;
+    runTest(transformer: Transformer, spec: Spec): Promise<{
+        isEqual: boolean;
+        diff: string;
+    }>;
+    runTests(transformer: Transformer, specs: Spec[]): Promise<{
+        isEqual: boolean;
+        diff: string;
+    }[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TransformerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TransformerService>;
+}
+
+export { TransformerService };

package/services/youtube/index.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from '@angular/core';
+
+declare class YoutubeService {
+    constructor();
+    uploadHls(cid: string, files: File[]): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<YoutubeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<YoutubeService>;
+}
+
+export { YoutubeService };

package/templates/agent/index.d.ts

@@ -0,0 +1,54 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, ElementRef, Provider } from '@angular/core';
+import { NgAtomicComponent } from '@ng-atomic/core';
+import * as i1 from '@ng-atomic/components/templates/entrance';
+import { EntranceTemplateStore } from '@ng-atomic/components/templates/entrance';
+import { Terminal } from '@xterm/xterm';
+import { XtermOrganism } from '@xxmachina/components/organisms/xterm';
+
+declare enum ActionId {
+    SIGN_IN = "[@ng-atomic/components] Sign In",
+    SIGN_IN_WITH_GOOGLE = "[@ng-atomic/components] Sign In With Google",
+    SIGN_IN_WITH_TWITTER = "[@ng-atomic/components] Sign In With Twitter",
+    SIGN_OUT = "[@ng-atomic/components] Sign Out"
+}
+declare class AgentTemplate extends NgAtomicComponent implements AfterViewInit {
+    static ActionId: typeof ActionId;
+    protected ActionId: typeof ActionId;
+    protected store: EntranceTemplateStore;
+    private cdr;
+    private app;
+    readonly xtermComponent: _angular_core.Signal<XtermOrganism>;
+    readonly inputField: _angular_core.Signal<ElementRef<HTMLTextAreaElement>>;
+    protected statusText: string;
+    protected isProcessing: boolean;
+    protected showCursor: boolean;
+    protected cursorLeft: number;
+    protected cursorTop: number;
+    private terminal;
+    private commandHistory;
+    private historyIndex;
+    protected currentInput: string;
+    ngAfterViewInit(): void;
+    onTerminalReady(terminal: Terminal): void;
+    private showWelcomeMessage;
+    private showPrompt;
+    private processCommand;
+    private completeProcessing;
+    handleEnter(event: KeyboardEvent): void;
+    navigateHistory(event: KeyboardEvent, direction: number): void;
+    generateCommand(event?: KeyboardEvent): void;
+    closeSideApp(event: MouseEvent): void;
+    focusInput(): void;
+    adjustTextareaHeight(): void;
+    preventPrefixDeletion(event: KeyboardEvent): void;
+    handleInput(event: Event): void;
+    handleFocus(): void;
+    handleBlur(): void;
+    updateCursorPosition(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgentTemplate, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgentTemplate, "templates-agent", never, {}, {}, never, never, true, [{ directive: typeof i1.EntranceTemplateStore; inputs: { "form": "form"; "actions": "actions"; "title": "title"; "fieldMap": "fieldMap"; }; outputs: {}; }]>;
+}
+declare function provideAgentTemplate(): Provider[];
+
+export { AgentTemplate, provideAgentTemplate };

package/templates/background/index.d.ts

@@ -0,0 +1,44 @@
+import * as i0 from '@angular/core';
+
+declare class BackgroundTemplate {
+    title: i0.InputSignal<string>;
+    private canvas;
+    private ctx;
+    private particles;
+    protected window: Window & typeof globalThis;
+    private hue;
+    private frame;
+    private messages;
+    private currentMessage;
+    constructor();
+    private initializeParticles;
+    private glitchEffect;
+    private drawText;
+    private animate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackgroundTemplate, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BackgroundTemplate, "app-background-template", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class MachinaBackgroundTemplate {
+    private canvas;
+    private ctx;
+    private particles;
+    protected window: Window & typeof globalThis;
+    private hue;
+    constructor();
+    private initializeParticles;
+    private animate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MachinaBackgroundTemplate, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MachinaBackgroundTemplate, "machina-templates-background", never, {}, {}, never, never, true, never>;
+}
+
+declare function provideMachinaBackgroundTemplate(): {
+    provide: any;
+    useValue: () => Promise<i0.Type<MachinaBackgroundTemplate>>;
+};
+declare function provideLainBackgroundTemplate(): {
+    provide: any;
+    useValue: () => Promise<i0.Type<BackgroundTemplate>>;
+};
+
+export { MachinaBackgroundTemplate, provideLainBackgroundTemplate, provideMachinaBackgroundTemplate };

package/templates/invoice-iframe/index.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { NgAtomicComponent } from '@ng-atomic/core';
+
+declare class InvoiceIframeTemplate extends NgAtomicComponent {
+    readonly iframe: ElementRef;
+    protected navStartActions: any[];
+    protected src: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InvoiceIframeTemplate, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InvoiceIframeTemplate, "templates-invoice-iframe", never, { "navStartActions": { "alias": "navStartActions"; "required": false; }; "src": { "alias": "src"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { InvoiceIframeTemplate };

package/templates/scheduler/index.d.ts

@@ -0,0 +1,31 @@
+import { FormGroup } from '@angular/forms';
+import { NgAtomicComponent } from '@ng-atomic/core';
+import * as i0 from '@angular/core';
+
+declare enum ActionId {
+    ADD_EVENTS = "ADD_EVENTS",
+    COPY_MESSAGE = "COPY_MESSAGE",
+    DELETE_EVENT = "[@xxmachina/scheduler/components/templates/scheduler] Delete Event",
+    FIX_SCHEDULE = "[@xxmachina/scheduler/components/templates/scheduler] Fix Schedule"
+}
+declare class SchedulerTemplate extends NgAtomicComponent {
+    static readonly ActionId: typeof ActionId;
+    protected form: FormGroup;
+    protected autoCompleteTitle: string[];
+    protected addEventsActions: {
+        id: ActionId;
+        name: string;
+        icon: string;
+    }[];
+    protected submitActions: {
+        id: ActionId;
+        name: string;
+        icon: string;
+    }[];
+    onDeleteButtonClicked(index: any): void;
+    onFixButtonClicked(index: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerTemplate, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SchedulerTemplate, "templates-scheduler", never, { "form": { "alias": "form"; "required": false; }; "autoCompleteTitle": { "alias": "autoCompleteTitle"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { SchedulerTemplate };

package/templates/video/index.d.ts

@@ -0,0 +1,36 @@
+import * as rxjs from 'rxjs';
+import * as _angular_core from '@angular/core';
+import * as _angular_forms from '@angular/forms';
+import { VideoSectionOrganism } from '@ng-atomic/components/organisms/video-section';
+import { NgAtomicComponent } from '@ng-atomic/core';
+
+declare class VideoTemplateStore {
+    readonly form: _angular_core.InputSignal<_angular_forms.FormGroup<{
+        device: _angular_forms.FormControl<string>;
+        trim: _angular_forms.FormGroup<{
+            duration: _angular_forms.FormControl<number>;
+            start: _angular_forms.FormControl<number>;
+            end: _angular_forms.FormControl<number>;
+        }>;
+    }>>;
+    readonly gridActions: _angular_core.InputSignal<any[]>;
+    readonly images: _angular_core.InputSignal<string[]>;
+    readonly deviceOptions: _angular_core.InputSignal<{
+        name: string;
+        value: string;
+    }[]>;
+    readonly videoStream: _angular_core.InputSignal<MediaStream>;
+    readonly videoStream$: rxjs.Observable<MediaStream>;
+    readonly videoSrc: _angular_core.InputSignal<string>;
+    readonly title: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VideoTemplateStore, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<VideoTemplateStore, never, never, { "form": { "alias": "form"; "required": false; "isSignal": true; }; "gridActions": { "alias": "gridActions"; "required": false; "isSignal": true; }; "images": { "alias": "images"; "required": false; "isSignal": true; }; "deviceOptions": { "alias": "deviceOptions"; "required": false; "isSignal": true; }; "videoStream": { "alias": "videoStream"; "required": false; "isSignal": true; }; "videoSrc": { "alias": "videoSrc"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class VideoTemplate extends NgAtomicComponent {
+    protected store: VideoTemplateStore;
+    readonly videoSection: _angular_core.Signal<VideoSectionOrganism>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VideoTemplate, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VideoTemplate, "templates-video", never, {}, {}, never, never, true, [{ directive: typeof VideoTemplateStore; inputs: { "title": "title"; "form": "form"; "gridActions": "gridActions"; "images": "images"; "deviceOptions": "deviceOptions"; "videoStream": "videoStream"; "videoSrc": "videoSrc"; }; outputs: {}; }]>;
+}
+
+export { VideoTemplate, VideoTemplateStore };

package/validators/query/index.d.ts

@@ -0,0 +1,7 @@
+import { AsyncValidatorFn } from '@angular/forms';
+
+declare class QueryValidators {
+    static graphql(): AsyncValidatorFn;
+}
+
+export { QueryValidators };