@xxmachina/components 19.0.0-preview.9 → 19.1.0

package/routes/queries/index.d.ts

@@ -1 +1,5 @@
-export { default } from './queries.routes';
+import { Routes } from '@angular/router';
+
+declare const routes: Routes;
+
+export { routes };

package/routes/query/index.d.ts

@@ -1 +1,5 @@
-export { default } from './query.routes';
+import { Routes } from '@angular/router';
+
+declare const routes: Routes;
+
+export { routes };

package/routes/resources/index.d.ts

@@ -1 +1,5 @@
-export { default } from './resources.routes';
+import { Routes } from '@angular/router';
+
+declare const routes: Routes;
+
+export { routes };

package/routes/side/chat/index.d.ts

@@ -1,2 +1,5 @@
-export * from './chat.routes';
-export * from './chat.component';
+import { Routes } from '@angular/router';
+
+declare const routes: Routes;
+
+export { routes };

package/routes/side/index.d.ts

@@ -1 +1,5 @@
-export { default } from './pages.routes';
+import { Routes } from '@angular/router';
+
+declare const routes: Routes;
+
+export { routes };

package/routes/transformer/index.d.ts

@@ -0,0 +1,5 @@
+import { Routes } from '@angular/router';
+
+declare const routes: Routes;
+
+export { routes };

package/routes/transformers/index.d.ts

@@ -0,0 +1,5 @@
+import { Routes } from '@angular/router';
+
+declare const routes: Routes;
+
+export { routes };

package/services/app/index.d.ts

@@ -0,0 +1,17 @@
+import { AppService as AppService$1 } from '@ng-atomic/common/services/app';
+import { CommandService } from '@xxmachina/components/services/command';
+import { QueryService } from '@xxmachina/components/services/query';
+import { TransformerService } from '@xxmachina/components/services/transformer';
+import { ContextService } from '@xxmachina/components/services/context';
+import * as i0 from '@angular/core';
+
+declare class AppService extends AppService$1 {
+    readonly command: CommandService;
+    readonly query: QueryService;
+    readonly context: ContextService;
+    readonly transformer: TransformerService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
+}
+
+export { AppService };

package/services/assistant/index.d.ts

@@ -1 +1,20 @@
-export * from './assistant.service';
+import { HttpClient } from '@angular/common/http';
+import { Assistant } from '@xxmachina/common/domain/models';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare class AssistantService {
+    readonly http: HttpClient;
+    list(): Observable<Object>;
+    create(assistant: Assistant): Promise<Object>;
+    get(id: string): Observable<Assistant>;
+    update(assistant: Partial<Assistant> & {
+        id: string;
+    }): Promise<Object>;
+    delete(id: string): Promise<Object>;
+    syncFiles(id: string): Promise<Object>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssistantService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AssistantService>;
+}
+
+export { AssistantService };

package/services/calendar/index.d.ts

@@ -1 +1,13 @@
-export * from './calendar.service';
+import { HttpClient } from '@angular/common/http';
+import { Calendar } from '@xxmachina/common/domain/models';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare class CalendarService {
+    http: HttpClient;
+    list(): Observable<Calendar[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarService>;
+}
+
+export { CalendarService };

package/services/command/index.d.ts

@@ -1 +1,54 @@
-export * from './command.service';
+import * as _xxmachina_common_domain_models from '@xxmachina/common/domain/models';
+import { Command, Resource } from '@xxmachina/common/domain/models';
+import * as rxjs from 'rxjs';
+import { ReplaySubject } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { JsonSchemaService } from '@xxmachina/components/services/json-schema';
+import { AppService } from '@ng-atomic/common/services/app';
+import { OpenApiService } from '@xxmachina/components/services/openapi';
+import { CommandActionFactoryOptions, ActionId, CommandActionsBuilder } from '@xxmachina/common/domain/builder';
+import { NavigationExtras } from '@angular/router';
+import { Action } from '@ng-atomic/core';
+
+type CommandActionOptions = CommandActionFactoryOptions & {
+    overwrite?: Partial<Action>;
+};
+type CommandPermissionResolver = (command: Command) => boolean;
+declare const COMMAND_PERMISSION_RESOLVER: InjectionToken<CommandPermissionResolver>;
+declare function provideCommandPermissionResolver(useFactory: () => CommandPermissionResolver): {
+    provide: InjectionToken<CommandPermissionResolver>;
+    useFactory: () => CommandPermissionResolver;
+};
+declare class CommandService {
+    static readonly ActionId: typeof ActionId;
+    protected readonly app: AppService;
+    protected readonly http: HttpClient;
+    protected readonly resources: _angular_core.Signal<Resource[]>;
+    protected readonly resourceUrls: _angular_core.Signal<string[]>;
+    protected readonly resourceUrls$: rxjs.Observable<string[]>;
+    protected readonly refresh$: ReplaySubject<void>;
+    readonly schema: JsonSchemaService;
+    readonly openApi: OpenApiService;
+    readonly commands$: rxjs.Observable<_xxmachina_common_domain_models.WebAPiRequestCommand[]>;
+    readonly commands: _angular_core.Signal<_xxmachina_common_domain_models.WebAPiRequestCommand[]>;
+    protected readonly permissionResolver: CommandPermissionResolver;
+    constructor();
+    getCommand(id: string): Command | null;
+    getCommands(ids: string[]): Command[];
+    getActionBuilder(item?: any): CommandActionsBuilder;
+    execute<D extends object>(commandOrCommandId: Command | string, data: D): Promise<any>;
+    refresh(): Promise<void>;
+    resolveResponse(data: any): Promise<any>;
+    download(url: string): Promise<void>;
+    buildNavigationAction(commandOrId: Command | string, data?: any, navigationExtra?: NavigationExtras, options?: CommandActionOptions): Action<any>;
+    buildExecutionAction(commandOrId: Command | string, data?: any, options?: CommandActionOptions): Action<any>;
+    hasPermission(commandOrId: Command | string): boolean;
+    protected resolveCommand(commandOrId: Command | string): Command | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CommandService>;
+}
+
+export { COMMAND_PERMISSION_RESOLVER, CommandService, provideCommandPermissionResolver };
+export type { CommandActionOptions, CommandPermissionResolver };

package/services/context/index.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from '@angular/core';
+
+declare class ContextService {
+    context: i0.WritableSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextService>;
+}
+
+export { ContextService };

package/services/contract/index.d.ts

@@ -1 +1,11 @@
-export * from './contract.service';
+import * as rxjs from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare class ContractService {
+    private graphql;
+    list(): rxjs.Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContractService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContractService>;
+}
+
+export { ContractService };

package/services/debug/index.d.ts

@@ -1 +1,14 @@
-export * from './debug.service';
+import * as i0 from '@angular/core';
+import { SnackBarService } from '@ng-atomic/common/services/snack-bar';
+
+declare class MachinaDevService {
+    readonly isDevMode: i0.WritableSignal<boolean>;
+    protected readonly snackBar: SnackBarService;
+    toggleDevMode(): void;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MachinaDevService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MachinaDevService>;
+}
+declare function provideMachinaDevService(): i0.EnvironmentProviders;
+
+export { MachinaDevService, provideMachinaDevService };

package/services/forms/query/index.d.ts

@@ -1 +1,45 @@
-export * from './query.service';
+import * as _angular_forms from '@angular/forms';
+import { FormBuilder } from '@angular/forms';
+import { Query } from '@xxmachina/common/domain/models';
+import * as i0 from '@angular/core';
+
+declare class QueryFormService {
+    protected fb: FormBuilder;
+    build(): _angular_forms.FormGroup<{
+        id: _angular_forms.FormControl<string>;
+        title: _angular_forms.FormControl<string>;
+        graphql: _angular_forms.FormGroup<{
+            endpoint: _angular_forms.FormControl<string>;
+            query: _angular_forms.FormControl<string>;
+            variablesJson: _angular_forms.FormControl<string>;
+            headersJson: _angular_forms.FormControl<string>;
+            transformerTs: _angular_forms.FormControl<any>;
+            transformer: _angular_forms.FormControl<any>;
+        }>;
+    }>;
+    static parseGraphql(formValue: Partial<{
+        endpoint: string;
+        query: string;
+        variablesJson: string;
+        headersJson: string;
+        transformerTs: string | null;
+        transformer: (data: any) => any | null;
+    }>): Query['graphql'];
+    static parse(formValue: Partial<{
+        id: string;
+        title: string;
+        type: 'graphql';
+        graphql: Partial<{
+            endpoint: string;
+            query: string;
+            variablesJson: string;
+            headersJson: string;
+            transformerTs: string | null;
+            transformer: (data: any) => any | null;
+        }>;
+    }>): Query;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryFormService>;
+}
+
+export { QueryFormService };

package/services/forms/schedule/index.d.ts

@@ -1 +1,42 @@
-export * from './schedule.service';
+import { FormBuilder, FormGroup, FormControl, FormArray } from '@angular/forms';
+import { Schedule } from '@xxmachina/common/domain/models';
+import dayjs from 'dayjs';
+import * as i0 from '@angular/core';
+
+declare class ScheduleService {
+    protected fb: FormBuilder;
+    buildScheduleForm({ id, calendarId, name, startAt, endAt, url, }?: Partial<Schedule>): FormGroup<{
+        id: FormControl<string>;
+        calendarId: FormControl<string>;
+        name: FormControl<string>;
+        startAt: FormControl<dayjs.Dayjs>;
+        endAt: FormControl<dayjs.Dayjs>;
+        url: FormControl<string>;
+    }>;
+    build(): FormGroup<{
+        dateRange: FormGroup<{
+            start: FormControl<dayjs.Dayjs>;
+            end: FormControl<dayjs.Dayjs>;
+        }>;
+        timeRange: FormGroup<{
+            start: FormControl<string>;
+            end: FormControl<string>;
+        }>;
+        title: FormControl<string>;
+        events: FormArray<FormGroup<{
+            startAt: FormControl<dayjs.Dayjs>;
+            endAt: FormControl<dayjs.Dayjs>;
+        }>>;
+        message: FormControl<string>;
+    }>;
+    getSchedulesForm(form: ReturnType<typeof this['build']>): FormArray;
+    getSchedules(form: ReturnType<typeof this['build']>): Schedule[];
+    addSchedule(form: ReturnType<typeof this['build']>, schedule: Schedule): void;
+    removeAt(form: ReturnType<typeof this['build']>, index: number): void;
+    removeAllSchedules(form: ReturnType<typeof this['build']>): void;
+    rebuildSchedulesForm(form: ReturnType<typeof this['build']>, schedules: Schedule[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScheduleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScheduleService>;
+}
+
+export { ScheduleService };

package/services/forms/variables/index.d.ts

@@ -0,0 +1,12 @@
+import { FormBuilder, NonNullableFormBuilder, FormGroup } from '@angular/forms';
+import * as i0 from '@angular/core';
+
+declare function buildVariablesForm(value: object, fb: FormBuilder | NonNullableFormBuilder): FormGroup;
+declare class VariablesFromService {
+    protected readonly fb: NonNullableFormBuilder;
+    build(value: object): FormGroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VariablesFromService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VariablesFromService>;
+}
+
+export { VariablesFromService, buildVariablesForm };

package/services/graphql/index.d.ts

@@ -1 +1,20 @@
-export * from './graphql.service';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
+/**
+ * @deprecated use GraphqlService(@mxxmachina/common/services/graphql) instead
+ */
+declare class GraphqlService {
+    private http;
+    constructor(http: HttpClient);
+    graphql(props: {
+        query?: string;
+        variables?: object;
+        operationName?: string;
+    }): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphqlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GraphqlService>;
+}
+
+export { GraphqlService };

package/services/invoice/index.d.ts

@@ -1 +1,19 @@
-export * from './invoice.service';
+import { GraphqlService } from '@xxmachina/components/services/graphql';
+import { Observable } from 'rxjs';
+import { Invoice } from '@xxmachina/common/invoice/domain/models';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from '@angular/core';
+
+declare class InvoiceService {
+    readonly graphql: GraphqlService;
+    readonly http: HttpClient;
+    list(): Observable<Invoice[]>;
+    getInvoices(): Observable<Invoice[]>;
+    download(invoice: Invoice): Promise<void>;
+    send(invoice: Invoice): Promise<void>;
+    sync(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InvoiceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InvoiceService>;
+}
+
+export { InvoiceService };

package/services/json-schema/index.d.ts

@@ -1 +1,15 @@
-export * from './json-schema.service';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare class JsonSchemaService {
+    private http;
+    private schemaCache;
+    constructor(http: HttpClient);
+    getSchema(schemaUrl: string): Observable<any>;
+    resolveRef(schema: any, baseUrl?: string, localSchema?: any): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonSchemaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JsonSchemaService>;
+}
+
+export { JsonSchemaService };

package/services/link/index.d.ts

@@ -1 +1,13 @@
-export * from './link.service';
+import { HttpClient } from '@angular/common/http';
+import { Google } from '@xxmachina/common/domain/models';
+import * as i0 from '@angular/core';
+
+declare class LinkService {
+    readonly http: HttpClient;
+    create(link: Google): Promise<Object>;
+    linkWithGoogle(): Window;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LinkService>;
+}
+
+export { LinkService };

package/services/message/index.d.ts

@@ -0,0 +1,23 @@
+import * as rxjs from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { Message } from '@ng-atomic/common/models';
+import { OpenAIService } from '@xxmachina/components/services/openai';
+
+declare class MESSAGES {
+    static readonly ERROR: () => Message;
+    static readonly WAITING: () => Message;
+}
+declare class MessageService {
+    readonly messages: _angular_core.WritableSignal<Message[]>;
+    readonly messages$: rxjs.Observable<Message[]>;
+    readonly latestMessage: _angular_core.Signal<Message>;
+    readonly latestMessage$: rxjs.Observable<Message>;
+    readonly openai: OpenAIService;
+    pushMessage(message: Message): void;
+    clearMessages(): void;
+    completeMessage(systemMessages?: Message[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MessageService>;
+}
+
+export { MESSAGES, MessageService };

package/services/openai/index.d.ts

@@ -0,0 +1,35 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider } from '@angular/core';
+import * as openai_client from 'openai/client';
+import OpenAI, { ClientOptions } from 'openai';
+import { Message } from '@ng-atomic/common/models';
+
+declare const OPENAI_CONFIG: InjectionToken<ClientOptions>;
+declare const OPENAI_BACKEND_URL: InjectionToken<string>;
+declare function provideOpenaiConfig(useFactory?: () => ClientOptions): {
+    provide: InjectionToken<ClientOptions>;
+    useFactory: () => ClientOptions;
+}[];
+declare function provideOpenaiBackendUrl(url: string): {
+    provide: InjectionToken<string>;
+    useValue: string;
+};
+declare class OpenAIService {
+    readonly config: ClientOptions;
+    readonly apiKey: i0.WritableSignal<string | openai_client.ApiKeySetter>;
+    readonly openai: i0.Signal<OpenAI>;
+    readonly hasApiKey: i0.Signal<boolean>;
+    complete(_messages: Message[]): Promise<Message[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenAIService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OpenAIService>;
+}
+declare class OpenAIViaBackendService extends OpenAIService {
+    private readonly http;
+    private readonly backendUrl;
+    complete(_messages: Message[]): Promise<Message[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenAIViaBackendService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OpenAIViaBackendService>;
+}
+declare function provideOpenAIViaBackendService(backendUrl: string): Provider[];
+
+export { OPENAI_BACKEND_URL, OPENAI_CONFIG, OpenAIService, OpenAIViaBackendService, provideOpenAIViaBackendService, provideOpenaiBackendUrl, provideOpenaiConfig };

package/services/openapi/index.d.ts

@@ -1 +1,17 @@
-export * from './openapi.service';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { OpenApi, OpenAPISchema } from '@xxmachina/common/domain/models';
+import { JsonSchemaService } from '@xxmachina/components/services/json-schema';
+import * as i0 from '@angular/core';
+
+declare class OpenApiService {
+    readonly http: HttpClient;
+    readonly schema: JsonSchemaService;
+    getOpenApiMany(urls: string[]): Observable<OpenApi[]>;
+    getOpenApi(url: string): Observable<OpenApi>;
+    getOpenApiSchema(url: string): Observable<OpenAPISchema>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OpenApiService>;
+}
+
+export { OpenApiService };

package/services/order/index.d.ts

@@ -1 +1,13 @@
-export * from './order.service';
+import { GraphqlService } from '@xxmachina/components/services/graphql';
+import { Order } from '@xxmachina/common/invoice/domain/models';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare class OrderService {
+    readonly graphql: GraphqlService;
+    list(): Observable<Order[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OrderService>;
+}
+
+export { OrderService };

package/services/partner/index.d.ts

@@ -1 +1,11 @@
-export * from './partner.service';
+import * as rxjs from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare class PartnerService {
+    private graphql;
+    list(): rxjs.Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PartnerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PartnerService>;
+}
+
+export { PartnerService };

package/services/query/index.d.ts

@@ -1 +1,42 @@
-export * from './query.service';
+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

@@ -1 +1,20 @@
-export * from './recording.service';
+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

@@ -1 +1,26 @@
-export * from './schedule.service';
+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

@@ -1 +1,30 @@
-export * from './thread.service';
+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 };