@kosdev-code/kos-ui-sdk 0.1.0-dev.5053

package/models/models/translation/types/index.d.ts

@@ -0,0 +1,383 @@
+import { TranslationContainerModel } from '../translation-container-model';
+import { LocaleDescriptor, Localization, TranslationResponse } from '../services';
+import { KosContext, KosParentAware } from '../../../../core';
+
+
+// ---------------  Translation ---------------
+
+/**
+ * Configuration options for Translation model instances.
+ *
+ * This interface defines the complete configuration structure for individual translation
+ * namespace models, including locale settings, resolution strategies, and custom loading
+ * mechanisms. Translation models handle the actual key resolution and interpolation for
+ * specific functional areas within KOS applications.
+ *
+ * @example Basic Translation Configuration
+ * ```typescript
+ * // Device status translations with English fallback
+ * const statusOptions: TranslationOptions = {
+ *   namespace: 'device-status',
+ *   currentLocale: 'es',
+ *   defaultLocale: 'en',
+ *   descriptor: {
+ *     'es': {
+ *       fallbacks: ['en']
+ *     },
+ *     'en': {
+ *       fallbacks: []
+ *     }
+ *   },
+ *   kosParentId: 'translation-container'
+ * };
+ *
+ * const statusTranslation = Translation.instance('status-translations')
+ *   .options(statusOptions)
+ *   .build();
+ * ```
+ *
+ * @example Custom Bundle Resolution
+ * ```typescript
+ * // API-based translation loading
+ * const apiBundleResolver = async (
+ *   namespace: string,
+ *   locale: string,
+ *   context?: KosContext
+ * ): Promise<TranslationResponse> => {
+ *   const response = await fetch(`/api/translations/${namespace}/${locale}`);
+ *   return await response.json();
+ * };
+ *
+ * const apiOptions: TranslationOptions = {
+ *   namespace: 'alerts',
+ *   currentLocale: 'fr',
+ *   defaultLocale: 'en',
+ *   descriptor: {
+ *     'fr': { fallbacks: ['en'] },
+ *     'en': { fallbacks: [] }
+ *   },
+ *   bundleResolver: apiBundleResolver,
+ *   kosParentId: 'translation-container'
+ * };
+ * ```
+ *
+ * @example Multi-Regional Configuration
+ * ```typescript
+ * // Complex fallback chains for regional variations
+ * const regionalOptions: TranslationOptions = {
+ *   namespace: 'regional-ui',
+ *   currentLocale: 'pt-BR',
+ *   defaultLocale: 'en',
+ *   descriptor: {
+ *     'pt-BR': { fallbacks: ['pt', 'es', 'en'] },
+ *     'pt-PT': { fallbacks: ['pt', 'es', 'en'] },
+ *     'pt': { fallbacks: ['es', 'en'] },
+ *     'es': { fallbacks: ['en'] },
+ *     'en': { fallbacks: [] }
+ *   },
+ *   kosParentId: 'translation-container'
+ * };
+ * ```
+ *
+ * @group KOS Model
+ * @category i18n
+ */
+export interface TranslationOptions extends KosParentAware {
+  /**
+   * Translation namespace identifier, typically corresponding to a feature area.
+   * Used to organize translations by functional domain and prevent key conflicts.
+   *
+   * @example "device-status"
+   * @example "user-settings"
+   * @example "maintenance-scheduler"
+   */
+  namespace: string;
+
+  /**
+   * Current active locale for this translation model.
+   * Determines which language variant to load and display.
+   *
+   * @example "en" - English
+   * @example "es" - Spanish
+   * @example "pt-BR" - Brazilian Portuguese
+   */
+  currentLocale: string;
+
+  /**
+   * Default fallback locale when translations are missing in the current locale.
+   * Typically set to the primary application language.
+   *
+   * @default "en"
+   */
+  defaultLocale: string;
+
+  /**
+   * Optional base URL for translation file loading.
+   * Used with default file-based resolution strategy.
+   *
+   * @example "/assets/locales"
+   * @example "https://cdn.example.com/translations"
+   */
+  rootUrl?: string;
+
+  /**
+   * Locale descriptors defining fallback chains and configuration for each locale.
+   * Maps locale codes to their fallback hierarchy and metadata.
+   */
+  descriptor: Record<string, LocaleDescriptor>;
+
+  /**
+   * Optional custom path resolver for translation file loading.
+   * Overrides default path construction logic.
+   *
+   * @param namespace - Target translation namespace
+   * @param locale - Target locale code
+   * @returns Full path to translation resource
+   */
+  resolver?: (namespace: string, locale: string) => string;
+
+  /**
+   * Optional custom bundle resolver for advanced translation loading strategies.
+   * Enables loading from APIs, device storage, or custom sources.
+   *
+   * @param namespace - Target translation namespace
+   * @param locale - Target locale code
+   * @param context - KOS context for accessing shared data
+   * @returns Promise resolving to translation data
+   */
+  bundleResolver?: (
+    namespace: string,
+    locale: string,
+    context?: KosContext
+  ) => Promise<TranslationResponse>;
+}
+
+// ---------------  TranslationContainer ---------------
+
+/**
+ * Configuration options for TranslationContainer model instances.
+ *
+ * This interface defines the configuration structure for translation container models,
+ * which manage multiple translation namespaces and coordinate global locale switching.
+ * Containers serve as the central orchestration point for internationalization in KOS
+ * applications.
+ *
+ * @example Basic Container Configuration
+ * ```typescript
+ * // Multi-namespace application translations
+ * const containerOptions: TranslationContainerOptions = {
+ *   lang: 'es',
+ *   defaultNamespace: 'common',
+ *   descriptor: {
+ *     namespaces: {
+ *       'common': {
+ *         basePath: '/assets/locales',
+ *         locales: {
+ *           'en': { file: 'en/common.json', defaultLocale: 'en' },
+ *           'es': { file: 'es/common.json', defaultLocale: 'en' },
+ *           'fr': { file: 'fr/common.json', defaultLocale: 'en' }
+ *         }
+ *       },
+ *       'dashboard': {
+ *         basePath: '/assets/locales',
+ *         locales: {
+ *           'en': { file: 'en/dashboard.json', defaultLocale: 'en' },
+ *           'es': { file: 'es/dashboard.json', defaultLocale: 'en' },
+ *           'fr': { file: 'fr/dashboard.json', defaultLocale: 'en' }
+ *         }
+ *       }
+ *     }
+ *   }
+ * };
+ *
+ * const appTranslations = TranslationContainer.instance('app-i18n')
+ *   .options(containerOptions)
+ *   .build();
+ * ```
+ *
+ * @example CDN-Based Translation Loading
+ * ```typescript
+ * // Custom resolver for CDN-hosted translations
+ * const cdnResolver = function(
+ *   namespace: string,
+ *   locale: string
+ * ): string {
+ *   return `https://cdn.example.com/translations/${namespace}/${locale}.json`;
+ * };
+ *
+ * const cdnOptions: TranslationContainerOptions = {
+ *   lang: 'ja',
+ *   resolver: cdnResolver,
+ *   descriptor: {
+ *     namespaces: {
+ *       'device-control': {
+ *         basePath: '', // Ignored with custom resolver
+ *         locales: {
+ *           'ja': { file: '', defaultLocale: 'en' },
+ *           'en': { file: '', defaultLocale: 'en' }
+ *         }
+ *       }
+ *     }
+ *   }
+ * };
+ * ```
+ *
+ * @example Development Environment Setup
+ * ```typescript
+ * // Hot-reload friendly configuration for development
+ * const devOptions: TranslationContainerOptions = {
+ *   lang: 'en',
+ *   rootUrl: '/dev-translations',
+ *   descriptor: {
+ *     namespaces: {
+ *       'ui': {
+ *         basePath: '/ui-translations',
+ *         locales: {
+ *           'en': { file: 'en/ui.json', defaultLocale: 'en' },
+ *           'es': { file: 'es/ui.json', defaultLocale: 'en' }
+ *         }
+ *       },
+ *       'forms': {
+ *         basePath: '/form-translations',
+ *         locales: {
+ *           'en': { file: 'en/forms.json', defaultLocale: 'en' },
+ *           'es': { file: 'es/forms.json', defaultLocale: 'en' }
+ *         }
+ *       }
+ *     }
+ *   }
+ * };
+ * ```
+ *
+ * @group KOS Model
+ * @category i18n
+ */
+export interface TranslationContainerOptions {
+  /**
+   * Current application-wide locale setting.
+   * Applied to all child translation models when they are created or updated.
+   *
+   * @example "en" - English
+   * @example "es" - Spanish
+   * @example "pt-BR" - Brazilian Portuguese
+   */
+  lang: string;
+
+  /**
+   * Comprehensive locale and namespace descriptor defining the complete
+   * translation structure for the application.
+   */
+  descriptor: Localization;
+
+  /**
+   * Optional default namespace for application-wide common translations.
+   * When specified, provides easy access to shared UI elements and messages.
+   *
+   * @example "common"
+   * @example "shared"
+   * @example "ui-elements"
+   */
+  defaultNamespace?: string;
+
+  /**
+   * Optional base URL for all translation file loading.
+   * Applied as prefix to all translation resource paths.
+   *
+   * @example "/assets/locales"
+   * @example "https://cdn.example.com/app-translations"
+   * @example "/tenant-specific/translations"
+   */
+  rootUrl?: string;
+
+  /**
+   * Optional URL for loading translation descriptor dynamically.
+   * Enables runtime configuration of translation structure.
+   *
+   * @example "/api/translations/descriptor"
+   * @example "https://config.example.com/translation-manifest.json"
+   */
+  descriptorUrl?: string;
+
+  /**
+   * Optional custom resolver for translation file path construction.
+   * Overrides default path resolution logic for all namespaces.
+   *
+   * @param namespace - Target translation namespace
+   * @param locale - Target locale code
+   * @returns Full path to translation resource
+   */
+  resolver?: (
+    this: TranslationContainerModel,
+    namespace: string,
+    locale: string
+  ) => string;
+}
+
+/**
+ * Type definitions for variable interpolation in translation keys.
+ *
+ * Translation models support sophisticated variable substitution patterns
+ * for dynamic content in internationalized applications.
+ *
+ * @group KOS Model
+ * @category Internationalization
+ */
+export type ResolveTranslationOptions<T = string> =
+  | {
+      /**
+       * Context variables for template-based interpolation using {{variable}} syntax.
+       *
+       * @example
+       * ```typescript
+       * t('welcome.message', {
+       *   context: { username: 'John', unreadCount: 5 }
+       * })
+       * // "Welcome {{username}}, you have {{unreadCount}} messages"
+       * // Result: "Welcome John, you have 5 messages"
+       * ```
+       */
+      context?: Record<string, any>;
+
+      /**
+       * Data variables for macro-based interpolation using __variable__ syntax.
+       *
+       * @example
+       * ```typescript
+       * t('system.info', {
+       *   data: { version: '2.1.0', platform: 'Linux' }
+       * })
+       * // "System __version__ running on __platform__"
+       * // Result: "System 2.1.0 running on Linux"
+       * ```
+       */
+      data?: Record<string, any>;
+
+      /**
+       * Contextual modifier for conditional key resolution.
+       * Enables different translations based on application state.
+       *
+       * @example
+       * ```typescript
+       * // Translation file: { "title": "Create", "title_edit": "Update" }
+       * t('title', { context: 'edit' })
+       * // Resolves to "title_edit" key, returns "Update"
+       * ```
+       */
+      context?: string;
+
+      /**
+       * Fallback value when translation key is not found.
+       * Ensures graceful degradation for missing translations.
+       */
+      defaultValue?: T;
+    }
+  | string;
+
+declare global {
+  interface AbstractModelFactory {
+    createTranslation: (id: string, options: TranslationOptions) => Translation;
+    createTranslationContainer: (
+      options: TranslationContainerOptions
+    ) => TranslationContainer;
+  }
+}

package/models/models/trouble/handlers/resolvable-trouble-handler.d.ts

@@ -0,0 +1,16 @@
+import { TroubleHandler } from '../../../../core';
+
+export declare class ResolvableTroubleHandler implements TroubleHandler {
+    type: string;
+    title: string;
+    subtitle: string;
+}
+export declare class BlockPumpTroubleHandler implements TroubleHandler {
+    type: string;
+    title: string;
+    subtitle: string;
+}
+export declare class TroubleHandlerFactory {
+    static getHandler(type: string): TroubleHandler | undefined;
+}
+//# sourceMappingURL=resolvable-trouble-handler.d.ts.map

package/models/models/trouble/handlers/resolvable-trouble-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvable-trouble-handler.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble/handlers/resolvable-trouble-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,qBAAa,wBAAyB,YAAW,cAAc;IAC7D,IAAI,SAAuB;IAC3B,KAAK,SAAwB;IAC7B,QAAQ,SAAa;CACtB;AAED,qBAAa,uBAAwB,YAAW,cAAc;IAC5D,IAAI,SAAsB;IAC1B,KAAK,SAAwB;IAC7B,QAAQ,SAAa;CACtB;AAED,qBAAa,qBAAqB;IAChC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;CAU5D"}

package/models/models/trouble/index.d.ts

@@ -0,0 +1,9 @@
+import * as TroubleServices from "./services";
+export { Trouble } from './trouble-registration';
+export type { DeferAware, ResolveAware, TroubleAware, TroubleModel, TroubleOptions, } from './types';
+export * from './utils/is-trouble-aware';
+export { EXTENSION_TROUBLE_DATA_MAPPER } from './utils/trouble-data-extension';
+export { EXTENSION_TROUBLE_MAPPER } from './utils/trouble-extension';
+export * from './utils/trouble-reducer';
+export { TroubleServices };
+//# sourceMappingURL=index.d.ts.map

package/models/models/trouble/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,eAAe,MAAM,YAAY,CAAC;AAE9C,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,YAAY,EACV,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,cAAc,GACf,MAAM,SAAS,CAAC;AACjB,cAAc,0BAA0B,CAAC;AACzC,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,cAAc,yBAAyB,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/models/models/trouble/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './trouble-services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/trouble/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/models/models/trouble/services/trouble-services.d.ts

@@ -0,0 +1,23 @@
+import { FutureResponse } from '../../../services/future';
+import { KosServiceResponse } from '../../../../core';
+
+export interface TroubleResponse {
+    reason: string;
+    createTime: string;
+    resolvable: boolean;
+    ifaces: string[];
+    id: string;
+    clientData: any;
+    type: string;
+    tags: string[];
+    info: any;
+}
+/**
+ * @category Service
+ * @internal
+ * Retrieves the initial Trouble data.
+ */
+export declare const getTroubles: (servicePath: string) => Promise<KosServiceResponse<TroubleResponse[]> | undefined>;
+export declare const resolveTrouble: (troubleId: string, servicePath?: string, tracker?: string) => Promise<FutureResponse>;
+export declare const bulkResolveTroubles: (troubleIds: string[], servicePath?: string, tracker?: string) => Promise<FutureResponse>;
+//# sourceMappingURL=trouble-services.d.ts.map

package/models/models/trouble/services/trouble-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trouble-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble/services/trouble-services.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EACL,kBAAkB,EAGnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAkB,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAO1E,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,GAAG,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,GAAG,CAAC;CACX;AACD;;;;GAIG;AACH,eAAO,MAAM,WAAW,gBAAuB,MAAM,+DAKpD,CAAC;AAEF,eAAO,MAAM,cAAc,cACd,MAAM,kCAEP,MAAM,4BAsBjB,CAAC;AAEF,eAAO,MAAM,mBAAmB,eAClB,MAAM,EAAE,kCAEV,MAAM,4BAuBjB,CAAC"}

package/models/models/trouble/trouble-model.d.ts

@@ -0,0 +1,43 @@
+import { DeferAware, TroubleModel, TroubleOptions } from './types';
+import { FutureAwareContainer } from '../future/future-types';
+import { IKosModelLogger, KosContextLogger, KosCreationContext } from '../../../core';
+
+export declare const MODEL_TYPE = "trouble-model";
+export declare class TroubleModelImpl<AdditionalData extends object = any> implements TroubleModel<AdditionalData>, IKosModelLogger {
+    id: string;
+    logger: KosContextLogger;
+    private _troubleId;
+    private _resolvable;
+    type: string;
+    futureHandler: FutureAwareContainer;
+    ifaces: string[];
+    clientData: unknown;
+    info: unknown;
+    role: string;
+    color: string;
+    tags: string[];
+    data: AdditionalData;
+    rank: number;
+    servicePath: string;
+    group?: string;
+    createTime?: string;
+    private _mapped;
+    constructor(modelId: string, { resolvable, tags, info, id, clientData, rank, ifaces, type, group, createTime, role, color, servicePath, ...rest }: TroubleOptions, context: KosCreationContext);
+    getTitleWithContext(context: string): string;
+    getSubtitleWithContext(context: string): string;
+    get rawId(): string;
+    get title(): string;
+    get subtitle(): string;
+    get troubleId(): string;
+    get resolvable(): boolean;
+    get future(): import('../future/future-types').IFutureModel<Record<string, unknown>> | undefined;
+    resolveMappedData(): Promise<any>;
+    get deferredCompanion(): (import('../../../core').IKosDataModel & DeferAware) | undefined;
+    get deferred(): boolean;
+    get shouldDefer(): boolean;
+    clearDefer(): void;
+    defer(): void;
+    getChildren(): import('../future/future-types').IFutureModel<Record<string, unknown>>[];
+    resolve(tracker?: string): Promise<import('../..').FutureResponse | undefined>;
+}
+//# sourceMappingURL=trouble-model.d.ts.map

package/models/models/trouble/trouble-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trouble-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble/trouble-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACxB,MAAM,eAAe,CAAC;AAGvB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAInE,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAExE,eAAO,MAAM,UAAU,kBAAkB,CAAC;AAM1C,qBACa,gBAAgB,CAAC,cAAc,SAAS,MAAM,GAAG,GAAG,CAC/D,YAAW,YAAY,CAAC,cAAc,CAAC,EAAE,eAAe;IAExD,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,WAAW,CAAU;IAE7B,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,oBAAoB,CAAC;IACpC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,OAAO,CAAwB;gBAErC,OAAO,EAAE,MAAM,EACf,EACE,UAAU,EACV,IAAI,EACJ,IAAI,EACJ,EAAE,EACF,UAAU,EACV,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,KAAK,EACL,UAAU,EACV,IAAI,EACJ,KAAK,EACL,WAAW,EACX,GAAG,IAAI,EACR,EAAE,cAAc,EACjB,OAAO,EAAE,kBAAkB;IAyB7B,mBAAmB,CAAC,OAAO,EAAE,MAAM;IAWnC,sBAAsB,CAAC,OAAO,EAAE,MAAM;IAWtC,IAAI,KAAK,WAER;IACD,IAAI,KAAK,WAER;IAED,IAAI,QAAQ,WAEX;IAED,IAAI,SAAS,WAEZ;IAED,IAAI,UAAU,YAEb;IAED,IAAI,MAAM,uFAET;IAEK,iBAAiB;IAIvB,IAAI,iBAAiB,qEAMpB;IACD,IAAI,QAAQ,YAKX;IACD,IAAI,WAAW,IAAI,OAAO,CAMzB;IAED,UAAU;IAGV,KAAK;IAIL,WAAW;IAML,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM;CAc/B"}

package/models/models/trouble/trouble-registration.d.ts

@@ -0,0 +1,84 @@
+import { TroubleModel, TroubleOptions } from './types';
+import { KosModelRegistrationBean } from '../../../core';
+
+/**
+ * # Translation
+ *
+ * The registration bean includes convenience methods for creating and working with TranslationModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: Translation.type, id: "translationId"})
+ * private translationModel: TranslationModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new TranslationModel instances.
+ *
+ 
+ * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
+ *
+ * If a model with the specified id already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = Translation.factory("translationId")({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a TranslationModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (Translation.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to TranslationModel
+ *    // and the compiler will know that the model has the TranslationModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { Translation } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...Translation.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The translation model is NOT a singleton model.  This means that each time the factory function is called with a unique ID, a new model instance will be created.
+ * If the factory function is called with an ID that already exists, the existing model will be returned.
+ 
+ * */
+export declare const Trouble: Readonly<KosModelRegistrationBean<TroubleModel, TroubleOptions>>;
+//# sourceMappingURL=trouble-registration.d.ts.map

package/models/models/trouble/trouble-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trouble-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble/trouble-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAG9D,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8EK;AACL,eAAO,MAAM,OAAO,EAAE,QAAQ,CAC5B,wBAAwB,CAAC,YAAY,EAAE,cAAc,CAAC,CAWvD,CAAC"}