@aastrika_npmjs/sunbird-sdk 5.1.1

package/content/def/content-feedback-service.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { ContentFeedback, ContentFeedbackFilterCriteria } from './content';
+export interface ContentFeedbackService {
+    /**
+     * This api is used to save the feedback about content.
+     *
+     * @param contentFeedback - {@link ContentFeedback}
+     */
+    sendFeedback(contentFeedback: ContentFeedback): Observable<boolean>;
+    /**
+     * This api is used to get the feedback about a content.
+     * <p>
+     * <p>On successful fetching the data, the response will return
+     * status as TRUE and with result type as {@link ContentFeedback}, if content has any feedback then the result will not be null,
+     * <p>
+     * On failing to fetch the data, the response will return status as FALSE with the following error.
+     *
+     * @param contentFeedbackFilterCriteria - {@link ContentFeedbackFilterCriteria}
+     */
+    getFeedback(contentFeedbackFilterCriteria: ContentFeedbackFilterCriteria): Observable<ContentFeedback[]>;
+}

package/content/def/content-service.d.ts

@@ -0,0 +1,46 @@
+import { ChildContentRequest, ContentDelete, ContentDeleteRequest, ContentDetailRequest, ContentExportRequest, ContentImportRequest, ContentMarkerRequest, ContentRequest, ContentSearchCriteria, ContentSpaceUsageSummaryRequest, ContentSpaceUsageSummaryResponse, EcarImportRequest, RelevantContentRequest } from './requests';
+import { ApiRequestHandler, Response } from '../../api';
+import { Observable } from 'rxjs';
+import { Content, HierarchyInfo } from './content';
+import { ContentDeleteResponse, ContentExportResponse, ContentImportResponse, ContentSearchResult, RelevantContentResponsePlayer, SearchResponse } from './response';
+import { DownloadCompleteDelegate } from '../../util/download/def/download-complete-delegate';
+import { SdkServiceOnInitDelegate } from '../../sdk-service-on-init-delegate';
+import { ContentAggregator } from '../handlers/content-aggregator';
+import { FormService } from '../../form';
+import { CourseService } from '../../course';
+import { ProfileService } from '../../profile';
+import { SearchRequest } from "./search-request";
+export interface ContentService extends DownloadCompleteDelegate, SdkServiceOnInitDelegate {
+    getContentDetails(request: ContentDetailRequest): Observable<Content>;
+    getContentHeirarchy(request: ContentDetailRequest): Observable<Content>;
+    getContents(criteria: ContentRequest): Observable<Content[]>;
+    getChildContents(childContentRequest: ChildContentRequest): Observable<Content>;
+    searchContent(criteria: ContentSearchCriteria, request?: {
+        [key: string]: any;
+    }, apiHandler?: ApiRequestHandler<SearchRequest, SearchResponse>, isFromContentAggregator?: boolean): Observable<ContentSearchResult>;
+    deleteContent(contentDeleteRequest: ContentDeleteRequest): Observable<ContentDeleteResponse[]>;
+    enqueueContentDelete(contentDeleteRequest: ContentDeleteRequest): Observable<void>;
+    clearContentDeleteQueue(): Observable<void>;
+    getContentDeleteQueue(): Observable<ContentDelete[]>;
+    prevContent(hierarchyInfo: HierarchyInfo[], currentContentIdentifier: string): Observable<Content>;
+    nextContent(hierarchyInfo: HierarchyInfo[], currentContentIdentifier: string): Observable<Content>;
+    getRelevantContent(relevantContentRequest: RelevantContentRequest): Observable<RelevantContentResponsePlayer>;
+    importEcar(ecarImportRequest: EcarImportRequest): Observable<ContentImportResponse[]>;
+    importContent(contentImportRequest: ContentImportRequest): Observable<ContentImportResponse[]>;
+    subscribeForImportStatus(contentId: string): Observable<Response>;
+    cancelImport(contentId: string): Observable<any>;
+    exportContent(contentExportRequest: ContentExportRequest): Observable<ContentExportResponse>;
+    getDownloadState(): Promise<Response>;
+    cancelDownload(contentId: string): Observable<undefined>;
+    setContentMarker(contentMarkerRequest: ContentMarkerRequest): Observable<boolean>;
+    getContentSpaceUsageSummary(contentSpaceUsageSummaryRequest: ContentSpaceUsageSummaryRequest): Observable<ContentSpaceUsageSummaryResponse[]>;
+    buildContentAggregator(formService: FormService, courseService: CourseService, profileService: ProfileService): ContentAggregator;
+    getQuestionList(questionIds: string[], parentId?: string): Observable<any>;
+    getQuestionSetHierarchy(data: any): Observable<any>;
+    getQuestionSetRead(contentId: string, params?: any): Observable<any>;
+    getQuestionSetChildren(questionSetId: string): Promise<any[]>;
+    formatSearchCriteria(requestMap: {
+        [key: string]: any;
+    }): ContentSearchCriteria;
+    downloadTranscriptFile(directory: any): Promise<any>;
+}

package/content/def/content.d.ts

@@ -0,0 +1,43 @@
+import { Content as ContentData } from '@project-sunbird/client-services/models';
+import { Rollup } from '../../telemetry';
+import { ContentAccess } from '../../profile';
+import { ContentMarker } from './response';
+export { Content as ContentData, LicenseDetails, OriginData, Trackable, TrackingEnabled } from '@project-sunbird/client-services/models/content';
+export interface Content {
+    identifier: string;
+    name: string;
+    contentData: ContentData;
+    mimeType: string;
+    basePath: string;
+    contentType: string;
+    referenceCount: number;
+    lastUpdatedTime: number;
+    isAvailableLocally: boolean;
+    isUpdateAvailable: boolean;
+    children?: Content[];
+    hierarchyInfo?: HierarchyInfo[];
+    sizeOnDevice: number;
+    lastUsedTime: number;
+    rollup?: Rollup;
+    contentFeedback?: ContentFeedback[];
+    contentAccess?: ContentAccess[];
+    contentMarker?: ContentMarker[];
+    primaryCategory?: string;
+}
+export interface ContentFeedback {
+    contentId: string;
+    rating: number;
+    comments: string;
+    createdAt?: number;
+    stageId?: string;
+    contentVersion: string;
+}
+export interface ContentFeedbackFilterCriteria {
+    uid: string;
+    contentId: string;
+}
+export interface HierarchyInfo {
+    identifier: string;
+    contentType: string;
+    primaryCategory?: string;
+}

package/content/def/requests.d.ts

@@ -0,0 +1,219 @@
+import { ContentData, SearchType } from '..';
+import { Content, HierarchyInfo } from './content';
+import { CorrelationData, Rollup } from '../../telemetry';
+import { ContentImportResponse } from './response';
+import { ContentEntry } from '../db/schema';
+import { DownloadRequest } from '../../util/download';
+import { CachedItemRequest } from '../../key-value-store';
+export interface ContentAggregatorRequest extends CachedItemRequest {
+    applyFirstAvailableCombination?: {
+        [key in keyof ContentData]?: string[];
+    };
+    userPreferences?: {
+        [key: string]: string[] | string | undefined;
+    };
+    interceptSearchCriteria?: (searchCriteria: ContentSearchCriteria) => ContentSearchCriteria;
+}
+export interface ContentDecorateRequest {
+    content: Content;
+    attachFeedback?: boolean;
+    attachContentAccess?: boolean;
+    attachContentMarker?: boolean;
+}
+export interface ContentDetailRequest {
+    contentId: string;
+    objectType?: string;
+    emitUpdateIfAny?: boolean;
+    attachFeedback?: boolean;
+    attachContentAccess?: boolean;
+    attachContentMarker?: boolean;
+}
+export interface ContentRequest {
+    uid?: string | string[];
+    primaryCategories: string[];
+    audience?: string[];
+    pragma?: string[];
+    exclPragma?: string[];
+    attachFeedback?: boolean;
+    attachContentAccess?: boolean;
+    attachContentMarker?: boolean;
+    sortCriteria?: ContentSortCriteria[];
+    recentlyViewed?: boolean;
+    localOnly?: boolean;
+    resourcesOnly?: boolean;
+    limit?: number;
+    board?: string[];
+    medium?: string[];
+    grade?: string[];
+    dialcodes?: string[];
+    childNodes?: string[];
+}
+export interface ContentSortCriteria {
+    sortAttribute: string;
+    sortOrder: SortOrder;
+}
+export declare enum SortOrder {
+    ASC = "asc",
+    DESC = "desc"
+}
+export interface ChildContentRequest {
+    contentId: string;
+    hierarchyInfo: HierarchyInfo[];
+    level?: number;
+}
+export interface ContentDeleteRequest {
+    contentDeleteList: ContentDelete[];
+}
+export interface ContentDelete {
+    contentId: string;
+    isChildContent: boolean;
+}
+export interface EcarImportRequest {
+    isChildContent: boolean;
+    destinationFolder: string;
+    sourceFilePath: string;
+    correlationData: CorrelationData[];
+    rollUp?: Rollup;
+    identifier?: string;
+}
+export interface ContentImportRequest {
+    withPriority?: number;
+    contentImportArray: ContentImport[];
+    contentStatusArray: string[];
+    fields?: (keyof ContentData)[];
+}
+export interface ContentImport {
+    isChildContent: boolean;
+    destinationFolder: string;
+    contentId: string;
+    correlationData?: CorrelationData[];
+    rollUp?: Rollup;
+}
+export interface ContentExportRequest {
+    destinationFolder: string;
+    contentIds: string[];
+    saveLocally?: boolean;
+    subContentIds?: string[];
+}
+export interface ContentMarkerRequest {
+    contentId: string;
+    uid: string;
+    data: string;
+    extraInfo: {
+        [key: string]: any;
+    };
+    marker: MarkerType;
+    isMarked: boolean;
+}
+export declare enum MarkerType {
+    NOTHING = 0,
+    PREVIEWED = 1,
+    BOOKMARKED = 2
+}
+export interface ContentSearchCriteria {
+    query?: string;
+    exists?: string[];
+    offset?: number;
+    limit?: number;
+    mode?: string;
+    age?: number;
+    grade?: string[];
+    medium?: string[];
+    board?: string[];
+    createdBy?: string[];
+    audience?: string[];
+    channel?: string[];
+    purpose?: string[];
+    topic?: string[];
+    pragma?: string[];
+    exclPragma?: string[];
+    contentStatusArray?: string[];
+    facets?: string[];
+    contentTypes?: string[];
+    keywords?: string[];
+    dialCodes?: string[];
+    language?: string[];
+    offlineSearch?: boolean;
+    facetFilters?: ContentSearchFilter[];
+    impliedFilters?: ContentSearchFilter[];
+    impliedFiltersMap?: {
+        [key: string]: any;
+    }[];
+    sortCriteria?: ContentSortCriteria[];
+    searchType?: SearchType;
+    framework?: string;
+    languageCode?: string;
+    mimeType?: string[];
+    subject?: string[];
+    fields?: string[];
+    primaryCategories?: string[];
+}
+export interface ContentSearchFilter {
+    name: string;
+    values: FilterValue[];
+}
+export interface FilterValue {
+    name: string;
+    count?: number;
+    apply: boolean;
+    translations?: string;
+    description?: string;
+    index?: number;
+    values?: FilterValue[];
+}
+export interface ContentSortCriteria {
+    sortAttribute: string;
+    sortOrder: SortOrder;
+}
+export interface ImportContentContext {
+    isChildContent: boolean;
+    ecarFilePath: string;
+    destinationFolder: string;
+    metadata?: any;
+    manifestVersion?: string;
+    skippedItemsIdentifier?: string[];
+    items?: any[];
+    identifiers?: string[];
+    contentImportResponseList: ContentImportResponse[];
+    tmpLocation?: string;
+    rootIdentifier?: string;
+    correlationData?: CorrelationData[];
+    rollUp?: Rollup;
+    existedContentIdentifiers?: {
+        [identifier: string]: boolean;
+    };
+    contentIdsToDelete: Set<string>;
+    identifier?: string;
+}
+export interface ExportContentContext {
+    ecarFilePath?: string;
+    tmpLocationPath?: string;
+    destinationFolder: string;
+    items?: any[];
+    contentModelsToExport: ContentEntry.SchemaMap[];
+    metadata: {
+        [key: string]: any;
+    };
+    manifest?: any;
+    subContentIds?: string[];
+}
+export interface ContentDownloadRequest extends DownloadRequest {
+    contentMeta: Partial<Content>;
+    isChildContent?: boolean;
+    correlationData?: CorrelationData[];
+    rollUp?: Rollup;
+}
+export interface RelevantContentRequest extends DownloadRequest {
+    hierarchyInfo?: HierarchyInfo[];
+    contentIdentifier?: string;
+    next?: boolean;
+    prev?: boolean;
+    shouldConvertBasePath?: boolean;
+}
+export interface ContentSpaceUsageSummaryRequest {
+    paths: string[];
+}
+export interface ContentSpaceUsageSummaryResponse {
+    path: string;
+    sizeOnDevice: number;
+}

package/content/def/response.d.ts

@@ -0,0 +1,93 @@
+import { ContentSearchCriteria, ContentSearchFilter } from './requests';
+import { Content, ContentData } from './content';
+import { ContentImportStatus } from '..';
+import { Course } from '../../course/def/course';
+import { ContentAggregation } from '../handlers/content-aggregator';
+export interface ContentSearchResult {
+    id: string;
+    responseMessageId: string;
+    filterCriteria: ContentSearchCriteria;
+    request?: {
+        [key: string]: any;
+    };
+    contentDataList: ContentData[];
+    collectionDataList?: ContentData[];
+    count?: number;
+}
+export interface ContentAggregatorResponse {
+    result: ContentAggregation[];
+}
+export interface ContentsGroupedByPageSection {
+    name: string;
+    combination?: {
+        [key in keyof Content]?: string;
+    };
+    sections: PageSection[];
+}
+export interface PageSection {
+    count?: number;
+    name?: string;
+    contents?: ContentData[] | Course[];
+    display?: Display;
+    totalCount?: number;
+}
+export interface Display {
+    name: {
+        [key: string]: any;
+    };
+}
+export interface SearchResponse {
+    id: string;
+    params: {
+        resmsgid: string;
+    };
+    result: {
+        count: number;
+        content: ContentData[];
+        collections: ContentData[];
+        facets: ContentSearchFilter[];
+        QuestionSet?: ContentData[];
+    };
+}
+export interface ChildContent {
+    identifier: string;
+    name: string;
+    objectType: string;
+    relation: string;
+    index: number;
+}
+export interface ContentImportResponse {
+    identifier: string;
+    status: ContentImportStatus;
+}
+export interface ContentDeleteResponse {
+    identifier: string;
+    status: ContentDeleteStatus;
+}
+export declare enum ContentDeleteStatus {
+    NOT_FOUND = -1,
+    DELETED_SUCCESSFULLY = 1
+}
+export interface ContentMarker {
+    contentId: string;
+    uid: string;
+    extraInfoMap: {
+        [key: string]: any;
+    };
+    marker: number;
+}
+export interface ContentExportResponse {
+    exportedFilePath: string;
+}
+export interface RelevantContentResponse {
+    nextContent?: Content;
+    previousContent?: Content;
+}
+export interface RelevantContentResponsePlayer {
+    prev?: {
+        content: Content;
+    };
+    next?: {
+        content: Content;
+    };
+}

package/content/def/search-request.d.ts

@@ -0,0 +1,37 @@
+import { SortOrder } from './requests';
+export interface SearchRequest {
+    filters: SearchFilter;
+    fields?: string[];
+    query?: string;
+    offset?: number;
+    limit?: number;
+    mode?: string;
+    exists?: string[];
+    facets?: string[];
+    sort_by?: {
+        [key: string]: SortOrder;
+    };
+}
+export interface SearchFilter {
+    compatibilityLevel?: {
+        [key: string]: any;
+    };
+    identifier?: string[];
+    status?: string[];
+    objectType?: string[];
+    contentType?: string[];
+    keywords?: string[];
+    dialcodes?: string[];
+    createdBy?: string[];
+    gradeLevel?: string[];
+    medium?: string[];
+    board?: string[];
+    language?: string[];
+    topic?: string[];
+    purpose?: string[];
+    channel?: string[];
+    audience?: string[];
+    mimeType?: string[];
+    subject?: string[];
+    primaryCategory?: string[];
+}

package/content/handlers/content-aggregator.d.ts

@@ -0,0 +1,166 @@
+import { ContentAggregatorRequest, ContentAggregatorResponse, ContentData, ContentSearchCriteria, ContentService, ContentsGroupedByPageSection } from '..';
+import { Observable } from 'rxjs';
+import { CachedItemStore } from '../../key-value-store';
+import { SearchRequest } from '../def/search-request';
+import { FormRequest, FormService } from '../../form';
+import { SearchContentHandler } from './search-content-handler';
+import { CsContentGroup } from '@project-sunbird/client-services/services/content/utilities/content-group-generator';
+import { CourseService } from '../../course';
+import { ProfileService } from '../../profile';
+import { ApiService, SerializedRequest } from '../../api';
+import { NetworkInfoService } from '../../util/network';
+declare type Primitive = string | number | boolean;
+interface AggregationConfig {
+    filterBy?: {
+        [field in keyof ContentData]: {
+            operation: any;
+            value: any;
+        };
+    }[];
+    sortBy?: {
+        [field in keyof ContentData]: 'asc' | 'desc' | {
+            order: 'asc' | 'desc';
+            preference: Primitive[];
+        };
+    }[];
+    groupBy?: keyof ContentData;
+    groupSortBy?: {
+        [field in keyof CsContentGroup]: 'asc' | 'desc' | {
+            order: 'asc' | 'desc';
+            preference: Primitive[];
+        };
+    }[];
+    groupFilterBy?: {
+        [field in keyof CsContentGroup]: {
+            operation: any;
+            value: any;
+        };
+    }[];
+}
+export interface DataSourceModelMap {
+    'CONTENTS': {
+        type: 'CONTENTS';
+        tag?: string;
+        request: Partial<SerializedRequest>;
+        mapping: {
+            applyFirstAvailableCombination?: boolean;
+            aggregate?: AggregationConfig;
+        }[];
+    };
+    'TRACKABLE_COLLECTIONS': {
+        type: 'TRACKABLE_COLLECTIONS';
+        tag?: string;
+        request: Partial<SerializedRequest>;
+        mapping: {
+            aggregate?: AggregationConfig;
+        }[];
+    };
+    'CONTENT_FACETS': {
+        type: 'CONTENT_FACETS';
+        tag?: string;
+        values?: DataResponseMap['CONTENT_FACETS'];
+        request: Partial<SerializedRequest>;
+        mapping: {
+            facet: string;
+            aggregate?: AggregationConfig;
+            filterPillBy?: string;
+        }[];
+        params?: any;
+    };
+    'RECENTLY_VIEWED_CONTENTS': {
+        type: 'RECENTLY_VIEWED_CONTENTS';
+        tag?: string;
+        mapping: {
+            aggregate?: AggregationConfig;
+        }[];
+    };
+    'CONTENT_DISCOVERY_BANNER': {
+        type: 'CONTENT_DISCOVERY_BANNER';
+        tag?: string;
+        values?: DataResponseMap['CONTENT_DISCOVERY_BANNER'];
+        mapping: {}[];
+    };
+}
+export interface DataResponseMap {
+    'TRACKABLE_COLLECTIONS': ContentsGroupedByPageSection;
+    'CONTENT_FACETS': {
+        facet: string;
+        index?: number;
+        searchCriteria: ContentSearchCriteria;
+        primaryFacetFilters?: any;
+        aggregate?: AggregationConfig;
+    }[];
+    'RECENTLY_VIEWED_CONTENTS': ContentsGroupedByPageSection;
+    'CONTENTS': ContentsGroupedByPageSection;
+    'CONTENT_DISCOVERY_BANNER': {
+        code: string;
+        ui: {
+            background: string;
+            text: string;
+        };
+        action: {
+            type: string;
+            subType: string;
+            params: any;
+        };
+        expiry: string;
+    }[];
+}
+export declare type DataSourceType = keyof DataSourceModelMap;
+export interface AggregatorConfigField<T extends DataSourceType = any> {
+    dataSrc: DataSourceModelMap[T];
+    sections: {
+        index: number;
+        code: string;
+        description?: string;
+        title: string;
+        theme: any;
+        isEnabled: boolean;
+        landingDetails?: {
+            title?: string;
+            description?: string;
+        };
+    }[];
+}
+export interface ContentAggregation<T extends DataSourceType = any> {
+    index: number;
+    title: string;
+    description?: string;
+    landingDetails?: {
+        title?: string;
+        description?: string;
+    };
+    data: DataResponseMap[T];
+    dataSrc: DataSourceModelMap[T];
+    theme: any;
+    meta?: {
+        filterCriteria?: ContentSearchCriteria;
+        searchRequest?: SearchRequest;
+        searchCriteria?: ContentSearchCriteria;
+    };
+}
+export declare class ContentAggregator {
+    private searchContentHandler;
+    private formService;
+    private contentService;
+    private cachedItemStore;
+    private courseService;
+    private profileService;
+    private apiService;
+    private networkInfoService;
+    private static searchContentCache;
+    private static CONTENT_AGGREGATION_KEY;
+    private static buildRequestHash;
+    constructor(searchContentHandler: SearchContentHandler, formService: FormService, contentService: ContentService, cachedItemStore: CachedItemStore, courseService: CourseService, profileService: ProfileService, apiService: ApiService, networkInfoService: NetworkInfoService);
+    aggregate(request: ContentAggregatorRequest, excludeDataSrc: DataSourceType[], formRequest?: FormRequest, formFields?: AggregatorConfigField[], cacheable?: boolean): Observable<ContentAggregatorResponse>;
+    private buildRecentlyViewedTask;
+    private buildContentDiscoveryBannerTask;
+    private buildFacetsTask;
+    private buildTrackableCollectionsTask;
+    private buildContentSearchTask;
+    private buildFilterByCriteria;
+    private buildSortByCriteria;
+    private buildSearchRequestAndCriteria;
+    private searchContents;
+}
+export {};

package/content/handlers/content-feedback-handler.d.ts

@@ -0,0 +1,5 @@
+import { ContentFeedback } from '..';
+import { ContentFeedbackEntry } from '../db/schema';
+export declare class ContentFeedbackHandler {
+    static mapFeedbackDBEntrytoResponseFeedback(feedback: ContentFeedbackEntry.SchemaMap): ContentFeedback;
+}

package/content/handlers/content-marker-handler.d.ts

@@ -0,0 +1,10 @@
+import { DbService } from '../../db';
+import { ContentMarker } from '..';
+import { Observable } from 'rxjs';
+import { ContentMarkerEntry } from '../db/schema';
+export declare class ContentMarkerHandler {
+    private dbService;
+    constructor(dbService: DbService);
+    getContentMarker(identifier: string, uid: string): Observable<ContentMarker[]>;
+    mapDBEntriesToContentMarkerDetails(markersInDb: ContentMarkerEntry.SchemaMap[]): ContentMarker[];
+}

package/content/handlers/content-storage-handler.d.ts

@@ -0,0 +1,9 @@
+import { DbService } from '../../db';
+import { ContentSpaceUsageSummaryResponse } from '..';
+import { Observable } from 'rxjs';
+export declare class ContentStorageHandler {
+    private dbService;
+    constructor(dbService: DbService);
+    getUsgaeSpace(path: string): Observable<number>;
+    getContentUsageSummary(paths: string[]): Promise<ContentSpaceUsageSummaryResponse[]>;
+}

package/content/handlers/delete-content-handler.d.ts

@@ -0,0 +1,18 @@
+import { DbService } from '../../db';
+import { ContentEntry } from '../db/schema';
+import { FileService } from '../../util/file/def/file-service';
+import { SharedPreferences } from '../../util/shared-preferences';
+export declare class DeleteContentHandler {
+    private dbService;
+    private fileService;
+    private sharedPreferences;
+    private updateNewContentModels;
+    private fileMapList;
+    constructor(dbService: DbService, fileService: FileService, sharedPreferences: SharedPreferences);
+    deleteAllChildren(row: ContentEntry.SchemaMap, isChildContent: boolean): Promise<void>;
+    deleteOrUpdateContent(contentInDb: ContentEntry.SchemaMap, isChildItems: boolean, isChildContent: boolean): Promise<void>;
+    private findAllContentsFromDbWithIdentifiers;
+    /** @internal */
+    private rm;
+    private getMetaData;
+}

package/content/handlers/export/clean-temp-loc.d.ts

@@ -0,0 +1,8 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { Response } from '../../../api';
+import { ExportContentContext } from '../..';
+export declare class CleanTempLoc {
+    private fileService;
+    constructor(fileService: FileService);
+    execute(exportContext: ExportContentContext): Promise<Response>;
+}