@limetech/lime-web-components 6.7.0 → 6.8.0

package/dist/problem/provider.d.ts

@@ -0,0 +1,192 @@
+import { Action } from '../action';
+import { Icon } from '../core';
+import { Problem } from './problem';
+import { ProblemQueryOptions, ProblemStatus, ProblemType } from './query';
+/**
+ * Interface that packages implement to provide problems to the platform.
+ *
+ * Providers are responsible for:
+ * - Storing and managing their own problems
+ * - Defining problem types with display information
+ * - Supplying actions users can take on problems
+ * - Responding to queries from the platform
+ *
+ * The platform aggregates problems from all registered providers.
+ *
+ * @example
+ * Provider implementation
+ * ```typescript
+ * class EmailProblemProvider implements ProblemProvider {
+ *     id = 'email-integration';
+ *     title = 'Email Integration';
+ *     description = 'Problems related to email sending and delivery';
+ *     icon = 'envelope';
+ *
+ *     private types: ProblemType[] = [
+ *         { id: 'delivery-failed', title: 'Delivery Failed' }
+ *     ];
+ *
+ *     private statuses: ProblemStatus[] = [
+ *         { id: 'open', title: 'Open' },
+ *         { id: 'resolved', title: 'Resolved' }
+ *     ];
+ *
+ *     getTypes(): ProblemType[] { return this.types; }
+ *     getType(type: string): ProblemType | undefined {
+ *         return this.types.find(t => t.id === type);
+ *     }
+ *     getStatuses(): ProblemStatus[] { return this.statuses; }
+ *     getStatus(status: string): ProblemStatus | undefined {
+ *         return this.statuses.find(s => s.id === status);
+ *     }
+ *     // ... implement remaining methods
+ * }
+ * ```
+ *
+ * @example
+ * Registering a provider
+ * ```typescript
+ * const repository = platform.get(PlatformServiceName.ProblemRepository);
+ * repository.registerProvider(new EmailProblemProvider());
+ * ```
+ *
+ * @see {@link ProblemRepository} for registering providers and querying problems
+ * @see {@link Problem} for the problem structure
+ * @see {@link ProblemQueryOptions} for query filtering
+ * @see {@link ProblemType} for problem type display information
+ * @see {@link Action} for problem actions
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface ProblemProvider {
+    /**
+     * Unique identifier for this provider.
+     *
+     * Used to identify the provider in the repository and to link problems back
+     * to their source. Should be a stable, lowercase identifier using hyphens
+     * for word separation (e.g., 'email-integration', 'external-crm-sync').
+     *
+     * The platform uses this id to set {@link Problem.providerId} when
+     * returning problems to consumers.
+     */
+    id: string;
+    /**
+     * Human-readable title for the provider.
+     *
+     * Should clearly identify the source of problems
+     * (e.g., 'Email Integration', 'External CRM Sync').
+     */
+    title: string;
+    /**
+     * Description of what problems this provider handles.
+     */
+    description: string;
+    /**
+     * Icon representing this provider.
+     *
+     * Can be either a string referencing an icon name from the platform's icon
+     * library, or an {@link Icon} object with additional properties like color.
+     *
+     * @see {@link Icon}
+     */
+    icon: string | Icon;
+    /**
+     * Retrieves problems from this provider.
+     *
+     * Implement filtering based on the provided options where supported.
+     * Unsupported filters should be silently ignored.
+     *
+     * @param options - Query options for filtering and pagination. All properties
+     * are optional. Providers should handle what they support and ignore the rest.
+     * @returns A promise resolving to an array of problems matching the query.
+     *
+     * @see {@link ProblemQueryOptions}
+     */
+    getProblems(options?: ProblemQueryOptions): Promise<Omit<Problem, 'providerId'>[]>;
+    /**
+     * Returns the count of problems matching the query options.
+     *
+     * Should return the total count of matching problems, not affected by
+     * pagination (limit/offset).
+     *
+     * @param options - Query options for filtering. Pagination options (limit/offset)
+     * should be ignored when counting.
+     * @returns A promise resolving to the number of matching problems.
+     */
+    getCount(options?: ProblemQueryOptions): Promise<number>;
+    /**
+     * Retrieves a specific problem by its id.
+     *
+     * @param id - The unique identifier of the problem within this provider.
+     * @returns A promise resolving to the problem if found, or undefined if
+     * no problem with that id exists.
+     */
+    get(id: string): Promise<Omit<Problem, 'providerId'> | undefined>;
+    /**
+     * Returns available actions for a specific problem.
+     *
+     * Actions allow users to take action on problems (e.g., retry, dismiss,
+     * navigate to configuration). Each action wraps a command that executes
+     * when triggered.
+     *
+     * @param problem - The problem to get actions for.
+     * @returns An array of actions available for this problem. Return an empty
+     * array `[]` if no actions are available.
+     *
+     * @see {@link Action}
+     */
+    getActions(problem: Problem): Action[];
+    /**
+     * Returns all problem types supported by this provider.
+     *
+     * Used by the platform to render type filters and understand
+     * the provider's problem categories.
+     *
+     * @returns An array of all problem types this provider can produce.
+     *
+     * @see {@link ProblemType}
+     * @see {@link Problem."type"}
+     */
+    getTypes(): ProblemType[];
+    /**
+     * Returns display information for a problem type.
+     *
+     * Problem types are provider-specific identifiers (e.g., 'delivery-failed',
+     * 'connection-error'). This method provides the human-readable title,
+     * description, and icon for each type.
+     *
+     * @param type - The problem type identifier (from {@link Problem."type"}).
+     * @returns Display information for the type, or undefined if the type
+     * is not recognized by this provider.
+     *
+     * @see {@link ProblemType}
+     * @see {@link Problem."type"}
+     */
+    getType(type: string): ProblemType | undefined;
+    /**
+     * Returns all statuses supported by this provider.
+     *
+     * Used by the platform to render status filters and understand
+     * the provider's workflow.
+     *
+     * @returns An array of all statuses this provider uses. Return an empty
+     * array `[]` if this provider doesn't track status.
+     *
+     * @see {@link ProblemStatus}
+     * @see {@link Problem.status}
+     */
+    getStatuses(): ProblemStatus[];
+    /**
+     * Returns display information for a problem status.
+     *
+     * @param status - The status identifier (from {@link Problem.status}).
+     * @returns Display information for the status, or undefined if the status
+     * is not recognized by this provider.
+     *
+     * @see {@link ProblemStatus}
+     * @see {@link Problem.status}
+     */
+    getStatus(status: string): ProblemStatus | undefined;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/problem/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/problem/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,WAAW,eAAe;IAC5B;;;;;;;;;OASG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;;;OAOG;IACH,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpB;;;;;;;;;;;OAWG;IACH,WAAW,CACP,OAAO,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IAE1C;;;;;;;;;OASG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzD;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC,GAAG,SAAS,CAAC,CAAC;IAElE;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;IAEvC;;;;;;;;;;OAUG;IACH,QAAQ,IAAI,WAAW,EAAE,CAAC;IAE1B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IAE/C;;;;;;;;;;;OAWG;IACH,WAAW,IAAI,aAAa,EAAE,CAAC;IAE/B;;;;;;;;;OASG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;CACxD"}

package/dist/problem/query.d.ts

@@ -0,0 +1,312 @@
+import { Icon } from '../core';
+import { ProblemSeverity } from './problem';
+/**
+ * Filter for querying problems related to {@link LimeObject}s.
+ *
+ * Used with {@link ProblemQueryOptions.context} to find problems linked to
+ * specific limeobjects. The limetype is always required, while id is optional:
+ * - With only `limetype`: Returns all problems related to that object type
+ * - With both `limetype` and `id`: Returns problems for that specific object
+ *
+ * @example
+ * Find all problems related to contacts
+ * ```typescript
+ * const contactProblems = await provider.getProblems({
+ *     context: { limetype: 'contact' }
+ * });
+ * ```
+ *
+ * @example
+ * Find problems for a specific deal
+ * ```typescript
+ * const dealProblems = await provider.getProblems({
+ *     context: {
+ *         limetype: 'deal',
+ *         id: 12345
+ *     }
+ * });
+ * ```
+ *
+ * @see {@link ProblemQueryOptions.context}
+ * @see {@link ProblemContext} for the context stored on problems
+ *
+ * @alpha
+ * @group Problem
+ */
+export type ProblemContextFilter = {
+    /**
+     * The limetype to filter by (e.g., 'contact', 'deal', 'company').
+     *
+     * This is required because object ids are only unique within a limetype.
+     */
+    limetype: string;
+    /**
+     * The specific object id to filter by.
+     *
+     * When omitted, matches all problems related to the specified limetype.
+     */
+    id?: number;
+};
+/**
+ * Options for querying problems from a {@link ProblemProvider}.
+ *
+ * All filter properties are optional. Providers handle what they support and
+ * silently ignore unsupported filters. This allows the platform to pass a
+ * consistent set of filters without needing to know each provider's capabilities.
+ *
+ * Multiple values can be provided for most filters (severity, status, type, tags)
+ * to match problems that have any of the specified values (OR logic).
+ *
+ * @example
+ * Get all open problems
+ * ```typescript
+ * const openProblems = await provider.getProblems({
+ *     status: 'open'
+ * });
+ * ```
+ *
+ * @example
+ * Get high-priority unresolved problems with pagination
+ * ```typescript
+ * const urgentProblems = await provider.getProblems({
+ *     severity: [ProblemSeverity.High, ProblemSeverity.Critical],
+ *     status: ['open', 'acknowledged'],
+ *     limit: 20,
+ *     offset: 0
+ * });
+ * ```
+ *
+ * @example
+ * Get problems for a specific type and user
+ * ```typescript
+ * const userEmailProblems = await provider.getProblems({
+ *     type: 'email.delivery-failed',
+ *     userId: 'user-123'
+ * });
+ * ```
+ *
+ * @example
+ * Get problems related to a specific limeobject
+ * ```typescript
+ * const dealProblems = await provider.getProblems({
+ *     context: {
+ *         limetype: 'deal',
+ *         id: 98765
+ *     }
+ * });
+ * ```
+ *
+ * @see {@link ProblemProvider.getProblems}
+ * @see {@link ProblemProvider.getCount}
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface ProblemQueryOptions {
+    /**
+     * Filter by severity level(s).
+     *
+     * When a single value is provided, returns problems with that severity.
+     * When an array is provided, returns problems matching any of the severities.
+     *
+     * @see {@link ProblemSeverity}
+     */
+    severity?: ProblemSeverity | ProblemSeverity[];
+    /**
+     * Filter by status(es).
+     *
+     * Status values are provider-defined strings. When a single value is provided,
+     * returns problems with that status. When an array is provided, returns
+     * problems matching any of the statuses.
+     *
+     * @see {@link Problem.status}
+     */
+    status?: string | string[];
+    /**
+     * Filter by problem type(s).
+     *
+     * Types are provider-specific strings like 'email.delivery-failed' or
+     * 'sync.connection-error'. When an array is provided, returns problems
+     * matching any of the types.
+     *
+     * @see {@link Problem."type"}
+     */
+    type?: string | string[];
+    /**
+     * Filter by tag(s).
+     *
+     * Returns problems that have any of the specified tags (OR logic).
+     *
+     * @see {@link Problem.tags}
+     */
+    tags?: string[];
+    /**
+     * Filter by user identifier.
+     *
+     * Returns problems associated with the specified user.
+     *
+     * @see {@link Problem.userId}
+     */
+    userId?: string;
+    /**
+     * Filter by related {@link LimeObject}.
+     *
+     * Use this to find problems linked to a specific limetype or object instance.
+     *
+     * @see {@link ProblemContextFilter}
+     * @see {@link Problem.context}
+     */
+    context?: ProblemContextFilter;
+    /**
+     * Maximum number of problems to return.
+     *
+     * Used for pagination. When omitted, the provider decides the default limit.
+     */
+    limit?: number;
+    /**
+     * Number of problems to skip before returning results.
+     *
+     * Used for pagination in combination with `limit`. For example, to get
+     * the second page of 20 items, use `{ limit: 20, offset: 20 }`.
+     */
+    offset?: number;
+}
+/**
+ * Display information for a problem type.
+ *
+ * Providers define multiple problem types (e.g., an Email Integration provider
+ * might have 'delivery-failed', 'validation-error', 'attachment-too-large').
+ * ProblemType provides the human-readable display information for each type.
+ *
+ * The platform retrieves this information via {@link ProblemProvider.getType}
+ * and {@link ProblemProvider.getTypes} to display problems with appropriate
+ * titles and icons.
+ *
+ * @example
+ * Implementing type methods in a provider
+ * ```typescript
+ * class EmailProblemProvider implements ProblemProvider {
+ *     private types: ProblemType[] = [
+ *         {
+ *             id: 'delivery-failed',
+ *             title: 'Delivery Failed',
+ *             description: 'Email could not be delivered to the recipient',
+ *             icon: 'envelope-exclamation'
+ *         },
+ *         {
+ *             id: 'validation-error',
+ *             title: 'Validation Error'
+ *         }
+ *     ];
+ *
+ *     getTypes(): ProblemType[] {
+ *         return this.types;
+ *     }
+ *
+ *     getType(type: string): ProblemType | undefined {
+ *         return this.types.find(t => t.id === type);
+ *     }
+ * }
+ * ```
+ *
+ * @see {@link ProblemProvider.getType}
+ * @see {@link ProblemProvider.getTypes}
+ * @see {@link Problem."type"}
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface ProblemType {
+    /**
+     * The type identifier as used in {@link Problem."type"}.
+     */
+    id: string;
+    /**
+     * Human-readable title for the problem type.
+     *
+     * Displayed as the primary label for problems of this type. Should be
+     * concise but descriptive (e.g., 'Delivery Failed', 'Connection Error').
+     */
+    title: string;
+    /**
+     * Detailed description of what this type of problem means.
+     *
+     * Provides context to help users understand the nature of the problem.
+     * May be displayed in tooltips or detail views.
+     */
+    description?: string;
+    /**
+     * Icon to display for problems of this type.
+     *
+     * Can be either a string referencing an icon name from the platform's icon
+     * library, or an {@link Icon} object with additional properties like color.
+     *
+     * @see {@link Icon}
+     */
+    icon?: string | Icon;
+}
+/**
+ * Display information for a problem status.
+ *
+ * Since status values are provider-defined, providers must supply display
+ * information for their statuses so the platform can render them appropriately.
+ *
+ * @example
+ * Implementing getStatus in a provider
+ * ```typescript
+ * class EmailProblemProvider implements ProblemProvider {
+ *     private statusInfoMap: Record<string, ProblemStatus> = {
+ *         'open': {
+ *             id: 'open',
+ *             title: 'Open',
+ *             icon: 'circle'
+ *         },
+ *         'pending-retry': {
+ *             id: 'pending-retry',
+ *             title: 'Pending Retry',
+ *             icon: 'clock'
+ *         },
+ *         'resolved': {
+ *             id: 'resolved',
+ *             title: 'Resolved',
+ *             icon: 'check-circle'
+ *         }
+ *     };
+ *
+ *     getStatus(status: string): ProblemStatus | undefined {
+ *         return this.statusInfoMap[status];
+ *     }
+ *
+ *     getStatuses(): ProblemStatus[] {
+ *         return Object.values(this.statusInfoMap);
+ *     }
+ * }
+ * ```
+ *
+ * @see {@link ProblemProvider.getStatus}
+ * @see {@link ProblemProvider.getStatuses}
+ * @see {@link Problem.status}
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface ProblemStatus {
+    /**
+     * The status identifier as used in {@link Problem.status}.
+     */
+    id: string;
+    /**
+     * Human-readable title for the status.
+     */
+    title: string;
+    /**
+     * Icon to display for this status.
+     *
+     * Can be either a string referencing an icon name from the platform's icon
+     * library, or an {@link Icon} object with additional properties like color.
+     *
+     * @see {@link Icon}
+     */
+    icon?: string | Icon;
+}
+//# sourceMappingURL=query.d.ts.map

package/dist/problem/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/problem/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAC/B;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,WAAW,mBAAmB;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,eAAe,GAAG,eAAe,EAAE,CAAC;IAE/C;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE3B;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAEzB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAE/B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,WAAW,WAAW;IACxB;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,WAAW,aAAa;IAC1B;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB"}

package/dist/problem/repository.d.ts

@@ -0,0 +1,111 @@
+import { Problem } from './problem';
+import { ProblemProvider } from './provider';
+import { ProblemQueryOptions } from './query';
+/**
+ * Repository for accessing problems from registered providers.
+ *
+ * The repository is the primary interface for consumers to interact with
+ * problems. It provides a unified API for querying, counting, and retrieving
+ * problems from registered {@link ProblemProvider}s.
+ *
+ * Packages register their providers with the repository during initialization.
+ * Consumers then use the repository's query methods rather than interacting
+ * with providers directly.
+ *
+ * @example
+ * Registering a provider
+ * ```typescript
+ * const repository = platform.get(PlatformServiceName.ProblemRepository);
+ * repository.registerProvider(new EmailProblemProvider());
+ * ```
+ *
+ * @example
+ * Fetching problems from a provider
+ * ```typescript
+ * const repository = platform.get(PlatformServiceName.ProblemRepository);
+ * const problems = await repository.getProblems('email-integration', {
+ *     severity: ProblemSeverity.Critical
+ * });
+ * ```
+ *
+ * @example
+ * Getting actions for a problem
+ * ```typescript
+ * const problem = await repository.get('email-integration', 'prob-123');
+ * const provider = repository.getProvider(problem.providerId);
+ * const actions = provider.getActions(problem);
+ * ```
+ *
+ * @see {@link ProblemProvider} for the provider interface
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface ProblemRepository {
+    /**
+     * Registers a problem provider with the repository.
+     *
+     * The provider's {@link ProblemProvider.id} must be unique. Registering
+     * a provider with an id that already exists will throw an error.
+     *
+     * @param provider - The provider to register. Must have a unique id.
+     * @throws Error if a provider with the same id is already registered.
+     */
+    registerProvider(provider: ProblemProvider): void;
+    /**
+     * Returns all registered providers.
+     *
+     * Useful for displaying provider information in the UI, such as
+     * provider titles and icons for filtering.
+     *
+     * @returns An array of all registered providers.
+     */
+    getProviders(): ProblemProvider[];
+    /**
+     * Returns a specific provider by its id.
+     *
+     * @param id - The unique identifier of the provider.
+     * @returns The provider if found, undefined otherwise.
+     */
+    getProvider(id: string): ProblemProvider | undefined;
+    /**
+     * Fetches problems from a provider matching the query options.
+     *
+     * @param providerId - The provider id to query.
+     * @param options - Optional filtering and pagination options.
+     * @returns A promise resolving to an array of problems.
+     * @throws Error if no provider with the given id is registered.
+     *
+     * @example
+     * ```typescript
+     * const emailProblems = await repository.getProblems('email-integration');
+     *
+     * const criticalProblems = await repository.getProblems(
+     *     'email-integration',
+     *     { severity: ProblemSeverity.Critical }
+     * );
+     * ```
+     */
+    getProblems(providerId: string, options?: ProblemQueryOptions): Promise<Problem[]>;
+    /**
+     * Returns the count of problems from a provider.
+     *
+     * More efficient than fetching all problems when only the count is needed.
+     *
+     * @param providerId - The provider id to query.
+     * @param options - Optional filtering options.
+     * @returns A promise resolving to the count.
+     * @throws Error if no provider with the given id is registered.
+     */
+    getCount(providerId: string, options?: ProblemQueryOptions): Promise<number>;
+    /**
+     * Retrieves a specific problem by provider and problem id.
+     *
+     * @param providerId - The id of the provider that owns the problem.
+     * @param problemId - The id of the problem within that provider.
+     * @returns A promise resolving to the problem if found, undefined otherwise.
+     * @throws Error if no provider with the given id is registered.
+     */
+    get(providerId: string, problemId: string): Promise<Problem | undefined>;
+}
+//# sourceMappingURL=repository.d.ts.map

package/dist/problem/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../src/problem/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;;;;;;;OAQG;IACH,gBAAgB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAAC;IAElD;;;;;;;OAOG;IACH,YAAY,IAAI,eAAe,EAAE,CAAC;IAElC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAAC;IAErD;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CACP,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAEtB;;;;;;;;;OASG;IACH,QAAQ,CACJ,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAAC;IAEnB;;;;;;;OAOG;IACH,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;CAC5E"}

package/dist/problem/types.d.ts

@@ -0,0 +1,15 @@
+import { ProblemRepository as Service } from './repository';
+declare const SERVICE_NAME = "problemRepository";
+declare module '../core/platform' {
+    interface PlatformServiceNameType {
+        /**
+         * @see {@link Service | ProblemRepository}
+         */
+        ProblemRepository: typeof SERVICE_NAME;
+    }
+    interface LimeWebComponentPlatform {
+        get(name: PlatformServiceNameType['ProblemRepository']): Service;
+    }
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/problem/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/problem/types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5D,QAAA,MAAM,YAAY,sBAAsB,CAAC;AAIzC,OAAO,QAAQ,kBAAkB,CAAC;IAC9B,UAAU,uBAAuB;QAC7B;;WAEG;QACH,iBAAiB,EAAE,OAAO,YAAY,CAAC;KAC1C;IACD,UAAU,wBAAwB;QAC9B,GAAG,CAAC,IAAI,EAAE,uBAAuB,CAAC,mBAAmB,CAAC,GAAG,OAAO,CAAC;KACpE;CACJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/lime-web-components",
-  "version": "6.7.0",
+  "version": "6.8.0",
   "description": "Lime Web Components",
   "author": "Lime Technologies",
   "license": "Apache-2.0",
@@ -40,7 +40,7 @@
     "@microsoft/api-extractor": "^7.55.2",
     "eslint": "^9.39.2",
     "expect-type": "^1.3.0",
-    "globals": "^17.0.0",
+    "globals": "^17.2.0",
     "jsdom": "^27.4.0",
     "replace-in-file": "^8.4.0",
     "shelljs": "0.10.0",
@@ -49,7 +49,7 @@
     "typescript": "^4.9.5",
     "vite": "^7.3.1",
     "vite-plugin-dts": "^4.5.0",
-    "vitest": "^4.0.17",
+    "vitest": "^4.0.18",
     "yargs": "^18.0.0"
   },
   "keywords": [