@c-rex/services 0.1.19 → 0.1.20

package/dist/index.js

@@ -0,0 +1,3268 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_LOGO_SRC: () => DEFAULT_LOGO_SRC,
+  DirectoryNodesService: () => DirectoryNodesService,
+  DocumentTypesService: () => DocumentTypesService,
+  INFORMATION_UNIT_PROPERTY_PRESENTATION: () => INFORMATION_UNIT_PROPERTY_PRESENTATION,
+  InformationUnitsService: () => InformationUnitsService,
+  LanguageService: () => LanguageService,
+  METADATA_VIEW_PROFILES: () => METADATA_VIEW_PROFILES,
+  READMODEL_CACHE_POLICY: () => READMODEL_CACHE_POLICY,
+  RenditionsService: () => RenditionsService,
+  TopicsService: () => TopicsService,
+  administrativeMetadataGetAllClientService: () => administrativeMetadataGetAllClientService,
+  administrativeMetadataGetAllServer: () => administrativeMetadataGetAllServer,
+  administrativeMetadataGetByIdClientService: () => administrativeMetadataGetByIdClientService,
+  administrativeMetadataGetByIdServer: () => administrativeMetadataGetByIdServer,
+  afterUsesGetAllClientService: () => afterUsesGetAllClientService,
+  afterUsesGetAllServer: () => afterUsesGetAllServer,
+  afterUsesGetByIdClientService: () => afterUsesGetByIdClientService,
+  afterUsesGetByIdServer: () => afterUsesGetByIdServer,
+  buildTelephoneEntries: () => buildTelephoneEntries,
+  categoriesGetAllClientService: () => categoriesGetAllClientService,
+  categoriesGetAllServer: () => categoriesGetAllServer,
+  categoriesGetByIdClientService: () => categoriesGetByIdClientService,
+  categoriesGetByIdServer: () => categoriesGetByIdServer,
+  collectionsGetAllClientService: () => collectionsGetAllClientService,
+  collectionsGetAllServer: () => collectionsGetAllServer,
+  collectionsGetByIdClientService: () => collectionsGetByIdClientService,
+  collectionsGetByIdServer: () => collectionsGetByIdServer,
+  componentsGetAllClientService: () => componentsGetAllClientService,
+  componentsGetAllServer: () => componentsGetAllServer,
+  componentsGetByIdClientService: () => componentsGetByIdClientService,
+  componentsGetByIdServer: () => componentsGetByIdServer,
+  conceptsGetAllClientService: () => conceptsGetAllClientService,
+  conceptsGetAllServer: () => conceptsGetAllServer,
+  conceptsGetByIdClientService: () => conceptsGetByIdClientService,
+  conceptsGetByIdServer: () => conceptsGetByIdServer,
+  conformitiesGetAllClientService: () => conformitiesGetAllClientService,
+  conformitiesGetAllServer: () => conformitiesGetAllServer,
+  conformitiesGetByIdClientService: () => conformitiesGetByIdClientService,
+  conformitiesGetByIdServer: () => conformitiesGetByIdServer,
+  consumablesGetAllClientService: () => consumablesGetAllClientService,
+  consumablesGetAllServer: () => consumablesGetAllServer,
+  consumablesGetByIdClientService: () => consumablesGetByIdClientService,
+  consumablesGetByIdServer: () => consumablesGetByIdServer,
+  contentLifeCycleStatusGetAllClientService: () => contentLifeCycleStatusGetAllClientService,
+  contentLifeCycleStatusGetAllServer: () => contentLifeCycleStatusGetAllServer,
+  contentLifeCycleStatusGetByIdClientService: () => contentLifeCycleStatusGetByIdClientService,
+  contentLifeCycleStatusGetByIdServer: () => contentLifeCycleStatusGetByIdServer,
+  decodeEncodedVcardId: () => decodeEncodedVcardId,
+  designAndRealizationsGetAllClientService: () => designAndRealizationsGetAllClientService,
+  designAndRealizationsGetAllServer: () => designAndRealizationsGetAllServer,
+  designAndRealizationsGetByIdClientService: () => designAndRealizationsGetByIdClientService,
+  designAndRealizationsGetByIdServer: () => designAndRealizationsGetByIdServer,
+  directoryNodeTypesGetAllClientService: () => directoryNodeTypesGetAllClientService,
+  directoryNodeTypesGetAllServer: () => directoryNodeTypesGetAllServer,
+  directoryNodeTypesGetByIdClientService: () => directoryNodeTypesGetByIdClientService,
+  directoryNodeTypesGetByIdServer: () => directoryNodeTypesGetByIdServer,
+  directoryNodesGetAllClientService: () => directoryNodesGetAllClientService,
+  directoryNodesGetAllServer: () => directoryNodesGetAllServer,
+  directoryNodesGetByIdClientService: () => directoryNodesGetByIdClientService,
+  directoryNodesGetByIdServer: () => directoryNodesGetByIdServer,
+  documentTypesGetAllClientService: () => documentTypesGetAllClientService,
+  documentTypesGetAllServer: () => documentTypesGetAllServer,
+  documentTypesGetByIdClientService: () => documentTypesGetByIdClientService,
+  documentTypesGetByIdServer: () => documentTypesGetByIdServer,
+  documentationMetadataGetAllClientService: () => documentationMetadataGetAllClientService,
+  documentationMetadataGetAllServer: () => documentationMetadataGetAllServer,
+  documentationMetadataGetByIdClientService: () => documentationMetadataGetByIdClientService,
+  documentationMetadataGetByIdServer: () => documentationMetadataGetByIdServer,
+  documentsGetAllClientService: () => documentsGetAllClientService,
+  documentsGetAllServer: () => documentsGetAllServer,
+  documentsGetByIdClientService: () => documentsGetByIdClientService,
+  documentsGetByIdServer: () => documentsGetByIdServer,
+  documentsLanguagesClientService: () => documentsLanguagesClientService,
+  documentsLanguagesServer: () => documentsLanguagesServer,
+  domainEntitiesGetAllClientService: () => domainEntitiesGetAllClientService,
+  domainEntitiesGetAllServer: () => domainEntitiesGetAllServer,
+  domainEntitiesGetByIdClientService: () => domainEntitiesGetByIdClientService,
+  domainEntitiesGetByIdServer: () => domainEntitiesGetByIdServer,
+  downTimesGetAllClientService: () => downTimesGetAllClientService,
+  downTimesGetAllServer: () => downTimesGetAllServer,
+  downTimesGetByIdClientService: () => downTimesGetByIdClientService,
+  downTimesGetByIdServer: () => downTimesGetByIdServer,
+  eventsGetAllClientService: () => eventsGetAllClientService,
+  eventsGetAllServer: () => eventsGetAllServer,
+  eventsGetByIdClientService: () => eventsGetByIdClientService,
+  eventsGetByIdServer: () => eventsGetByIdServer,
+  formalitiesGetAllClientService: () => formalitiesGetAllClientService,
+  formalitiesGetAllServer: () => formalitiesGetAllServer,
+  formalitiesGetByIdClientService: () => formalitiesGetByIdClientService,
+  formalitiesGetByIdServer: () => formalitiesGetByIdServer,
+  formsGetAllClientService: () => formsGetAllClientService,
+  formsGetAllServer: () => formsGetAllServer,
+  formsGetByIdClientService: () => formsGetByIdClientService,
+  formsGetByIdServer: () => formsGetByIdServer,
+  fragmentsGetAllClientService: () => fragmentsGetAllClientService,
+  fragmentsGetAllServer: () => fragmentsGetAllServer,
+  fragmentsGetByIdClientService: () => fragmentsGetByIdClientService,
+  fragmentsGetByIdServer: () => fragmentsGetByIdServer,
+  fragmentsLanguagesClientService: () => fragmentsLanguagesClientService,
+  fragmentsLanguagesServer: () => fragmentsLanguagesServer,
+  functionalMetadatasGetAllClientService: () => functionalMetadatasGetAllClientService,
+  functionalMetadatasGetAllServer: () => functionalMetadatasGetAllServer,
+  functionalMetadatasGetByIdClientService: () => functionalMetadatasGetByIdClientService,
+  functionalMetadatasGetByIdServer: () => functionalMetadatasGetByIdServer,
+  functionalitiesGetAllClientService: () => functionalitiesGetAllClientService,
+  functionalitiesGetAllServer: () => functionalitiesGetAllServer,
+  functionalitiesGetByIdClientService: () => functionalitiesGetByIdClientService,
+  functionalitiesGetByIdServer: () => functionalitiesGetByIdServer,
+  getApplicableForTypes: () => getApplicableForTypes,
+  getAvailableLanguagesByVersionOf: () => getAvailableLanguagesByVersionOf,
+  getComponents: () => getComponents,
+  getContentLifeCycleStatus: () => getContentLifeCycleStatus,
+  getDocumentTypes: () => getDocumentTypes,
+  getFunctionalMetadata: () => getFunctionalMetadata,
+  getIndividualProfileById: () => getIndividualProfileById,
+  getIndividualsProfiles: () => getIndividualsProfiles,
+  getInformationSubjects: () => getInformationSubjects,
+  getMetadataDisplayRows: () => getMetadataDisplayRows,
+  getMetadataFacetLabelOverrides: () => getMetadataFacetLabelOverrides,
+  getMetadataPropertyResolvers: () => getMetadataPropertyResolvers,
+  getOrganizationBranding: () => getOrganizationBranding,
+  getOrganizationProfile: () => getOrganizationProfile,
+  getOrganizationProfileById: () => getOrganizationProfileById,
+  getOrganizationsProfiles: () => getOrganizationsProfiles,
+  getParties: () => getParties,
+  getPlanningTimes: () => getPlanningTimes,
+  getProductFeatures: () => getProductFeatures,
+  getProductLifeCyclePhases: () => getProductLifeCyclePhases,
+  getProductMetadata: () => getProductMetadata,
+  getProductVariants: () => getProductVariants,
+  getQualifications: () => getQualifications,
+  getServerConfig: () => getServerConfig,
+  getSupplies: () => getSupplies,
+  getTopicTypes: () => getTopicTypes,
+  getVCardProfileById: () => getVCardProfileById,
+  getVCardProfiles: () => getVCardProfiles,
+  groupsGetAllClientService: () => groupsGetAllClientService,
+  groupsGetAllServer: () => groupsGetAllServer,
+  groupsGetByIdClientService: () => groupsGetByIdClientService,
+  groupsGetByIdServer: () => groupsGetByIdServer,
+  hardwareToolsGetAllClientService: () => hardwareToolsGetAllClientService,
+  hardwareToolsGetAllServer: () => hardwareToolsGetAllServer,
+  hardwareToolsGetByIdClientService: () => hardwareToolsGetByIdClientService,
+  hardwareToolsGetByIdServer: () => hardwareToolsGetByIdServer,
+  identitiesGetAllClientService: () => identitiesGetAllClientService,
+  identitiesGetAllServer: () => identitiesGetAllServer,
+  identitiesGetByIdClientService: () => identitiesGetByIdClientService,
+  identitiesGetByIdServer: () => identitiesGetByIdServer,
+  identityDomainsGetAllClientService: () => identityDomainsGetAllClientService,
+  identityDomainsGetAllServer: () => identityDomainsGetAllServer,
+  identityDomainsGetByIdClientService: () => identityDomainsGetByIdClientService,
+  identityDomainsGetByIdServer: () => identityDomainsGetByIdServer,
+  individualsGetAllClientService: () => individualsGetAllClientService,
+  individualsGetAllServer: () => individualsGetAllServer,
+  individualsGetByIdClientService: () => individualsGetByIdClientService,
+  individualsGetByIdServer: () => individualsGetByIdServer,
+  informationObjectsGetAllClientService: () => informationObjectsGetAllClientService,
+  informationObjectsGetAllServer: () => informationObjectsGetAllServer,
+  informationObjectsGetByIdClientService: () => informationObjectsGetByIdClientService,
+  informationObjectsGetByIdServer: () => informationObjectsGetByIdServer,
+  informationSubjectsGetAllClientService: () => informationSubjectsGetAllClientService,
+  informationSubjectsGetAllServer: () => informationSubjectsGetAllServer,
+  informationSubjectsGetByIdClientService: () => informationSubjectsGetByIdClientService,
+  informationSubjectsGetByIdServer: () => informationSubjectsGetByIdServer,
+  informationTypesGetAllClientService: () => informationTypesGetAllClientService,
+  informationTypesGetAllServer: () => informationTypesGetAllServer,
+  informationTypesGetByIdClientService: () => informationTypesGetByIdClientService,
+  informationTypesGetByIdServer: () => informationTypesGetByIdServer,
+  informationUnitsGetAllClientService: () => informationUnitsGetAllClientService,
+  informationUnitsGetAllServer: () => informationUnitsGetAllServer,
+  informationUnitsGetByIdClientService: () => informationUnitsGetByIdClientService,
+  informationUnitsGetByIdServer: () => informationUnitsGetByIdServer,
+  informationUnitsLanguagesClientService: () => informationUnitsLanguagesClientService,
+  informationUnitsLanguagesServer: () => informationUnitsLanguagesServer,
+  learningsGetAllClientService: () => learningsGetAllClientService,
+  learningsGetAllServer: () => learningsGetAllServer,
+  learningsGetByIdClientService: () => learningsGetByIdClientService,
+  learningsGetByIdServer: () => learningsGetByIdServer,
+  locationsGetAllClientService: () => locationsGetAllClientService,
+  locationsGetAllServer: () => locationsGetAllServer,
+  locationsGetByIdClientService: () => locationsGetByIdClientService,
+  locationsGetByIdServer: () => locationsGetByIdServer,
+  lubricantsGetAllClientService: () => lubricantsGetAllClientService,
+  lubricantsGetAllServer: () => lubricantsGetAllServer,
+  lubricantsGetByIdClientService: () => lubricantsGetByIdClientService,
+  lubricantsGetByIdServer: () => lubricantsGetByIdServer,
+  maintenanceIntervalsGetAllClientService: () => maintenanceIntervalsGetAllClientService,
+  maintenanceIntervalsGetAllServer: () => maintenanceIntervalsGetAllServer,
+  maintenanceIntervalsGetByIdClientService: () => maintenanceIntervalsGetByIdClientService,
+  maintenanceIntervalsGetByIdServer: () => maintenanceIntervalsGetByIdServer,
+  mapVCardEntityToBaseProfile: () => mapVCardEntityToBaseProfile,
+  normalizeEmail: () => normalizeEmail,
+  normalizeHref: () => normalizeHref,
+  operatingSuppliesGetAllClientService: () => operatingSuppliesGetAllClientService,
+  operatingSuppliesGetAllServer: () => operatingSuppliesGetAllServer,
+  operatingSuppliesGetByIdClientService: () => operatingSuppliesGetByIdClientService,
+  operatingSuppliesGetByIdServer: () => operatingSuppliesGetByIdServer,
+  organizationsGetAllClientService: () => organizationsGetAllClientService,
+  organizationsGetAllServer: () => organizationsGetAllServer,
+  organizationsGetByIdClientService: () => organizationsGetByIdClientService,
+  organizationsGetByIdServer: () => organizationsGetByIdServer,
+  packagesCreateClientAppClientService: () => packagesCreateClientAppClientService,
+  packagesCreateClientAppServer: () => packagesCreateClientAppServer,
+  packagesGetAllClientService: () => packagesGetAllClientService,
+  packagesGetAllServer: () => packagesGetAllServer,
+  packagesGetByIdClientService: () => packagesGetByIdClientService,
+  packagesGetByIdServer: () => packagesGetByIdServer,
+  packagesLanguagesClientService: () => packagesLanguagesClientService,
+  packagesLanguagesServer: () => packagesLanguagesServer,
+  partiesGetAllClientService: () => partiesGetAllClientService,
+  partiesGetAllServer: () => partiesGetAllServer,
+  partiesGetByIdClientService: () => partiesGetByIdClientService,
+  partiesGetByIdServer: () => partiesGetByIdServer,
+  planningTimesGetAllClientService: () => planningTimesGetAllClientService,
+  planningTimesGetAllServer: () => planningTimesGetAllServer,
+  planningTimesGetByIdClientService: () => planningTimesGetByIdClientService,
+  planningTimesGetByIdServer: () => planningTimesGetByIdServer,
+  processesGetAllClientService: () => processesGetAllClientService,
+  processesGetAllServer: () => processesGetAllServer,
+  processesGetByIdClientService: () => processesGetByIdClientService,
+  processesGetByIdServer: () => processesGetByIdServer,
+  productFeaturesGetAllClientService: () => productFeaturesGetAllClientService,
+  productFeaturesGetAllServer: () => productFeaturesGetAllServer,
+  productFeaturesGetByIdClientService: () => productFeaturesGetByIdClientService,
+  productFeaturesGetByIdServer: () => productFeaturesGetByIdServer,
+  productFunctionsGetAllClientService: () => productFunctionsGetAllClientService,
+  productFunctionsGetAllServer: () => productFunctionsGetAllServer,
+  productFunctionsGetByIdClientService: () => productFunctionsGetByIdClientService,
+  productFunctionsGetByIdServer: () => productFunctionsGetByIdServer,
+  productLifeCyclePhasesGetAllClientService: () => productLifeCyclePhasesGetAllClientService,
+  productLifeCyclePhasesGetAllServer: () => productLifeCyclePhasesGetAllServer,
+  productLifeCyclePhasesGetByIdClientService: () => productLifeCyclePhasesGetByIdClientService,
+  productLifeCyclePhasesGetByIdServer: () => productLifeCyclePhasesGetByIdServer,
+  productMetadataGetAllClientService: () => productMetadataGetAllClientService,
+  productMetadataGetAllServer: () => productMetadataGetAllServer,
+  productMetadataGetByIdClientService: () => productMetadataGetByIdClientService,
+  productMetadataGetByIdServer: () => productMetadataGetByIdServer,
+  productPropertiesGetAllClientService: () => productPropertiesGetAllClientService,
+  productPropertiesGetAllServer: () => productPropertiesGetAllServer,
+  productPropertiesGetByIdClientService: () => productPropertiesGetByIdClientService,
+  productPropertiesGetByIdServer: () => productPropertiesGetByIdServer,
+  productVariantsGetAllClientService: () => productVariantsGetAllClientService,
+  productVariantsGetAllServer: () => productVariantsGetAllServer,
+  productVariantsGetByIdClientService: () => productVariantsGetByIdClientService,
+  productVariantsGetByIdServer: () => productVariantsGetByIdServer,
+  puttingToUsesGetAllClientService: () => puttingToUsesGetAllClientService,
+  puttingToUsesGetAllServer: () => puttingToUsesGetAllServer,
+  puttingToUsesGetByIdClientService: () => puttingToUsesGetByIdClientService,
+  puttingToUsesGetByIdServer: () => puttingToUsesGetByIdServer,
+  qualificationsGetAllClientService: () => qualificationsGetAllClientService,
+  qualificationsGetAllServer: () => qualificationsGetAllServer,
+  qualificationsGetByIdClientService: () => qualificationsGetByIdClientService,
+  qualificationsGetByIdServer: () => qualificationsGetByIdServer,
+  referencesGetAllClientService: () => referencesGetAllClientService,
+  referencesGetAllServer: () => referencesGetAllServer,
+  referencesGetByIdClientService: () => referencesGetByIdClientService,
+  referencesGetByIdServer: () => referencesGetByIdServer,
+  renditionsGetAllClientService: () => renditionsGetAllClientService,
+  renditionsGetAllServer: () => renditionsGetAllServer,
+  renditionsGetByIdClientService: () => renditionsGetByIdClientService,
+  renditionsGetByIdServer: () => renditionsGetByIdServer,
+  renditionsGetWithBinaryWithBinaryPathClientService: () => renditionsGetWithBinaryWithBinaryPathClientService,
+  renditionsGetWithBinaryWithBinaryPathServer: () => renditionsGetWithBinaryWithBinaryPathServer,
+  resolveFacetTags: () => resolveFacetTags,
+  resolveLogoSource: () => resolveLogoSource,
+  resolveMetadataDisplayProperties: () => resolveMetadataDisplayProperties,
+  resolveSocialProviderLabel: () => resolveSocialProviderLabel,
+  resolveTypedSocialLinks: () => resolveTypedSocialLinks,
+  resolveUiLanguage: () => resolveUiLanguage,
+  resourcesDownloadResourceClientService: () => resourcesDownloadResourceClientService,
+  resourcesDownloadResourceServer: () => resourcesDownloadResourceServer,
+  resourcesDownloadResourceWithBinaryPathClientService: () => resourcesDownloadResourceWithBinaryPathClientService,
+  resourcesDownloadResourceWithBinaryPathServer: () => resourcesDownloadResourceWithBinaryPathServer,
+  resourcesGetPackageClientService: () => resourcesGetPackageClientService,
+  resourcesGetPackageServer: () => resourcesGetPackageServer,
+  resourcesGetSubjectFromPackageClientService: () => resourcesGetSubjectFromPackageClientService,
+  resourcesGetSubjectFromPackageServer: () => resourcesGetSubjectFromPackageServer,
+  resourcesViewResourceClientService: () => resourcesViewResourceClientService,
+  resourcesViewResourceServer: () => resourcesViewResourceServer,
+  resourcesViewResourceWithBinaryPathClientService: () => resourcesViewResourceWithBinaryPathClientService,
+  resourcesViewResourceWithBinaryPathServer: () => resourcesViewResourceWithBinaryPathServer,
+  rolesGetAllClientService: () => rolesGetAllClientService,
+  rolesGetAllServer: () => rolesGetAllServer,
+  rolesGetByIdClientService: () => rolesGetByIdClientService,
+  rolesGetByIdServer: () => rolesGetByIdServer,
+  safetiesGetAllClientService: () => safetiesGetAllClientService,
+  safetiesGetAllServer: () => safetiesGetAllServer,
+  safetiesGetByIdClientService: () => safetiesGetByIdClientService,
+  safetiesGetByIdServer: () => safetiesGetByIdServer,
+  searchGetAllClientService: () => searchGetAllClientService,
+  searchGetAllServer: () => searchGetAllServer,
+  setupTimesGetAllClientService: () => setupTimesGetAllClientService,
+  setupTimesGetAllServer: () => setupTimesGetAllServer,
+  setupTimesGetByIdClientService: () => setupTimesGetByIdClientService,
+  setupTimesGetByIdServer: () => setupTimesGetByIdServer,
+  skillLevelsGetAllClientService: () => skillLevelsGetAllClientService,
+  skillLevelsGetAllServer: () => skillLevelsGetAllServer,
+  skillLevelsGetByIdClientService: () => skillLevelsGetByIdClientService,
+  skillLevelsGetByIdServer: () => skillLevelsGetByIdServer,
+  sparQLExecuteSparQlClientService: () => sparQLExecuteSparQlClientService,
+  sparQLExecuteSparQlServer: () => sparQLExecuteSparQlServer,
+  sparePartsGetAllClientService: () => sparePartsGetAllClientService,
+  sparePartsGetAllServer: () => sparePartsGetAllServer,
+  sparePartsGetByIdClientService: () => sparePartsGetByIdClientService,
+  sparePartsGetByIdServer: () => sparePartsGetByIdServer,
+  suppliesGetAllClientService: () => suppliesGetAllClientService,
+  suppliesGetAllServer: () => suppliesGetAllServer,
+  suppliesGetByIdClientService: () => suppliesGetByIdClientService,
+  suppliesGetByIdServer: () => suppliesGetByIdServer,
+  tasksGetAllClientService: () => tasksGetAllClientService,
+  tasksGetAllServer: () => tasksGetAllServer,
+  tasksGetByIdClientService: () => tasksGetByIdClientService,
+  tasksGetByIdServer: () => tasksGetByIdServer,
+  technicalDataGetAllClientService: () => technicalDataGetAllClientService,
+  technicalDataGetAllServer: () => technicalDataGetAllServer,
+  technicalDataGetByIdClientService: () => technicalDataGetByIdClientService,
+  technicalDataGetByIdServer: () => technicalDataGetByIdServer,
+  technicalOverviewsGetAllClientService: () => technicalOverviewsGetAllClientService,
+  technicalOverviewsGetAllServer: () => technicalOverviewsGetAllServer,
+  technicalOverviewsGetByIdClientService: () => technicalOverviewsGetByIdClientService,
+  technicalOverviewsGetByIdServer: () => technicalOverviewsGetByIdServer,
+  topicTypesGetAllClientService: () => topicTypesGetAllClientService,
+  topicTypesGetAllServer: () => topicTypesGetAllServer,
+  topicTypesGetByIdClientService: () => topicTypesGetByIdClientService,
+  topicTypesGetByIdServer: () => topicTypesGetByIdServer,
+  topicsGetAllClientService: () => topicsGetAllClientService,
+  topicsGetAllServer: () => topicsGetAllServer,
+  topicsGetByIdClientService: () => topicsGetByIdClientService,
+  topicsGetByIdServer: () => topicsGetByIdServer,
+  topicsLanguagesClientService: () => topicsLanguagesClientService,
+  topicsLanguagesServer: () => topicsLanguagesServer,
+  troubleShootingsGetAllClientService: () => troubleShootingsGetAllClientService,
+  troubleShootingsGetAllServer: () => troubleShootingsGetAllServer,
+  troubleShootingsGetByIdClientService: () => troubleShootingsGetByIdClientService,
+  troubleShootingsGetByIdServer: () => troubleShootingsGetByIdServer,
+  usesGetAllClientService: () => usesGetAllClientService,
+  usesGetAllServer: () => usesGetAllServer,
+  usesGetByIdClientService: () => usesGetByIdClientService,
+  usesGetByIdServer: () => usesGetByIdServer,
+  vCardsGetAllClientService: () => vCardsGetAllClientService,
+  vCardsGetAllServer: () => vCardsGetAllServer,
+  vCardsGetByIdClientService: () => vCardsGetByIdClientService,
+  vCardsGetByIdServer: () => vCardsGetByIdServer,
+  warningMessagesGetAllClientService: () => warningMessagesGetAllClientService,
+  warningMessagesGetAllServer: () => warningMessagesGetAllServer,
+  warningMessagesGetByIdClientService: () => warningMessagesGetByIdClientService,
+  warningMessagesGetByIdServer: () => warningMessagesGetByIdServer,
+  workingTimesGetAllClientService: () => workingTimesGetAllClientService,
+  workingTimesGetAllServer: () => workingTimesGetAllServer,
+  workingTimesGetByIdClientService: () => workingTimesGetByIdClientService,
+  workingTimesGetByIdServer: () => workingTimesGetByIdServer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/base-server-request.ts
+var import_requests = require("@c-rex/core/requests");
+
+// src/server-request-context.ts
+var import_node_async_hooks = require("async_hooks");
+var requestContextStorage = new import_node_async_hooks.AsyncLocalStorage();
+var withServerRequestContext = async (context, run) => {
+  return requestContextStorage.run(context, run);
+};
+var getServerRequestContext = () => {
+  return requestContextStorage.getStore();
+};
+
+// src/base-server-request.ts
+var baseServerRequest = async (endpoint, query) => {
+  const api = new import_requests.CrexApi();
+  const requestContext = getServerRequestContext();
+  const response = await api.execute({
+    url: endpoint,
+    method: "GET",
+    params: query,
+    skipCookieTokenLookup: requestContext?.skipCookieTokenLookup,
+    authToken: requestContext?.authToken
+  });
+  return response;
+};
+
+// src/generated/server-requests.ts
+var administrativeMetadataGetAllServer = async (query) => {
+  return baseServerRequest("AdministrativeMetadata", query);
+};
+var administrativeMetadataGetByIdServer = async (params, query) => {
+  return baseServerRequest(`AdministrativeMetadata/${encodeURIComponent(String(params.id))}`, query);
+};
+var afterUsesGetAllServer = async (query) => {
+  return baseServerRequest("AfterUses", query);
+};
+var afterUsesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`AfterUses/${encodeURIComponent(String(params.id))}`, query);
+};
+var categoriesGetAllServer = async (query) => {
+  return baseServerRequest("crex/v1/Categories", query);
+};
+var categoriesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`crex/v1/Categories/${encodeURIComponent(String(params.id))}`, query);
+};
+var collectionsGetAllServer = async (query) => {
+  return baseServerRequest("Collections", query);
+};
+var collectionsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Collections/${encodeURIComponent(String(params.id))}`, query);
+};
+var componentsGetAllServer = async (query) => {
+  return baseServerRequest("Components", query);
+};
+var componentsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Components/${encodeURIComponent(String(params.id))}`, query);
+};
+var conceptsGetAllServer = async (query) => {
+  return baseServerRequest("Concepts", query);
+};
+var conceptsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Concepts/${encodeURIComponent(String(params.id))}`, query);
+};
+var conformitiesGetAllServer = async (query) => {
+  return baseServerRequest("Conformities", query);
+};
+var conformitiesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Conformities/${encodeURIComponent(String(params.id))}`, query);
+};
+var consumablesGetAllServer = async (query) => {
+  return baseServerRequest("Consumables", query);
+};
+var consumablesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Consumables/${encodeURIComponent(String(params.id))}`, query);
+};
+var contentLifeCycleStatusGetAllServer = async (query) => {
+  return baseServerRequest("ContentLifeCycleStatus", query);
+};
+var contentLifeCycleStatusGetByIdServer = async (params, query) => {
+  return baseServerRequest(`ContentLifeCycleStatus/${encodeURIComponent(String(params.id))}`, query);
+};
+var designAndRealizationsGetAllServer = async (query) => {
+  return baseServerRequest("DesignAndRealizations", query);
+};
+var designAndRealizationsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`DesignAndRealizations/${encodeURIComponent(String(params.id))}`, query);
+};
+var directoryNodesGetAllServer = async (query) => {
+  return baseServerRequest("DirectoryNodes", query);
+};
+var directoryNodesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`DirectoryNodes/${encodeURIComponent(String(params.id))}`, query);
+};
+var directoryNodeTypesGetAllServer = async (query) => {
+  return baseServerRequest("DirectoryNodeTypes", query);
+};
+var directoryNodeTypesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`DirectoryNodeTypes/${encodeURIComponent(String(params.id))}`, query);
+};
+var documentationMetadataGetAllServer = async (query) => {
+  return baseServerRequest("DocumentationMetadata", query);
+};
+var documentationMetadataGetByIdServer = async (params, query) => {
+  return baseServerRequest(`DocumentationMetadata/${encodeURIComponent(String(params.id))}`, query);
+};
+var documentsGetAllServer = async (query) => {
+  return baseServerRequest("Documents", query);
+};
+var documentsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Documents/${encodeURIComponent(String(params.id))}`, query);
+};
+var documentsLanguagesServer = async (query) => {
+  return baseServerRequest("Documents/Languages", query);
+};
+var documentTypesGetAllServer = async (query) => {
+  return baseServerRequest("DocumentTypes", query);
+};
+var documentTypesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`DocumentTypes/${encodeURIComponent(String(params.id))}`, query);
+};
+var domainEntitiesGetAllServer = async (query) => {
+  return baseServerRequest("DomainEntities", query);
+};
+var domainEntitiesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`DomainEntities/${encodeURIComponent(String(params.id))}`, query);
+};
+var downTimesGetAllServer = async (query) => {
+  return baseServerRequest("DownTimes", query);
+};
+var downTimesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`DownTimes/${encodeURIComponent(String(params.id))}`, query);
+};
+var eventsGetAllServer = async (query) => {
+  return baseServerRequest("Events", query);
+};
+var eventsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Events/${encodeURIComponent(String(params.id))}`, query);
+};
+var formalitiesGetAllServer = async (query) => {
+  return baseServerRequest("Formalities", query);
+};
+var formalitiesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Formalities/${encodeURIComponent(String(params.id))}`, query);
+};
+var formsGetAllServer = async (query) => {
+  return baseServerRequest("Forms", query);
+};
+var formsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Forms/${encodeURIComponent(String(params.id))}`, query);
+};
+var fragmentsGetAllServer = async (query) => {
+  return baseServerRequest("Fragments", query);
+};
+var fragmentsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Fragments/${encodeURIComponent(String(params.id))}`, query);
+};
+var fragmentsLanguagesServer = async (query) => {
+  return baseServerRequest("Fragments/Languages", query);
+};
+var functionalitiesGetAllServer = async (query) => {
+  return baseServerRequest("Functionalities", query);
+};
+var functionalitiesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Functionalities/${encodeURIComponent(String(params.id))}`, query);
+};
+var functionalMetadatasGetAllServer = async (query) => {
+  return baseServerRequest("FunctionalMetadatas", query);
+};
+var functionalMetadatasGetByIdServer = async (params, query) => {
+  return baseServerRequest(`FunctionalMetadatas/${encodeURIComponent(String(params.id))}`, query);
+};
+var groupsGetAllServer = async (query) => {
+  return baseServerRequest("vcard/v1/Groups", query);
+};
+var groupsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`vcard/v1/Groups/${encodeURIComponent(String(params.id))}`, query);
+};
+var hardwareToolsGetAllServer = async (query) => {
+  return baseServerRequest("HardwareTools", query);
+};
+var hardwareToolsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`HardwareTools/${encodeURIComponent(String(params.id))}`, query);
+};
+var identitiesGetAllServer = async (query) => {
+  return baseServerRequest("Identities", query);
+};
+var identitiesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Identities/${encodeURIComponent(String(params.id))}`, query);
+};
+var identityDomainsGetAllServer = async (query) => {
+  return baseServerRequest("IdentityDomains", query);
+};
+var identityDomainsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`IdentityDomains/${encodeURIComponent(String(params.id))}`, query);
+};
+var individualsGetAllServer = async (query) => {
+  return baseServerRequest("vcard/v1/Individuals", query);
+};
+var individualsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`vcard/v1/Individuals/${encodeURIComponent(String(params.id))}`, query);
+};
+var informationObjectsGetAllServer = async (query) => {
+  return baseServerRequest("InformationObjects", query);
+};
+var informationObjectsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`InformationObjects/${encodeURIComponent(String(params.id))}`, query);
+};
+var informationSubjectsGetAllServer = async (query) => {
+  return baseServerRequest("InformationSubjects", query);
+};
+var informationSubjectsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`InformationSubjects/${encodeURIComponent(String(params.id))}`, query);
+};
+var informationTypesGetAllServer = async (query) => {
+  return baseServerRequest("InformationTypes", query);
+};
+var informationTypesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`InformationTypes/${encodeURIComponent(String(params.id))}`, query);
+};
+var informationUnitsGetAllServer = async (query) => {
+  return baseServerRequest("InformationUnits", query);
+};
+var informationUnitsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`InformationUnits/${encodeURIComponent(String(params.id))}`, query);
+};
+var informationUnitsLanguagesServer = async (query) => {
+  return baseServerRequest("InformationUnits/Languages", query);
+};
+var learningsGetAllServer = async (query) => {
+  return baseServerRequest("Learnings", query);
+};
+var learningsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Learnings/${encodeURIComponent(String(params.id))}`, query);
+};
+var locationsGetAllServer = async (query) => {
+  return baseServerRequest("vcard/v1/Locations", query);
+};
+var locationsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`vcard/v1/Locations/${encodeURIComponent(String(params.id))}`, query);
+};
+var lubricantsGetAllServer = async (query) => {
+  return baseServerRequest("Lubricants", query);
+};
+var lubricantsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Lubricants/${encodeURIComponent(String(params.id))}`, query);
+};
+var maintenanceIntervalsGetAllServer = async (query) => {
+  return baseServerRequest("MaintenanceIntervals", query);
+};
+var maintenanceIntervalsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`MaintenanceIntervals/${encodeURIComponent(String(params.id))}`, query);
+};
+var operatingSuppliesGetAllServer = async (query) => {
+  return baseServerRequest("OperatingSupplies", query);
+};
+var operatingSuppliesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`OperatingSupplies/${encodeURIComponent(String(params.id))}`, query);
+};
+var organizationsGetAllServer = async (query) => {
+  return baseServerRequest("vcard/v1/Organizations", query);
+};
+var organizationsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`vcard/v1/Organizations/${encodeURIComponent(String(params.id))}`, query);
+};
+var packagesCreateClientAppServer = async (query) => {
+  return baseServerRequest("ids/v1/Packages/CreateClientApp", query);
+};
+var packagesGetAllServer = async (query) => {
+  return baseServerRequest("Packages", query);
+};
+var packagesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Packages/${encodeURIComponent(String(params.id))}`, query);
+};
+var packagesLanguagesServer = async (query) => {
+  return baseServerRequest("Packages/Languages", query);
+};
+var partiesGetAllServer = async (query) => {
+  return baseServerRequest("Parties", query);
+};
+var partiesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Parties/${encodeURIComponent(String(params.id))}`, query);
+};
+var planningTimesGetAllServer = async (query) => {
+  return baseServerRequest("PlanningTimes", query);
+};
+var planningTimesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`PlanningTimes/${encodeURIComponent(String(params.id))}`, query);
+};
+var processesGetAllServer = async (query) => {
+  return baseServerRequest("Processes", query);
+};
+var processesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Processes/${encodeURIComponent(String(params.id))}`, query);
+};
+var productFeaturesGetAllServer = async (query) => {
+  return baseServerRequest("ProductFeatures", query);
+};
+var productFeaturesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`ProductFeatures/${encodeURIComponent(String(params.id))}`, query);
+};
+var productFunctionsGetAllServer = async (query) => {
+  return baseServerRequest("ProductFunctions", query);
+};
+var productFunctionsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`ProductFunctions/${encodeURIComponent(String(params.id))}`, query);
+};
+var productLifeCyclePhasesGetAllServer = async (query) => {
+  return baseServerRequest("ProductLifeCyclePhases", query);
+};
+var productLifeCyclePhasesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`ProductLifeCyclePhases/${encodeURIComponent(String(params.id))}`, query);
+};
+var productMetadataGetAllServer = async (query) => {
+  return baseServerRequest("ProductMetadata", query);
+};
+var productMetadataGetByIdServer = async (params, query) => {
+  return baseServerRequest(`ProductMetadata/${encodeURIComponent(String(params.id))}`, query);
+};
+var productPropertiesGetAllServer = async (query) => {
+  return baseServerRequest("ProductProperties", query);
+};
+var productPropertiesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`ProductProperties/${encodeURIComponent(String(params.id))}`, query);
+};
+var productVariantsGetAllServer = async (query) => {
+  return baseServerRequest("ProductVariants", query);
+};
+var productVariantsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`ProductVariants/${encodeURIComponent(String(params.id))}`, query);
+};
+var puttingToUsesGetAllServer = async (query) => {
+  return baseServerRequest("PuttingToUses", query);
+};
+var puttingToUsesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`PuttingToUses/${encodeURIComponent(String(params.id))}`, query);
+};
+var qualificationsGetAllServer = async (query) => {
+  return baseServerRequest("Qualifications", query);
+};
+var qualificationsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Qualifications/${encodeURIComponent(String(params.id))}`, query);
+};
+var referencesGetAllServer = async (query) => {
+  return baseServerRequest("References", query);
+};
+var referencesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`References/${encodeURIComponent(String(params.id))}`, query);
+};
+var renditionsGetAllServer = async (query) => {
+  return baseServerRequest("Renditions", query);
+};
+var renditionsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Renditions/${encodeURIComponent(String(params.id))}`, query);
+};
+var renditionsGetWithBinaryWithBinaryPathServer = async (params) => {
+  return baseServerRequest(`Renditions/${encodeURIComponent(String(params.id))}/${encodeURIComponent(String(params.binaryPath))}`);
+};
+var resourcesDownloadResourceServer = async (params) => {
+  return baseServerRequest(`ids/v1/Resources/${encodeURIComponent(String(params.renditionId))}`);
+};
+var resourcesDownloadResourceWithBinaryPathServer = async (params) => {
+  return baseServerRequest(`ids/v1/Resources/${encodeURIComponent(String(params.renditionId))}/${encodeURIComponent(String(params.binaryPath))}`);
+};
+var resourcesGetPackageServer = async (params, query) => {
+  return baseServerRequest(`Resources/packages/${encodeURIComponent(String(params.id))}`, query);
+};
+var resourcesGetSubjectFromPackageServer = async (params, query) => {
+  return baseServerRequest(`Resources/subjects/${encodeURIComponent(String(params.id))}`, query);
+};
+var resourcesViewResourceServer = async (params) => {
+  return baseServerRequest(`ids/v1/Resources/view/${encodeURIComponent(String(params.renditionId))}`);
+};
+var resourcesViewResourceWithBinaryPathServer = async (params) => {
+  return baseServerRequest(`ids/v1/Resources/view/${encodeURIComponent(String(params.renditionId))}/${encodeURIComponent(String(params.binaryPath))}`);
+};
+var rolesGetAllServer = async (query) => {
+  return baseServerRequest("Roles", query);
+};
+var rolesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Roles/${encodeURIComponent(String(params.id))}`, query);
+};
+var safetiesGetAllServer = async (query) => {
+  return baseServerRequest("Safeties", query);
+};
+var safetiesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Safeties/${encodeURIComponent(String(params.id))}`, query);
+};
+var searchGetAllServer = async (query) => {
+  return baseServerRequest("ids/v1/Search/Facets", query);
+};
+var setupTimesGetAllServer = async (query) => {
+  return baseServerRequest("SetupTimes", query);
+};
+var setupTimesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`SetupTimes/${encodeURIComponent(String(params.id))}`, query);
+};
+var skillLevelsGetAllServer = async (query) => {
+  return baseServerRequest("SkillLevels", query);
+};
+var skillLevelsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`SkillLevels/${encodeURIComponent(String(params.id))}`, query);
+};
+var sparePartsGetAllServer = async (query) => {
+  return baseServerRequest("SpareParts", query);
+};
+var sparePartsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`SpareParts/${encodeURIComponent(String(params.id))}`, query);
+};
+var sparQLExecuteSparQlServer = async (params) => {
+  return baseServerRequest(`SparQL/${encodeURIComponent(String(params.query))}`);
+};
+var suppliesGetAllServer = async (query) => {
+  return baseServerRequest("Supplies", query);
+};
+var suppliesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Supplies/${encodeURIComponent(String(params.id))}`, query);
+};
+var tasksGetAllServer = async (query) => {
+  return baseServerRequest("Tasks", query);
+};
+var tasksGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Tasks/${encodeURIComponent(String(params.id))}`, query);
+};
+var technicalDataGetAllServer = async (query) => {
+  return baseServerRequest("TechnicalData", query);
+};
+var technicalDataGetByIdServer = async (params, query) => {
+  return baseServerRequest(`TechnicalData/${encodeURIComponent(String(params.id))}`, query);
+};
+var technicalOverviewsGetAllServer = async (query) => {
+  return baseServerRequest("TechnicalOverviews", query);
+};
+var technicalOverviewsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`TechnicalOverviews/${encodeURIComponent(String(params.id))}`, query);
+};
+var topicsGetAllServer = async (query) => {
+  return baseServerRequest("Topics", query);
+};
+var topicsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Topics/${encodeURIComponent(String(params.id))}`, query);
+};
+var topicsLanguagesServer = async (query) => {
+  return baseServerRequest("Topics/Languages", query);
+};
+var topicTypesGetAllServer = async (query) => {
+  return baseServerRequest("TopicTypes", query);
+};
+var topicTypesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`TopicTypes/${encodeURIComponent(String(params.id))}`, query);
+};
+var troubleShootingsGetAllServer = async (query) => {
+  return baseServerRequest("TroubleShootings", query);
+};
+var troubleShootingsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`TroubleShootings/${encodeURIComponent(String(params.id))}`, query);
+};
+var usesGetAllServer = async (query) => {
+  return baseServerRequest("Uses", query);
+};
+var usesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`Uses/${encodeURIComponent(String(params.id))}`, query);
+};
+var vCardsGetAllServer = async (query) => {
+  return baseServerRequest("vcard/v1/VCards", query);
+};
+var vCardsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`vcard/v1/VCards/${encodeURIComponent(String(params.id))}`, query);
+};
+var warningMessagesGetAllServer = async (query) => {
+  return baseServerRequest("WarningMessages", query);
+};
+var warningMessagesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`WarningMessages/${encodeURIComponent(String(params.id))}`, query);
+};
+var workingTimesGetAllServer = async (query) => {
+  return baseServerRequest("WorkingTimes", query);
+};
+var workingTimesGetByIdServer = async (params, query) => {
+  return baseServerRequest(`WorkingTimes/${encodeURIComponent(String(params.id))}`, query);
+};
+
+// src/base-client-request.ts
+var baseClientRequest = async (endpoint, queryParams) => {
+  const res = await fetch(`/api/rpc`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      method: "CrexApi.execute",
+      params: {
+        url: endpoint,
+        method: "GET",
+        params: queryParams
+      }
+    }),
+    credentials: "include"
+  });
+  const json = await res.json();
+  if (!res.ok) throw new Error(json.error || "Unknown error");
+  return json.data;
+};
+
+// src/generated/client-requests.ts
+var administrativeMetadataGetAllClientService = async (query) => {
+  return baseClientRequest("AdministrativeMetadata", query);
+};
+var administrativeMetadataGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`AdministrativeMetadata/${encodeURIComponent(String(params.id))}`, query);
+};
+var afterUsesGetAllClientService = async (query) => {
+  return baseClientRequest("AfterUses", query);
+};
+var afterUsesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`AfterUses/${encodeURIComponent(String(params.id))}`, query);
+};
+var categoriesGetAllClientService = async (query) => {
+  return baseClientRequest("crex/v1/Categories", query);
+};
+var categoriesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`crex/v1/Categories/${encodeURIComponent(String(params.id))}`, query);
+};
+var collectionsGetAllClientService = async (query) => {
+  return baseClientRequest("Collections", query);
+};
+var collectionsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Collections/${encodeURIComponent(String(params.id))}`, query);
+};
+var componentsGetAllClientService = async (query) => {
+  return baseClientRequest("Components", query);
+};
+var componentsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Components/${encodeURIComponent(String(params.id))}`, query);
+};
+var conceptsGetAllClientService = async (query) => {
+  return baseClientRequest("Concepts", query);
+};
+var conceptsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Concepts/${encodeURIComponent(String(params.id))}`, query);
+};
+var conformitiesGetAllClientService = async (query) => {
+  return baseClientRequest("Conformities", query);
+};
+var conformitiesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Conformities/${encodeURIComponent(String(params.id))}`, query);
+};
+var consumablesGetAllClientService = async (query) => {
+  return baseClientRequest("Consumables", query);
+};
+var consumablesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Consumables/${encodeURIComponent(String(params.id))}`, query);
+};
+var contentLifeCycleStatusGetAllClientService = async (query) => {
+  return baseClientRequest("ContentLifeCycleStatus", query);
+};
+var contentLifeCycleStatusGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`ContentLifeCycleStatus/${encodeURIComponent(String(params.id))}`, query);
+};
+var designAndRealizationsGetAllClientService = async (query) => {
+  return baseClientRequest("DesignAndRealizations", query);
+};
+var designAndRealizationsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`DesignAndRealizations/${encodeURIComponent(String(params.id))}`, query);
+};
+var directoryNodesGetAllClientService = async (query) => {
+  return baseClientRequest("DirectoryNodes", query);
+};
+var directoryNodesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`DirectoryNodes/${encodeURIComponent(String(params.id))}`, query);
+};
+var directoryNodeTypesGetAllClientService = async (query) => {
+  return baseClientRequest("DirectoryNodeTypes", query);
+};
+var directoryNodeTypesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`DirectoryNodeTypes/${encodeURIComponent(String(params.id))}`, query);
+};
+var documentationMetadataGetAllClientService = async (query) => {
+  return baseClientRequest("DocumentationMetadata", query);
+};
+var documentationMetadataGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`DocumentationMetadata/${encodeURIComponent(String(params.id))}`, query);
+};
+var documentsGetAllClientService = async (query) => {
+  return baseClientRequest("Documents", query);
+};
+var documentsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Documents/${encodeURIComponent(String(params.id))}`, query);
+};
+var documentsLanguagesClientService = async (query) => {
+  return baseClientRequest("Documents/Languages", query);
+};
+var documentTypesGetAllClientService = async (query) => {
+  return baseClientRequest("DocumentTypes", query);
+};
+var documentTypesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`DocumentTypes/${encodeURIComponent(String(params.id))}`, query);
+};
+var domainEntitiesGetAllClientService = async (query) => {
+  return baseClientRequest("DomainEntities", query);
+};
+var domainEntitiesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`DomainEntities/${encodeURIComponent(String(params.id))}`, query);
+};
+var downTimesGetAllClientService = async (query) => {
+  return baseClientRequest("DownTimes", query);
+};
+var downTimesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`DownTimes/${encodeURIComponent(String(params.id))}`, query);
+};
+var eventsGetAllClientService = async (query) => {
+  return baseClientRequest("Events", query);
+};
+var eventsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Events/${encodeURIComponent(String(params.id))}`, query);
+};
+var formalitiesGetAllClientService = async (query) => {
+  return baseClientRequest("Formalities", query);
+};
+var formalitiesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Formalities/${encodeURIComponent(String(params.id))}`, query);
+};
+var formsGetAllClientService = async (query) => {
+  return baseClientRequest("Forms", query);
+};
+var formsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Forms/${encodeURIComponent(String(params.id))}`, query);
+};
+var fragmentsGetAllClientService = async (query) => {
+  return baseClientRequest("Fragments", query);
+};
+var fragmentsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Fragments/${encodeURIComponent(String(params.id))}`, query);
+};
+var fragmentsLanguagesClientService = async (query) => {
+  return baseClientRequest("Fragments/Languages", query);
+};
+var functionalitiesGetAllClientService = async (query) => {
+  return baseClientRequest("Functionalities", query);
+};
+var functionalitiesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Functionalities/${encodeURIComponent(String(params.id))}`, query);
+};
+var functionalMetadatasGetAllClientService = async (query) => {
+  return baseClientRequest("FunctionalMetadatas", query);
+};
+var functionalMetadatasGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`FunctionalMetadatas/${encodeURIComponent(String(params.id))}`, query);
+};
+var groupsGetAllClientService = async (query) => {
+  return baseClientRequest("vcard/v1/Groups", query);
+};
+var groupsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`vcard/v1/Groups/${encodeURIComponent(String(params.id))}`, query);
+};
+var hardwareToolsGetAllClientService = async (query) => {
+  return baseClientRequest("HardwareTools", query);
+};
+var hardwareToolsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`HardwareTools/${encodeURIComponent(String(params.id))}`, query);
+};
+var identitiesGetAllClientService = async (query) => {
+  return baseClientRequest("Identities", query);
+};
+var identitiesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Identities/${encodeURIComponent(String(params.id))}`, query);
+};
+var identityDomainsGetAllClientService = async (query) => {
+  return baseClientRequest("IdentityDomains", query);
+};
+var identityDomainsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`IdentityDomains/${encodeURIComponent(String(params.id))}`, query);
+};
+var individualsGetAllClientService = async (query) => {
+  return baseClientRequest("vcard/v1/Individuals", query);
+};
+var individualsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`vcard/v1/Individuals/${encodeURIComponent(String(params.id))}`, query);
+};
+var informationObjectsGetAllClientService = async (query) => {
+  return baseClientRequest("InformationObjects", query);
+};
+var informationObjectsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`InformationObjects/${encodeURIComponent(String(params.id))}`, query);
+};
+var informationSubjectsGetAllClientService = async (query) => {
+  return baseClientRequest("InformationSubjects", query);
+};
+var informationSubjectsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`InformationSubjects/${encodeURIComponent(String(params.id))}`, query);
+};
+var informationTypesGetAllClientService = async (query) => {
+  return baseClientRequest("InformationTypes", query);
+};
+var informationTypesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`InformationTypes/${encodeURIComponent(String(params.id))}`, query);
+};
+var informationUnitsGetAllClientService = async (query) => {
+  return baseClientRequest("InformationUnits", query);
+};
+var informationUnitsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`InformationUnits/${encodeURIComponent(String(params.id))}`, query);
+};
+var informationUnitsLanguagesClientService = async (query) => {
+  return baseClientRequest("InformationUnits/Languages", query);
+};
+var learningsGetAllClientService = async (query) => {
+  return baseClientRequest("Learnings", query);
+};
+var learningsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Learnings/${encodeURIComponent(String(params.id))}`, query);
+};
+var locationsGetAllClientService = async (query) => {
+  return baseClientRequest("vcard/v1/Locations", query);
+};
+var locationsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`vcard/v1/Locations/${encodeURIComponent(String(params.id))}`, query);
+};
+var lubricantsGetAllClientService = async (query) => {
+  return baseClientRequest("Lubricants", query);
+};
+var lubricantsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Lubricants/${encodeURIComponent(String(params.id))}`, query);
+};
+var maintenanceIntervalsGetAllClientService = async (query) => {
+  return baseClientRequest("MaintenanceIntervals", query);
+};
+var maintenanceIntervalsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`MaintenanceIntervals/${encodeURIComponent(String(params.id))}`, query);
+};
+var operatingSuppliesGetAllClientService = async (query) => {
+  return baseClientRequest("OperatingSupplies", query);
+};
+var operatingSuppliesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`OperatingSupplies/${encodeURIComponent(String(params.id))}`, query);
+};
+var organizationsGetAllClientService = async (query) => {
+  return baseClientRequest("vcard/v1/Organizations", query);
+};
+var organizationsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`vcard/v1/Organizations/${encodeURIComponent(String(params.id))}`, query);
+};
+var packagesCreateClientAppClientService = async (query) => {
+  return baseClientRequest("ids/v1/Packages/CreateClientApp", query);
+};
+var packagesGetAllClientService = async (query) => {
+  return baseClientRequest("Packages", query);
+};
+var packagesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Packages/${encodeURIComponent(String(params.id))}`, query);
+};
+var packagesLanguagesClientService = async (query) => {
+  return baseClientRequest("Packages/Languages", query);
+};
+var partiesGetAllClientService = async (query) => {
+  return baseClientRequest("Parties", query);
+};
+var partiesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Parties/${encodeURIComponent(String(params.id))}`, query);
+};
+var planningTimesGetAllClientService = async (query) => {
+  return baseClientRequest("PlanningTimes", query);
+};
+var planningTimesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`PlanningTimes/${encodeURIComponent(String(params.id))}`, query);
+};
+var processesGetAllClientService = async (query) => {
+  return baseClientRequest("Processes", query);
+};
+var processesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Processes/${encodeURIComponent(String(params.id))}`, query);
+};
+var productFeaturesGetAllClientService = async (query) => {
+  return baseClientRequest("ProductFeatures", query);
+};
+var productFeaturesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`ProductFeatures/${encodeURIComponent(String(params.id))}`, query);
+};
+var productFunctionsGetAllClientService = async (query) => {
+  return baseClientRequest("ProductFunctions", query);
+};
+var productFunctionsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`ProductFunctions/${encodeURIComponent(String(params.id))}`, query);
+};
+var productLifeCyclePhasesGetAllClientService = async (query) => {
+  return baseClientRequest("ProductLifeCyclePhases", query);
+};
+var productLifeCyclePhasesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`ProductLifeCyclePhases/${encodeURIComponent(String(params.id))}`, query);
+};
+var productMetadataGetAllClientService = async (query) => {
+  return baseClientRequest("ProductMetadata", query);
+};
+var productMetadataGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`ProductMetadata/${encodeURIComponent(String(params.id))}`, query);
+};
+var productPropertiesGetAllClientService = async (query) => {
+  return baseClientRequest("ProductProperties", query);
+};
+var productPropertiesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`ProductProperties/${encodeURIComponent(String(params.id))}`, query);
+};
+var productVariantsGetAllClientService = async (query) => {
+  return baseClientRequest("ProductVariants", query);
+};
+var productVariantsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`ProductVariants/${encodeURIComponent(String(params.id))}`, query);
+};
+var puttingToUsesGetAllClientService = async (query) => {
+  return baseClientRequest("PuttingToUses", query);
+};
+var puttingToUsesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`PuttingToUses/${encodeURIComponent(String(params.id))}`, query);
+};
+var qualificationsGetAllClientService = async (query) => {
+  return baseClientRequest("Qualifications", query);
+};
+var qualificationsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Qualifications/${encodeURIComponent(String(params.id))}`, query);
+};
+var referencesGetAllClientService = async (query) => {
+  return baseClientRequest("References", query);
+};
+var referencesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`References/${encodeURIComponent(String(params.id))}`, query);
+};
+var renditionsGetAllClientService = async (query) => {
+  return baseClientRequest("Renditions", query);
+};
+var renditionsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Renditions/${encodeURIComponent(String(params.id))}`, query);
+};
+var renditionsGetWithBinaryWithBinaryPathClientService = async (params) => {
+  return baseClientRequest(`Renditions/${encodeURIComponent(String(params.id))}/${encodeURIComponent(String(params.binaryPath))}`);
+};
+var resourcesDownloadResourceClientService = async (params) => {
+  return baseClientRequest(`ids/v1/Resources/${encodeURIComponent(String(params.renditionId))}`);
+};
+var resourcesDownloadResourceWithBinaryPathClientService = async (params) => {
+  return baseClientRequest(`ids/v1/Resources/${encodeURIComponent(String(params.renditionId))}/${encodeURIComponent(String(params.binaryPath))}`);
+};
+var resourcesGetPackageClientService = async (params, query) => {
+  return baseClientRequest(`Resources/packages/${encodeURIComponent(String(params.id))}`, query);
+};
+var resourcesGetSubjectFromPackageClientService = async (params, query) => {
+  return baseClientRequest(`Resources/subjects/${encodeURIComponent(String(params.id))}`, query);
+};
+var resourcesViewResourceClientService = async (params) => {
+  return baseClientRequest(`ids/v1/Resources/view/${encodeURIComponent(String(params.renditionId))}`);
+};
+var resourcesViewResourceWithBinaryPathClientService = async (params) => {
+  return baseClientRequest(`ids/v1/Resources/view/${encodeURIComponent(String(params.renditionId))}/${encodeURIComponent(String(params.binaryPath))}`);
+};
+var rolesGetAllClientService = async (query) => {
+  return baseClientRequest("Roles", query);
+};
+var rolesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Roles/${encodeURIComponent(String(params.id))}`, query);
+};
+var safetiesGetAllClientService = async (query) => {
+  return baseClientRequest("Safeties", query);
+};
+var safetiesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Safeties/${encodeURIComponent(String(params.id))}`, query);
+};
+var searchGetAllClientService = async (query) => {
+  return baseClientRequest("ids/v1/Search/Facets", query);
+};
+var setupTimesGetAllClientService = async (query) => {
+  return baseClientRequest("SetupTimes", query);
+};
+var setupTimesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`SetupTimes/${encodeURIComponent(String(params.id))}`, query);
+};
+var skillLevelsGetAllClientService = async (query) => {
+  return baseClientRequest("SkillLevels", query);
+};
+var skillLevelsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`SkillLevels/${encodeURIComponent(String(params.id))}`, query);
+};
+var sparePartsGetAllClientService = async (query) => {
+  return baseClientRequest("SpareParts", query);
+};
+var sparePartsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`SpareParts/${encodeURIComponent(String(params.id))}`, query);
+};
+var sparQLExecuteSparQlClientService = async (params) => {
+  return baseClientRequest(`SparQL/${encodeURIComponent(String(params.query))}`);
+};
+var suppliesGetAllClientService = async (query) => {
+  return baseClientRequest("Supplies", query);
+};
+var suppliesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Supplies/${encodeURIComponent(String(params.id))}`, query);
+};
+var tasksGetAllClientService = async (query) => {
+  return baseClientRequest("Tasks", query);
+};
+var tasksGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Tasks/${encodeURIComponent(String(params.id))}`, query);
+};
+var technicalDataGetAllClientService = async (query) => {
+  return baseClientRequest("TechnicalData", query);
+};
+var technicalDataGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`TechnicalData/${encodeURIComponent(String(params.id))}`, query);
+};
+var technicalOverviewsGetAllClientService = async (query) => {
+  return baseClientRequest("TechnicalOverviews", query);
+};
+var technicalOverviewsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`TechnicalOverviews/${encodeURIComponent(String(params.id))}`, query);
+};
+var topicsGetAllClientService = async (query) => {
+  return baseClientRequest("Topics", query);
+};
+var topicsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Topics/${encodeURIComponent(String(params.id))}`, query);
+};
+var topicsLanguagesClientService = async (query) => {
+  return baseClientRequest("Topics/Languages", query);
+};
+var topicTypesGetAllClientService = async (query) => {
+  return baseClientRequest("TopicTypes", query);
+};
+var topicTypesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`TopicTypes/${encodeURIComponent(String(params.id))}`, query);
+};
+var troubleShootingsGetAllClientService = async (query) => {
+  return baseClientRequest("TroubleShootings", query);
+};
+var troubleShootingsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`TroubleShootings/${encodeURIComponent(String(params.id))}`, query);
+};
+var usesGetAllClientService = async (query) => {
+  return baseClientRequest("Uses", query);
+};
+var usesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`Uses/${encodeURIComponent(String(params.id))}`, query);
+};
+var vCardsGetAllClientService = async (query) => {
+  return baseClientRequest("vcard/v1/VCards", query);
+};
+var vCardsGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`vcard/v1/VCards/${encodeURIComponent(String(params.id))}`, query);
+};
+var warningMessagesGetAllClientService = async (query) => {
+  return baseClientRequest("WarningMessages", query);
+};
+var warningMessagesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`WarningMessages/${encodeURIComponent(String(params.id))}`, query);
+};
+var workingTimesGetAllClientService = async (query) => {
+  return baseClientRequest("WorkingTimes", query);
+};
+var workingTimesGetByIdClientService = async (params, query) => {
+  return baseClientRequest(`WorkingTimes/${encodeURIComponent(String(params.id))}`, query);
+};
+
+// src/vcard/profile-utils.ts
+var import_sdk = require("@c-rex/core/sdk");
+var import_constants = require("@c-rex/constants");
+var import_headers = require("next/headers");
+var DEFAULT_LOGO_SRC = "/img/logo.png";
+var normalizePathLikeImageSource = (value) => {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("data:") || trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  return `/${trimmed}`;
+};
+var resolveLogoSource = (images = []) => {
+  const sourceFirst = images.map((image) => normalizePathLikeImageSource(image.source)).find((value) => Boolean(value));
+  if (!sourceFirst) {
+    console.warn("[VCardProfile] No usable VCARD image source found. Ignoring 'value' until IDS provides absolute resource URLs.");
+  }
+  return sourceFirst;
+};
+var normalizeHref = (value) => {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("mailto:") || trimmed.startsWith("tel:")) {
+    return trimmed;
+  }
+  return `https://${trimmed}`;
+};
+var SOCIAL_MEDIA_TYPE_URI = "https://www.c-rex.net/ns/iirds/vcard#SocialMedia";
+var SOCIAL_MEDIA_TYPE_URI_NORMALIZED = SOCIAL_MEDIA_TYPE_URI.toLowerCase();
+var isSocialMediaType = (value) => {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === SOCIAL_MEDIA_TYPE_URI_NORMALIZED || normalized.endsWith("#socialmedia");
+};
+var isSocialMediaUrlEntry = (url) => {
+  const hasTypedMarker = Array.isArray(url.types) && url.types.some((type) => isSocialMediaType(type));
+  if (hasTypedMarker) return true;
+  const hasClassMarker = Array.isArray(url.classes) && url.classes.some((cls) => isSocialMediaType(cls?.id));
+  if (hasClassMarker) return true;
+  const hasClassLabelMarker = Array.isArray(url.classes) && url.classes.some(
+    (cls) => (cls?.labels || []).some((label) => (label.value || "").trim().toLowerCase() === "social media")
+  );
+  return hasClassLabelMarker;
+};
+var SOCIAL_PROVIDER_BY_HOST = [
+  { hostPattern: /(^|\.)x\.com$/i, label: "X" },
+  { hostPattern: /(^|\.)twitter\.com$/i, label: "Twitter" },
+  { hostPattern: /(^|\.)facebook\.com$/i, label: "Facebook" },
+  { hostPattern: /(^|\.)instagram\.com$/i, label: "Instagram" },
+  { hostPattern: /(^|\.)youtube\.com$/i, label: "YouTube" },
+  { hostPattern: /(^|\.)youtu\.be$/i, label: "YouTube" },
+  { hostPattern: /(^|\.)linkedin\.com$/i, label: "LinkedIn" },
+  { hostPattern: /(^|\.)xing\.com$/i, label: "Xing" }
+];
+var resolveSocialProviderLabel = (href) => {
+  try {
+    const hostname = new URL(href).hostname.toLowerCase();
+    const provider = SOCIAL_PROVIDER_BY_HOST.find((entry) => entry.hostPattern.test(hostname));
+    return provider?.label || hostname.replace(/^www\./i, "");
+  } catch {
+    return "Social";
+  }
+};
+var isKnownSocialProviderHref = (href) => {
+  try {
+    const hostname = new URL(href).hostname.toLowerCase();
+    return SOCIAL_PROVIDER_BY_HOST.some((entry) => entry.hostPattern.test(hostname));
+  } catch {
+    return false;
+  }
+};
+var resolveTypedSocialLinks = (urls = []) => {
+  const items = urls.filter((url) => {
+    if (isSocialMediaUrlEntry(url)) return true;
+    const href = normalizeHref(url.value);
+    return Boolean(href && isKnownSocialProviderHref(href));
+  }).map((url) => normalizeHref(url.value)).filter((value) => Boolean(value));
+  const byHref = /* @__PURE__ */ new Map();
+  items.forEach((href) => {
+    if (byHref.has(href)) return;
+    const label = resolveSocialProviderLabel(href);
+    byHref.set(href, {
+      href,
+      label,
+      provider: label
+    });
+  });
+  return Array.from(byHref.values());
+};
+var normalizePhone = (value) => {
+  if (!value) return void 0;
+  return value.replace(/^tel:/i, "").trim() || void 0;
+};
+var isDialablePhone = (value) => {
+  if (!value) return false;
+  const normalized = value.trim();
+  if (!normalized) return false;
+  if (!/\d/.test(normalized)) return false;
+  return /^[+\d()[\]\-./\s]+$/.test(normalized);
+};
+var normalizePhoneHref = (value) => {
+  if (!value) return void 0;
+  const normalizedPhone = normalizePhone(value);
+  if (!normalizedPhone || !isDialablePhone(normalizedPhone)) return void 0;
+  return `tel:${normalizedPhone}`;
+};
+var normalizeEmail = (value) => {
+  if (!value) return void 0;
+  return value.replace(/^mailto:/i, "").trim() || void 0;
+};
+var normalizeLanguage = (value) => {
+  return (value || "").trim().toLowerCase().replace("_", "-");
+};
+var getLiteralLanguage = (literal) => {
+  const language = literal.language || literal["xml:lang"] || "";
+  return normalizeLanguage(language);
+};
+var getLocalizedLiteral = (labels = [], uiLanguage) => {
+  const normalizedUiLanguage = normalizeLanguage(uiLanguage);
+  const normalizedUiBaseLanguage = normalizedUiLanguage.split("-")[0];
+  const exact = labels.find((item) => getLiteralLanguage(item) === normalizedUiLanguage)?.value?.trim();
+  if (exact) return exact;
+  const base = labels.find((item) => getLiteralLanguage(item).startsWith(`${normalizedUiBaseLanguage}`))?.value?.trim();
+  if (base) return base;
+  const fallback = labels.find((item) => (item.value || "").trim().length > 0)?.value?.trim();
+  return fallback || void 0;
+};
+var buildTelephoneEntries = (telephones = [], uiLanguage) => {
+  return telephones.reduce((entries, telephone) => {
+    const normalizedValue = normalizePhone(telephone.value);
+    if (!normalizedValue) return entries;
+    const classLabels = (telephone.classes || []).map((cls) => getLocalizedLiteral(cls.labels || [], uiLanguage)).filter((value) => Boolean(value));
+    const dedupedClassLabels = Array.from(
+      new Map(classLabels.map((value) => [value.toLowerCase(), value])).values()
+    );
+    entries.push({
+      label: dedupedClassLabels.length > 0 ? dedupedClassLabels.join(" ") : "",
+      value: normalizedValue,
+      href: normalizePhoneHref(telephone.value)
+    });
+    return entries;
+  }, []);
+};
+var resolveUiLanguage = () => {
+  const sdk = new import_sdk.CrexSDK();
+  const clientConfig = sdk.getClientConfig();
+  const defaultLanguage = normalizeLanguage(clientConfig.languageSwitcher.default || "en-us");
+  const uiLanguageFromCookie = (0, import_headers.cookies)().get(import_constants.UI_LANG_KEY)?.value;
+  return normalizeLanguage(uiLanguageFromCookie) || defaultLanguage;
+};
+var buildAddressLines = (address) => {
+  if (!address) return [];
+  const line1 = [address.streetAddress].filter(Boolean).join(" ").trim();
+  const line2 = [address.postalCode, address.locality].filter(Boolean).join(" ").trim();
+  const line3 = [address.countryName].filter(Boolean).join(" ").trim();
+  return [line1, line2, line3].filter((line) => line.length > 0);
+};
+var mapVCardEntityToBaseProfile = (entity, options) => {
+  const preferredAddress = entity.addresses?.[0];
+  const preferredEmail = entity.emails?.[0];
+  const preferredWebsite = entity.urls?.find((item) => normalizeHref(item.value));
+  const logoSrc = resolveLogoSource([...entity.logos || [], ...entity.photos || []]) || (options.logoFallbackSrc || DEFAULT_LOGO_SRC);
+  return {
+    id: entity.id || void 0,
+    displayName: entity.organizationName?.trim() || entity.fullName?.trim() || options.displayNameFallback,
+    logoSrc,
+    addressLines: buildAddressLines(preferredAddress),
+    email: normalizeEmail(preferredEmail?.value),
+    telephoneEntries: buildTelephoneEntries(entity.telephones || [], options.uiLanguage),
+    website: normalizeHref(preferredWebsite?.value)
+  };
+};
+var decodeEncodedVcardId = (encodedId) => {
+  try {
+    return decodeURIComponent(encodedId);
+  } catch (error) {
+    console.error(`[VCardProfile] Invalid encoded VCARD ID value: "${encodedId}".`, error);
+    return void 0;
+  }
+};
+var getServerConfig = () => {
+  const sdk = new import_sdk.CrexSDK();
+  return sdk.getServerConfig();
+};
+
+// src/vcard/organization-profile.ts
+var import_requests2 = require("@c-rex/core/requests");
+var import_cache = require("next/cache");
+
+// src/read-models/cache-policy.ts
+var readPositiveInt = (rawValue, fallback) => {
+  const parsed = Number(rawValue);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return Math.floor(parsed);
+};
+var READMODEL_CACHE_POLICY = {
+  metadataRevalidateSeconds: readPositiveInt(
+    process.env.CREX_CACHE_REVALIDATE_METADATA_SECONDS,
+    2 * 60 * 60
+  ),
+  vcardRevalidateSeconds: readPositiveInt(
+    process.env.CREX_CACHE_REVALIDATE_VCARD_SECONDS,
+    6 * 60 * 60
+  ),
+  requestsRevalidateSeconds: readPositiveInt(
+    process.env.CREX_CACHE_REVALIDATE_REQUESTS_SECONDS,
+    15 * 60
+  )
+};
+
+// src/vcard/organization-profile.ts
+var toOrganizationProfile = (organization, options) => {
+  const base = mapVCardEntityToBaseProfile(organization, {
+    uiLanguage: options.uiLanguage,
+    displayNameFallback: options.displayNameFallback,
+    logoFallbackSrc: options.logoFallbackSrc
+  });
+  return {
+    ...base,
+    organizationName: base.displayName,
+    socialLinks: resolveTypedSocialLinks(organization.urls || []).map((item) => ({
+      label: item.label,
+      href: item.href
+    }))
+  };
+};
+var ORGANIZATION_PROFILE_REQUIRED_FIELDS = [
+  "organizationName",
+  "fullName",
+  "logos",
+  "photos",
+  "emails",
+  "telephones",
+  "addresses",
+  "urls"
+];
+var resolveOrganizationProfileQuery = (query) => {
+  if (!query) return void 0;
+  if (!Array.isArray(query.Fields) || query.Fields.length === 0) return query;
+  const mergedFields = Array.from(/* @__PURE__ */ new Set([...query.Fields, ...ORGANIZATION_PROFILE_REQUIRED_FIELDS]));
+  return {
+    ...query,
+    Fields: mergedFields
+  };
+};
+var fetchOrganizationProfileById = async (id, query, context) => {
+  try {
+    const organization = await organizationsGetByIdServer({ id }, resolveOrganizationProfileQuery(query));
+    return toOrganizationProfile(organization, {
+      uiLanguage: context.uiLanguage,
+      displayNameFallback: context.fallbackName,
+      logoFallbackSrc: context.logoFallbackSrc
+    });
+  } catch (error) {
+    console.error(`[OrganizationProfile] Failed to load VCARD organization "${id}".`, error);
+    return {
+      id,
+      logoSrc: context.logoFallbackSrc,
+      displayName: context.fallbackName,
+      organizationName: context.fallbackName,
+      addressLines: [],
+      telephoneEntries: [],
+      socialLinks: []
+    };
+  }
+};
+var getOrganizationProfileById = async (id, query) => {
+  const serverConfig = getServerConfig();
+  const uiLanguage = resolveUiLanguage();
+  const fallbackName = serverConfig.projectName;
+  const logoFallbackSrc = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+  return fetchOrganizationProfileById(id, query, {
+    uiLanguage,
+    fallbackName,
+    logoFallbackSrc
+  });
+};
+var getOrganizationProfileByIdCached = (0, import_cache.unstable_cache)(
+  async (id, query, context) => withServerRequestContext(
+    { skipCookieTokenLookup: true },
+    () => fetchOrganizationProfileById(id, query, context)
+  ),
+  ["read-model", "organization-profile-v2"],
+  {
+    revalidate: READMODEL_CACHE_POLICY.vcardRevalidateSeconds,
+    tags: [
+      import_requests2.CREX_API_CACHE_TAG,
+      import_requests2.CREX_API_CACHE_VCARD_TAG,
+      import_requests2.CREX_READMODEL_CACHE_TAG,
+      import_requests2.CREX_READMODEL_CACHE_VCARD_TAG,
+      import_requests2.CREX_READMODEL_CACHE_ORGANIZATION_TAG
+    ]
+  }
+);
+var getOrganizationsProfiles = async (query) => {
+  const serverConfig = getServerConfig();
+  const uiLanguage = resolveUiLanguage();
+  const fallbackName = serverConfig.projectName;
+  const logoFallbackSrc = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+  const result = await organizationsGetAllServer(query);
+  return result.items.map(
+    (organization) => toOrganizationProfile(organization, {
+      uiLanguage,
+      displayNameFallback: fallbackName,
+      logoFallbackSrc
+    })
+  );
+};
+var getOrganizationProfile = async () => {
+  const serverConfig = getServerConfig();
+  const rawVcardId = process.env.CREX_ORGANIZATION_VCARD_ID?.trim();
+  const encodedVcardId = process.env.CREX_ORGANIZATION_VCARD_ID_ENCODED?.trim();
+  const decodedEncodedVcardId = encodedVcardId ? decodeEncodedVcardId(encodedVcardId) : void 0;
+  const configuredVcardId = rawVcardId || decodedEncodedVcardId || serverConfig.organization?.vcardId?.trim();
+  if (!configuredVcardId) {
+    console.info("[OrganizationProfile] No VCARD organization ID configured. Using fallback branding.");
+    const logoFallbackSrc2 = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+    const fallbackName2 = serverConfig.projectName;
+    return {
+      logoSrc: logoFallbackSrc2,
+      displayName: fallbackName2,
+      organizationName: fallbackName2,
+      addressLines: [],
+      telephoneEntries: [],
+      socialLinks: []
+    };
+  }
+  if (rawVcardId && rawVcardId.startsWith("http") && !rawVcardId.includes("#")) {
+    console.warn(
+      `[OrganizationProfile] VCARD ID does not contain "#": "${rawVcardId}". If this value comes from .env, wrap it in quotes or use CREX_ORGANIZATION_VCARD_ID_ENCODED.`
+    );
+  }
+  const uiLanguage = resolveUiLanguage();
+  const fallbackName = serverConfig.projectName;
+  const logoFallbackSrc = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+  const context = {
+    uiLanguage,
+    fallbackName,
+    logoFallbackSrc
+  };
+  if (process.env.NODE_ENV === "test") {
+    return fetchOrganizationProfileById(configuredVcardId, void 0, context);
+  }
+  return getOrganizationProfileByIdCached(configuredVcardId, void 0, context);
+};
+var getOrganizationBranding = async () => {
+  const profile = await getOrganizationProfile();
+  return {
+    logoSrc: profile.logoSrc,
+    organizationName: profile.organizationName
+  };
+};
+
+// src/vcard/individual-profile.ts
+var toIndividualProfile = (individual, options) => {
+  const base = mapVCardEntityToBaseProfile(individual, {
+    uiLanguage: options.uiLanguage,
+    displayNameFallback: options.displayNameFallback,
+    logoFallbackSrc: options.logoFallbackSrc
+  });
+  return {
+    ...base,
+    fullName: base.displayName,
+    title: individual.title?.trim() || void 0,
+    role: individual.role?.trim() || void 0
+  };
+};
+var getIndividualProfileById = async (id, query) => {
+  const uiLanguage = resolveUiLanguage();
+  try {
+    const individual = await individualsGetByIdServer({ id }, query);
+    return toIndividualProfile(individual, {
+      uiLanguage,
+      displayNameFallback: id,
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    });
+  } catch (error) {
+    console.error(`[IndividualProfile] Failed to load VCARD individual "${id}".`, error);
+    return {
+      id,
+      logoSrc: DEFAULT_LOGO_SRC,
+      displayName: id,
+      fullName: id,
+      addressLines: [],
+      telephoneEntries: []
+    };
+  }
+};
+var getIndividualsProfiles = async (query) => {
+  const uiLanguage = resolveUiLanguage();
+  const result = await individualsGetAllServer(query);
+  return result.items.map(
+    (individual) => toIndividualProfile(individual, {
+      uiLanguage,
+      displayNameFallback: individual.id || "Unknown individual",
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    })
+  );
+};
+
+// src/vcard/vcard-profile.ts
+var toVCardProfile = (vcard, options) => {
+  const base = mapVCardEntityToBaseProfile(vcard, {
+    uiLanguage: options.uiLanguage,
+    displayNameFallback: options.displayNameFallback,
+    logoFallbackSrc: options.logoFallbackSrc
+  });
+  return {
+    ...base,
+    fullName: base.displayName
+  };
+};
+var getVCardProfileById = async (id, query) => {
+  const uiLanguage = resolveUiLanguage();
+  try {
+    const vcard = await vCardsGetByIdServer({ id }, query);
+    return toVCardProfile(vcard, {
+      uiLanguage,
+      displayNameFallback: id,
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    });
+  } catch (error) {
+    console.error(`[VCardProfile] Failed to load VCARD "${id}".`, error);
+    return {
+      id,
+      logoSrc: DEFAULT_LOGO_SRC,
+      displayName: id,
+      fullName: id,
+      addressLines: [],
+      telephoneEntries: []
+    };
+  }
+};
+var getVCardProfiles = async (query) => {
+  const uiLanguage = resolveUiLanguage();
+  const result = await vCardsGetAllServer(query);
+  return result.items.map(
+    (vcard) => toVCardProfile(vcard, {
+      uiLanguage,
+      displayNameFallback: vcard.id || "Unknown vCard",
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    })
+  );
+};
+
+// src/read-models/metadata-read-models.ts
+var import_requests3 = require("@c-rex/core/requests");
+var import_cache2 = require("next/cache");
+var resolveLocalizedLabel = (labels, uiLanguage) => {
+  if (!labels || labels.length === 0) return void 0;
+  const normalizedUiLanguage = uiLanguage.trim().toLowerCase();
+  const baseLanguage = normalizedUiLanguage.split("-")[0];
+  const normalized = labels.map((item) => ({
+    language: (item.language || "").trim().toLowerCase(),
+    value: (item.value || "").trim()
+  })).filter((item) => item.value.length > 0);
+  const exact = normalized.find((item) => item.language === normalizedUiLanguage)?.value;
+  if (exact) return exact;
+  const base = normalized.find((item) => item.language === baseLanguage)?.value;
+  if (base) return base;
+  const english = normalized.find((item) => item.language === "en" || item.language === "en-us")?.value;
+  if (english) return english;
+  return normalized[0]?.value;
+};
+var stableSerialize = (value) => {
+  const normalize = (input) => {
+    if (Array.isArray(input)) {
+      return input.map((item) => normalize(item));
+    }
+    if (input && typeof input === "object") {
+      const sorted = {};
+      Object.keys(input).sort((a, b) => a.localeCompare(b)).forEach((key) => {
+        sorted[key] = normalize(input[key]);
+      });
+      return sorted;
+    }
+    return input;
+  };
+  return JSON.stringify(normalize(value));
+};
+var READMODEL_PAGE_SIZE = 300;
+var READMODEL_MAX_PAGES = 50;
+var fetchAllPages = async (fetcher, baseQuery) => {
+  const pageSize = baseQuery.PageSize && baseQuery.PageSize > 0 ? baseQuery.PageSize : READMODEL_PAGE_SIZE;
+  const collected = [];
+  for (let pageNumber = 1; pageNumber <= READMODEL_MAX_PAGES; pageNumber += 1) {
+    const pageQuery = {
+      ...baseQuery,
+      PageNumber: pageNumber,
+      PageSize: pageSize
+    };
+    const response = await fetcher(pageQuery);
+    const pageItems = response.items || [];
+    if (pageItems.length === 0) break;
+    collected.push(...pageItems);
+    if (pageItems.length < pageSize) break;
+  }
+  return collected;
+};
+var getRefId = (ref) => ref?.id?.trim() || void 0;
+var toEntityRef = (entity, uiLanguage) => {
+  const id = entity.id?.trim();
+  if (!id) return void 0;
+  const label = resolveLocalizedLabel(entity.labels || [], uiLanguage) || entity.shortId?.trim() || id;
+  return { id, shortId: entity.shortId?.trim() || void 0, label };
+};
+var toClassRef = (classRef, uiLanguage) => {
+  const id = classRef?.id?.trim();
+  if (!id) return void 0;
+  const label = resolveLocalizedLabel(classRef?.labels || [], uiLanguage) || classRef?.shortId?.trim() || id;
+  return { id, shortId: classRef?.shortId?.trim() || void 0, label };
+};
+var deriveParentIds = (entity) => {
+  const directParents = (entity.parents || []).map((parent) => getRefId(parent)).filter((value) => Boolean(value));
+  if (directParents.length > 0) {
+    return Array.from(new Set(directParents));
+  }
+  const ancestorParents = (entity.ancestors || []).map((path) => path[path.length - 1]).map((parent) => getRefId(parent)).filter((value) => Boolean(value));
+  return Array.from(new Set(ancestorParents));
+};
+var deriveAncestorIds = (entity) => {
+  const ids = (entity.ancestors || []).flatMap((path) => path).map((item) => getRefId(item)).filter((value) => Boolean(value));
+  return Array.from(new Set(ids));
+};
+var buildTaxonomyTree = (items, options) => {
+  const nodesById = {};
+  const parentLinks = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const entityRef = toEntityRef(item, options.uiLanguage);
+    if (!entityRef) continue;
+    nodesById[entityRef.id] = {
+      ...entityRef,
+      classRef: toClassRef(item.class, options.uiLanguage),
+      hasInformationUnits: item.hasInformationUnits === true || item.hasInformationUnitReferences === true,
+      parentIds: deriveParentIds(item),
+      ancestorIds: deriveAncestorIds(item),
+      children: []
+    };
+  }
+  Object.values(nodesById).forEach((node) => {
+    parentLinks.set(node.id, node.parentIds.filter((id) => Boolean(nodesById[id])));
+  });
+  if (options.includeOnlyUsed) {
+    const keepIds = new Set(
+      Object.values(nodesById).filter((node) => node.hasInformationUnits === true).map((node) => node.id)
+    );
+    let changed = true;
+    while (changed) {
+      changed = false;
+      Array.from(keepIds).forEach((nodeId) => {
+        const parentIds = parentLinks.get(nodeId) || [];
+        parentIds.forEach((parentId) => {
+          if (!keepIds.has(parentId)) {
+            keepIds.add(parentId);
+            changed = true;
+          }
+        });
+      });
+    }
+    Object.keys(nodesById).forEach((nodeId) => {
+      if (!keepIds.has(nodeId)) {
+        delete nodesById[nodeId];
+        parentLinks.delete(nodeId);
+      }
+    });
+  }
+  Object.values(nodesById).forEach((node) => {
+    const parents = parentLinks.get(node.id) || [];
+    parents.forEach((parentId) => {
+      if (nodesById[parentId]) {
+        nodesById[parentId].children.push(node);
+      }
+    });
+  });
+  const roots = Object.values(nodesById).filter((node) => (parentLinks.get(node.id) || []).length === 0);
+  if (!options.groupRootsByClass) {
+    return {
+      roots: roots.sort((a, b) => a.label.localeCompare(b.label)),
+      nodesById,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const groupedRoots = /* @__PURE__ */ new Map();
+  const ungroupedRootId = "class:ungrouped";
+  groupedRoots.set(ungroupedRootId, {
+    id: ungroupedRootId,
+    label: "Ungrouped",
+    parentIds: [],
+    ancestorIds: [],
+    children: [],
+    isVirtualGroup: true
+  });
+  roots.forEach((root) => {
+    const classId = root.classRef?.id || ungroupedRootId;
+    if (!groupedRoots.has(classId)) {
+      groupedRoots.set(classId, {
+        id: classId,
+        shortId: root.classRef?.shortId,
+        label: root.classRef?.label || "Ungrouped",
+        parentIds: [],
+        ancestorIds: [],
+        children: [],
+        isVirtualGroup: true
+      });
+    }
+    groupedRoots.get(classId)?.children.push(root);
+  });
+  const groupedRootNodes = Array.from(groupedRoots.values()).filter((group) => group.children.length > 0).map((group) => ({
+    ...group,
+    children: [...group.children].sort((a, b) => a.label.localeCompare(b.label))
+  })).sort((a, b) => a.label.localeCompare(b.label));
+  return {
+    roots: groupedRootNodes,
+    nodesById,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+};
+var defaultTreeOptions = (uiLanguage) => ({
+  uiLanguage,
+  groupRootsByClass: true
+});
+var createTaxonomyResolver = (options) => {
+  const cached = (0, import_cache2.unstable_cache)(
+    async (_queryKey, query, uiLanguage, readOptions) => {
+      const items = await withServerRequestContext(
+        { skipCookieTokenLookup: true },
+        () => fetchAllPages(options.fetch, query)
+      );
+      return buildTaxonomyTree(items, {
+        ...defaultTreeOptions(uiLanguage),
+        includeOnlyUsed: readOptions.includeOnlyUsed
+      });
+    },
+    ["read-model", options.cacheKey],
+    {
+      revalidate: READMODEL_CACHE_POLICY.metadataRevalidateSeconds,
+      tags: [
+        import_requests3.CREX_API_CACHE_TAG,
+        import_requests3.CREX_READMODEL_CACHE_TAG,
+        import_requests3.CREX_READMODEL_CACHE_METADATA_TAG,
+        ...options.tags || []
+      ]
+    }
+  );
+  return async (query, readOptions) => {
+    const uiLanguage = resolveUiLanguage();
+    const normalizedQuery = { ...options.defaultQuery, ...query || {} };
+    const normalizedReadOptions = {
+      includeOnlyUsed: readOptions?.includeOnlyUsed === true
+    };
+    const cacheKey = stableSerialize({ normalizedQuery, uiLanguage, normalizedReadOptions });
+    return cached(cacheKey, normalizedQuery, uiLanguage, normalizedReadOptions);
+  };
+};
+var defaultMetadataQuery = {
+  PageNumber: 1,
+  PageSize: READMODEL_PAGE_SIZE,
+  Fields: ["labels", "class", "hasInformationUnits"],
+  Sort: ["shortId"]
+};
+var getCategoriesCached = createTaxonomyResolver({
+  cacheKey: "categories",
+  tags: [import_requests3.CREX_READMODEL_CACHE_INFORMATION_SUBJECTS_TAG],
+  defaultQuery: defaultMetadataQuery,
+  fetch: categoriesGetAllServer
+});
+var getInformationSubjectsLegacyCached = createTaxonomyResolver({
+  cacheKey: "information-subjects-legacy",
+  tags: [import_requests3.CREX_READMODEL_CACHE_INFORMATION_SUBJECTS_TAG],
+  defaultQuery: defaultMetadataQuery,
+  fetch: informationSubjectsGetAllServer
+});
+var getDocumentTypesCached = createTaxonomyResolver({
+  cacheKey: "document-types",
+  tags: [import_requests3.CREX_READMODEL_CACHE_DOCUMENT_TYPES_TAG],
+  defaultQuery: defaultMetadataQuery,
+  fetch: documentTypesGetAllServer
+});
+var getComponentsCached = createTaxonomyResolver({
+  cacheKey: "components",
+  tags: [import_requests3.CREX_READMODEL_CACHE_COMPONENTS_TAG],
+  defaultQuery: {
+    ...defaultMetadataQuery,
+    Fields: ["labels", "class", "parents", "ancestors", "ancestorsOrSelf", "hasInformationUnits"]
+  },
+  fetch: componentsGetAllServer
+});
+var getTopicTypesCached = createTaxonomyResolver({
+  cacheKey: "topic-types",
+  defaultQuery: defaultMetadataQuery,
+  fetch: topicTypesGetAllServer
+});
+var getContentLifeCycleStatusCached = createTaxonomyResolver({
+  cacheKey: "content-life-cycle-status",
+  defaultQuery: defaultMetadataQuery,
+  fetch: contentLifeCycleStatusGetAllServer
+});
+var getApplicableForTypesCached = createTaxonomyResolver({
+  cacheKey: "applicable-for-types",
+  defaultQuery: defaultMetadataQuery,
+  fetch: informationTypesGetAllServer
+});
+var getPlanningTimesCached = createTaxonomyResolver({
+  cacheKey: "planning-times",
+  defaultQuery: defaultMetadataQuery,
+  fetch: planningTimesGetAllServer
+});
+var getFunctionalMetadataCached = createTaxonomyResolver({
+  cacheKey: "functional-metadata",
+  defaultQuery: defaultMetadataQuery,
+  fetch: functionalMetadatasGetAllServer
+});
+var getProductFeaturesCached = createTaxonomyResolver({
+  cacheKey: "product-features",
+  defaultQuery: defaultMetadataQuery,
+  fetch: productFeaturesGetAllServer
+});
+var getProductLifeCyclePhasesCached = createTaxonomyResolver({
+  cacheKey: "product-life-cycle-phases",
+  defaultQuery: defaultMetadataQuery,
+  fetch: productLifeCyclePhasesGetAllServer
+});
+var getProductMetadataCached = createTaxonomyResolver({
+  cacheKey: "product-metadata",
+  defaultQuery: defaultMetadataQuery,
+  fetch: productMetadataGetAllServer
+});
+var getProductVariantsCached = createTaxonomyResolver({
+  cacheKey: "product-variants",
+  defaultQuery: defaultMetadataQuery,
+  fetch: productVariantsGetAllServer
+});
+var getQualificationsCached = createTaxonomyResolver({
+  cacheKey: "qualifications",
+  defaultQuery: defaultMetadataQuery,
+  fetch: qualificationsGetAllServer
+});
+var getSuppliesCached = createTaxonomyResolver({
+  cacheKey: "supplies",
+  defaultQuery: defaultMetadataQuery,
+  fetch: suppliesGetAllServer
+});
+var toRoleRef = (party, uiLanguage) => {
+  const role = party.partyRole;
+  const id = role?.id?.trim() || "role:unknown";
+  return {
+    id,
+    shortId: role?.shortId?.trim() || void 0,
+    label: resolveLocalizedLabel(role?.labels || [], uiLanguage) || role?.shortId?.trim() || "Unknown role"
+  };
+};
+var getPartiesCached = (0, import_cache2.unstable_cache)(
+  async (_queryKey, query, uiLanguage) => {
+    const items = await withServerRequestContext(
+      { skipCookieTokenLookup: true },
+      () => fetchAllPages(partiesGetAllServer, query)
+    );
+    const groups = /* @__PURE__ */ new Map();
+    items.forEach((party) => {
+      const id = party.id?.trim();
+      if (!id) return;
+      const role = toRoleRef(party, uiLanguage);
+      if (!groups.has(role.id)) {
+        groups.set(role.id, { role, parties: [] });
+      }
+      const label = resolveLocalizedLabel(party.labels || [], uiLanguage) || party.shortId?.trim() || id;
+      groups.get(role.id)?.parties.push({
+        id,
+        shortId: party.shortId?.trim() || void 0,
+        label,
+        role,
+        vcardId: party.vcard?.id?.trim() || void 0
+      });
+    });
+    return {
+      groups: Array.from(groups.values()).map((group) => ({
+        ...group,
+        parties: group.parties.sort((a, b) => a.label.localeCompare(b.label))
+      })).sort((a, b) => a.role.label.localeCompare(b.role.label)),
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  },
+  ["read-model", "parties"],
+  {
+    revalidate: READMODEL_CACHE_POLICY.metadataRevalidateSeconds,
+    tags: [import_requests3.CREX_API_CACHE_TAG, import_requests3.CREX_READMODEL_CACHE_TAG, import_requests3.CREX_READMODEL_CACHE_METADATA_TAG, import_requests3.CREX_READMODEL_CACHE_PARTIES_TAG]
+  }
+);
+var getInformationSubjects = async (options) => {
+  const readOptions = { includeOnlyUsed: options?.includeOnlyUsed === true };
+  try {
+    const categories = await getCategoriesCached(void 0, readOptions);
+    if (categories.roots.length > 0) {
+      return categories;
+    }
+  } catch (error) {
+    console.warn("[MetadataReadModels] Categories endpoint unavailable, falling back to InformationSubjects.", error);
+  }
+  return getInformationSubjectsLegacyCached(void 0, readOptions);
+};
+var getDocumentTypes = async () => {
+  return getDocumentTypesCached();
+};
+var getComponents = async () => {
+  return getComponentsCached();
+};
+var getParties = async () => {
+  const uiLanguage = resolveUiLanguage();
+  const query = {
+    PageNumber: 1,
+    PageSize: READMODEL_PAGE_SIZE,
+    Fields: ["labels", "partyRole", "vcard", "class"],
+    Sort: ["shortId"],
+    Embed: ["vcard"]
+  };
+  return getPartiesCached(stableSerialize({ query, uiLanguage }), query, uiLanguage);
+};
+var getTopicTypes = async (query) => {
+  return getTopicTypesCached(query);
+};
+var getContentLifeCycleStatus = async (query) => {
+  return getContentLifeCycleStatusCached(query);
+};
+var getApplicableForTypes = async (query) => {
+  return getApplicableForTypesCached(query);
+};
+var getPlanningTimes = async (query) => {
+  return getPlanningTimesCached(query);
+};
+var getFunctionalMetadata = async (query) => {
+  return getFunctionalMetadataCached(query);
+};
+var getProductFeatures = async (query) => {
+  return getProductFeaturesCached(query);
+};
+var getProductLifeCyclePhases = async (query) => {
+  return getProductLifeCyclePhasesCached(query);
+};
+var getProductMetadata = async (query) => {
+  return getProductMetadataCached(query);
+};
+var getProductVariants = async (query) => {
+  return getProductVariantsCached(query);
+};
+var getQualifications = async (query) => {
+  return getQualificationsCached(query);
+};
+var getSupplies = async (query) => {
+  return getSuppliesCached(query);
+};
+var getMetadataPropertyResolvers = () => ({
+  parties: getParties,
+  components: getComponents,
+  informationSubjects: getInformationSubjects,
+  topicTypes: getTopicTypes,
+  documentTypes: getDocumentTypes,
+  contentLifeCycleStatus: getContentLifeCycleStatus,
+  applicableForTypes: getApplicableForTypes,
+  planningTimes: getPlanningTimes,
+  functionalMetadata: getFunctionalMetadata,
+  productFeatures: getProductFeatures,
+  productLifeCyclePhases: getProductLifeCyclePhases,
+  productMetadata: getProductMetadata,
+  productVariants: getProductVariants,
+  qualifications: getQualifications,
+  supplies: getSupplies
+});
+
+// src/read-models/metadata-presentation-config.ts
+var INFORMATION_UNIT_PROPERTY_PRESENTATION = {
+  id: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  shortId: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  score: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  class: {
+    valueKind: "objectRef",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "class" }
+  },
+  labels: {
+    valueKind: "literalArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  comments: {
+    valueKind: "literalArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  descriptions: {
+    valueKind: "literalArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  synonyms: {
+    valueKind: "stringArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  packages: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  hasInformationUnits: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  links: {
+    valueKind: "resourceLinkArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  revision: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  created: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  modified: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  abstract: {
+    valueKind: "literalArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  replaces: {
+    valueKind: "objectRef",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  versionOf: {
+    valueKind: "objectRef",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  titles: {
+    valueKind: "literalArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  languages: {
+    valueKind: "stringArray",
+    facet: { supported: true, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  parties: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "partyRole" },
+    metadataDisplay: { supported: true, sectionStrategy: "partyRole" }
+  },
+  renditions: {
+    valueKind: "renditionArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  identities: {
+    valueKind: "objectRefArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  components: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  informationSubjects: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  topicTypes: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  documentTypes: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  directoryNodes: {
+    valueKind: "objectRefArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  contentLifeCycleStatus: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  applicableForTypes: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  planningTimes: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  events: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  functionalMetadata: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  informationUnits: {
+    valueKind: "objectRefArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  productFeatures: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  productLifeCyclePhases: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  productMetadata: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  productVariants: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  qualifications: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  supplies: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  }
+};
+
+// src/read-models/metadata-presentation.ts
+var import_cache3 = require("next/cache");
+var import_requests4 = require("@c-rex/core/requests");
+var addTaxonomyNodeOverride = (node, map, sectionLabel) => {
+  if (!node.shortId) return;
+  map[node.shortId] = {
+    label: node.label,
+    sectionLabel
+  };
+};
+var createClassSectionOverrides = (nodes) => {
+  const overrides = {};
+  Object.values(nodes).forEach((node) => {
+    addTaxonomyNodeOverride(node, overrides, node.classRef?.label);
+  });
+  return overrides;
+};
+var TOPIC_TYPE_DOMAIN_ENTITY_ID = "http://iirds.tekom.de/iirds#TopicType";
+var CONTENT_LIFECYCLE_STATUS_DOMAIN_ENTITY_ID = "http://iirds.tekom.de/iirds#ContentLifeCycleStatus";
+var resolveLocalizedLabel2 = (labels, uiLanguage) => {
+  if (!labels || labels.length === 0) return void 0;
+  const normalizedLanguage = uiLanguage.toLowerCase();
+  const baseLanguage = normalizedLanguage.split("-")[0];
+  const normalized = labels.map((item) => ({
+    language: (item.language || "").toLowerCase(),
+    value: item.value || ""
+  })).filter((item) => item.value.length > 0);
+  const exact = normalized.find((item) => item.language === normalizedLanguage)?.value;
+  if (exact) return exact;
+  const base = normalized.find((item) => item.language === baseLanguage)?.value;
+  if (base) return base;
+  const english = normalized.find((item) => item.language === "en" || item.language === "en-us")?.value;
+  if (english) return english;
+  return normalized[0]?.value;
+};
+var getDomainEntitySectionLabelUncached = async (id, uiLanguage) => {
+  const query = {
+    Fields: ["labels"]
+  };
+  const entity = await withServerRequestContext(
+    { skipCookieTokenLookup: true },
+    () => domainEntitiesGetByIdServer({ id }, query)
+  );
+  return resolveLocalizedLabel2(entity.labels || [], uiLanguage);
+};
+var getDomainEntitySectionLabelCached = (0, import_cache3.unstable_cache)(
+  async (id, uiLanguage) => getDomainEntitySectionLabelUncached(id, uiLanguage),
+  ["metadata-presentation-domain-entity-label"],
+  {
+    revalidate: READMODEL_CACHE_POLICY.metadataRevalidateSeconds,
+    tags: [import_requests4.CREX_API_CACHE_TAG, import_requests4.CREX_READMODEL_CACHE_TAG, import_requests4.CREX_READMODEL_CACHE_METADATA_TAG]
+  }
+);
+var inFlightDomainEntityLabelRequests = /* @__PURE__ */ new Map();
+var getDomainEntitySectionLabel = async (id, uiLanguage) => {
+  const inFlightKey = `${id}::${uiLanguage.toLowerCase()}`;
+  const existing = inFlightDomainEntityLabelRequests.get(inFlightKey);
+  if (existing) return existing;
+  const promise = getDomainEntitySectionLabelCached(id, uiLanguage).finally(() => {
+    inFlightDomainEntityLabelRequests.delete(inFlightKey);
+  });
+  inFlightDomainEntityLabelRequests.set(inFlightKey, promise);
+  return promise;
+};
+var getMetadataFacetLabelOverrides = async (properties, uiLanguage = "en-US", options) => {
+  const defaultProperties = Object.keys(INFORMATION_UNIT_PROPERTY_PRESENTATION).filter((property) => INFORMATION_UNIT_PROPERTY_PRESENTATION[property].facet.supported);
+  const propertySet = new Set(properties && properties.length > 0 ? properties : defaultProperties);
+  const result = {};
+  const classResolvers = {
+    components: getComponents,
+    informationSubjects: getInformationSubjects,
+    documentTypes: getDocumentTypes,
+    applicableForTypes: getApplicableForTypes,
+    planningTimes: getPlanningTimes,
+    functionalMetadata: getFunctionalMetadata,
+    contentLifeCycleStatus: getContentLifeCycleStatus,
+    productFeatures: getProductFeatures,
+    productLifeCyclePhases: getProductLifeCyclePhases,
+    productMetadata: getProductMetadata,
+    productVariants: getProductVariants,
+    qualifications: getQualifications,
+    supplies: getSupplies,
+    topicTypes: getTopicTypes
+  };
+  const classTasks = [];
+  let partiesTask;
+  for (const property of propertySet) {
+    const config = INFORMATION_UNIT_PROPERTY_PRESENTATION[property];
+    if (!config?.facet.supported) continue;
+    if (config.facet.sectionStrategy === "partyRole" && property === "parties") {
+      partiesTask = (async () => {
+        const parties = await getParties();
+        const partyOverrides = {};
+        parties.groups.forEach((group) => {
+          const sectionLabel = group.role.label;
+          group.parties.forEach((party) => {
+            if (!party.shortId) return;
+            partyOverrides[party.shortId] = {
+              label: party.label,
+              sectionLabel
+            };
+          });
+        });
+        result.parties = partyOverrides;
+      })();
+      continue;
+    }
+    if (config.facet.sectionStrategy === "class") {
+      const resolver = classResolvers[property];
+      if (!resolver) continue;
+      classTasks.push(
+        (async () => {
+          const taxonomy = property === "informationSubjects" && options?.includeOnlyUsedByProperty?.informationSubjects === true ? await getInformationSubjects({ includeOnlyUsed: true }) : await resolver();
+          if (property === "topicTypes" || property === "contentLifeCycleStatus") {
+            const domainEntityId = property === "topicTypes" ? TOPIC_TYPE_DOMAIN_ENTITY_ID : CONTENT_LIFECYCLE_STATUS_DOMAIN_ENTITY_ID;
+            const sectionLabel = await getDomainEntitySectionLabel(domainEntityId, uiLanguage);
+            const overrides = createClassSectionOverrides(taxonomy.nodesById);
+            if (sectionLabel) {
+              Object.values(overrides).forEach((entry) => {
+                entry.sectionLabel = sectionLabel;
+              });
+            }
+            result[property] = overrides;
+            return;
+          }
+          result[property] = createClassSectionOverrides(taxonomy.nodesById);
+        })()
+      );
+    }
+  }
+  await Promise.all([...classTasks, ...partiesTask ? [partiesTask] : []]);
+  return result;
+};
+
+// src/read-models/metadata-display.ts
+var import_utils = require("@c-rex/utils");
+var resolveLiteralLabel = (labels, uiLanguage) => {
+  if (!labels || labels.length === 0) return void 0;
+  const language = uiLanguage || "en";
+  const preferred = (0, import_utils.resolvePreferredLanguage)(
+    labels.map((item) => item.language || ""),
+    language
+  );
+  if (preferred) {
+    const exact = labels.find((item) => item.language === preferred)?.value;
+    if (exact) return exact;
+  }
+  return labels.find((item) => item.value)?.value || void 0;
+};
+var resolveObjectRefLabel = (item, uiLanguage) => {
+  return resolveLiteralLabel(item.labels || [], uiLanguage) || item.shortId || item.id || void 0;
+};
+var asObjectRefArray = (value) => {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => Boolean(item && typeof item === "object"));
+};
+var asLiteralArray = (value) => {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => Boolean(item && typeof item === "object"));
+};
+var shouldUseOverrides = (strategy) => {
+  return strategy === "class" || strategy === "partyRole";
+};
+var getMetadataDisplayRows = async (data, options) => {
+  const includeProperties = options.includeProperties || Object.keys(INFORMATION_UNIT_PROPERTY_PRESENTATION);
+  const uiLanguage = options.uiLanguage;
+  const preferredTitle = resolveLiteralLabel(data.titles || [], uiLanguage) || resolveLiteralLabel(data.labels || [], uiLanguage);
+  const objectRefProperties = includeProperties.filter((key) => {
+    const config = INFORMATION_UNIT_PROPERTY_PRESENTATION[key];
+    if (!config?.metadataDisplay?.supported) return false;
+    return config.valueKind === "objectRefArray" || config.valueKind === "objectRef";
+  });
+  const overrideProperties = objectRefProperties.filter(
+    (key) => shouldUseOverrides(INFORMATION_UNIT_PROPERTY_PRESENTATION[key].metadataDisplay.sectionStrategy)
+  );
+  const labelOverrides = options.overrides || (overrideProperties.length > 0 ? await getMetadataFacetLabelOverrides(overrideProperties, uiLanguage) : {});
+  const rows = [];
+  for (const key of includeProperties) {
+    const config = INFORMATION_UNIT_PROPERTY_PRESENTATION[key];
+    if (!config?.metadataDisplay?.supported) continue;
+    if (key === "labels") {
+      continue;
+    }
+    if (key === "titles") {
+      if (preferredTitle) {
+        rows.push({
+          key,
+          label: key,
+          labelSource: "translationKey",
+          values: [preferredTitle],
+          valueType: "text"
+        });
+      }
+      continue;
+    }
+    const value = data[key];
+    if (value === null || value === void 0) continue;
+    if (key === "languages") {
+      const languages = (0, import_utils.sortAndDeduplicateLanguages)(value || []);
+      if (languages.length > 0) {
+        rows.push({
+          key,
+          label: key,
+          labelSource: "translationKey",
+          values: languages,
+          valueType: "language"
+        });
+      }
+      continue;
+    }
+    if (config.valueKind === "scalar") {
+      rows.push({
+        key,
+        label: key,
+        labelSource: "translationKey",
+        values: [String(value)],
+        valueType: "text"
+      });
+      continue;
+    }
+    if (config.valueKind === "stringArray") {
+      const values = Array.from(new Set(value.map((item) => String(item)).filter((item) => item.length > 0)));
+      if (values.length > 0) {
+        rows.push({
+          key,
+          label: key,
+          labelSource: "translationKey",
+          values,
+          valueType: "text"
+        });
+      }
+      continue;
+    }
+    if (config.valueKind === "literalArray") {
+      const literals = asLiteralArray(value);
+      const preferred = resolveLiteralLabel(literals, uiLanguage);
+      if (preferred) {
+        rows.push({
+          key,
+          label: key,
+          labelSource: "translationKey",
+          values: [preferred],
+          valueType: "text"
+        });
+      }
+      continue;
+    }
+    if (config.valueKind === "objectRef") {
+      const ref = value;
+      const label = resolveObjectRefLabel(ref, uiLanguage);
+      if (label) {
+        rows.push({
+          key,
+          label: key,
+          labelSource: "translationKey",
+          values: [label],
+          valueType: "text"
+        });
+      }
+      continue;
+    }
+    if (config.valueKind === "objectRefArray") {
+      const refs = asObjectRefArray(value);
+      if (refs.length === 0) continue;
+      const grouped = /* @__PURE__ */ new Map();
+      const strategy = config.metadataDisplay.sectionStrategy;
+      refs.forEach((ref) => {
+        const shortId = ref.shortId || "";
+        const override = shortId ? labelOverrides[key]?.[shortId] : void 0;
+        const label = override?.label || resolveObjectRefLabel(ref, uiLanguage);
+        if (!label) return;
+        const section = strategy === "none" ? key : override?.sectionLabel || key;
+        if (!grouped.has(section)) grouped.set(section, []);
+        grouped.get(section)?.push(label);
+      });
+      Array.from(grouped.entries()).sort((a, b) => a[0].localeCompare(b[0])).forEach(([section, values]) => {
+        const uniqueValues = Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
+        if (uniqueValues.length === 0) return;
+        const isDirect = section !== key;
+        rows.push({
+          key,
+          label: section,
+          labelSource: isDirect ? "direct" : "translationKey",
+          values: uniqueValues,
+          valueType: "text"
+        });
+      });
+      continue;
+    }
+  }
+  return rows;
+};
+
+// src/read-models/version-availability.ts
+var import_requests5 = require("@c-rex/core/requests");
+var import_utils2 = require("@c-rex/utils");
+var import_cache4 = require("next/cache");
+var stableSerialize2 = (value) => {
+  const normalize = (input) => {
+    if (Array.isArray(input)) return input.map((item) => normalize(item));
+    if (input && typeof input === "object") {
+      const sorted = {};
+      Object.keys(input).sort((a, b) => a.localeCompare(b)).forEach((key) => {
+        sorted[key] = normalize(input[key]);
+      });
+      return sorted;
+    }
+    return input;
+  };
+  return JSON.stringify(normalize(value));
+};
+var normalizeVersionItems = (items, uiLanguage) => {
+  const uniqueByShortId = /* @__PURE__ */ new Map();
+  items.forEach((item) => {
+    const shortId = item.shortId?.trim();
+    if (!shortId) return;
+    const language = (0, import_utils2.resolvePreferredLanguage)(item.languages, uiLanguage);
+    if (!language) return;
+    uniqueByShortId.set(shortId, {
+      shortId,
+      language
+    });
+  });
+  return Array.from(uniqueByShortId.values()).sort((a, b) => {
+    const languageOrder = a.language.localeCompare(b.language);
+    if (languageOrder !== 0) return languageOrder;
+    return a.shortId.localeCompare(b.shortId);
+  });
+};
+var getAvailableLanguagesByVersionOfCached = (0, import_cache4.unstable_cache)(
+  async (_cacheKey, query, uiLanguage) => {
+    const result = await withServerRequestContext(
+      { skipCookieTokenLookup: true },
+      () => informationUnitsGetAllServer(query)
+    );
+    return normalizeVersionItems(result.items || [], uiLanguage);
+  },
+  ["read-model", "version-availability"],
+  {
+    revalidate: READMODEL_CACHE_POLICY.metadataRevalidateSeconds,
+    tags: [import_requests5.CREX_API_CACHE_TAG, import_requests5.CREX_READMODEL_CACHE_TAG, import_requests5.CREX_READMODEL_CACHE_METADATA_TAG]
+  }
+);
+var fetchAvailableLanguagesByVersionOfDirect = async (query, uiLanguage) => {
+  const result = await withServerRequestContext(
+    { skipCookieTokenLookup: true },
+    () => informationUnitsGetAllServer(query)
+  );
+  return normalizeVersionItems(result.items || [], uiLanguage);
+};
+var getAvailableLanguagesByVersionOf = async (versionOfShortId) => {
+  if (!versionOfShortId) return [];
+  const uiLanguage = resolveUiLanguage();
+  const query = {
+    Restrict: [`versionOf.shortId=${versionOfShortId}`],
+    Fields: ["shortId", "languages", "labels", "versionOf"],
+    PageNumber: 1,
+    PageSize: 200,
+    Sort: ["languages"]
+  };
+  const cacheKey = stableSerialize2({ versionOfShortId, uiLanguage, query });
+  if (process.env.NODE_ENV === "test") {
+    return fetchAvailableLanguagesByVersionOfDirect(query, uiLanguage);
+  }
+  return getAvailableLanguagesByVersionOfCached(cacheKey, query, uiLanguage);
+};
+
+// src/read-models/metadata-view-profile.ts
+var ALL_PROPERTIES = Object.keys(INFORMATION_UNIT_PROPERTY_PRESENTATION);
+var DEFAULT_FACET_PROPERTIES = ALL_PROPERTIES.filter((key) => {
+  const config = INFORMATION_UNIT_PROPERTY_PRESENTATION[key];
+  return config.facet.supported && config.valueKind === "objectRefArray";
+});
+var DEFAULT_METADATA_DISPLAY_PROPERTIES = ALL_PROPERTIES.filter((key) => {
+  const config = INFORMATION_UNIT_PROPERTY_PRESENTATION[key];
+  return config.metadataDisplay.supported;
+});
+var toSet = (values) => new Set(values || []);
+var applyIncludeExclude = (base, include, exclude) => {
+  const includeSet = toSet(include);
+  const excludeSet = toSet(exclude);
+  const source = includeSet.size > 0 ? base.filter((item) => includeSet.has(item)) : base;
+  return source.filter((item) => !excludeSet.has(item));
+};
+var METADATA_VIEW_PROFILES = {
+  "default-search": {
+    id: "default-search",
+    facet: {
+      includeProperties: DEFAULT_FACET_PROPERTIES,
+      extraTags: ["rdfType"],
+      includeZeroHits: true
+    }
+  },
+  "information-unit-search": {
+    id: "information-unit-search",
+    facet: {
+      includeProperties: DEFAULT_FACET_PROPERTIES.filter((property) => property !== "informationSubjects"),
+      extraTags: ["rdfType"],
+      includeZeroHits: true
+    }
+  },
+  "default-metadata-display": {
+    id: "default-metadata-display",
+    metadataDisplay: {
+      includeProperties: DEFAULT_METADATA_DISPLAY_PROPERTIES
+    }
+  }
+};
+var toInformationUnitPropertyKeys = (values) => {
+  const available = new Set(ALL_PROPERTIES);
+  return (values || []).filter((value) => available.has(value));
+};
+var resolveFacetTags = (options) => {
+  const profile = METADATA_VIEW_PROFILES[options?.profileId || "default-search"];
+  const facetConfig = profile.facet;
+  const supported = DEFAULT_FACET_PROPERTIES;
+  const profileScoped = applyIncludeExclude(
+    supported,
+    facetConfig?.includeProperties,
+    facetConfig?.excludeProperties
+  );
+  const runtimeScoped = applyIncludeExclude(
+    profileScoped,
+    toInformationUnitPropertyKeys(options?.includeProperties),
+    toInformationUnitPropertyKeys(options?.excludeProperties)
+  );
+  const tagSet = new Set(runtimeScoped);
+  (facetConfig?.extraTags || []).forEach((tag) => tagSet.add(tag));
+  (options?.extraTags || []).forEach((tag) => tagSet.add(tag));
+  return Array.from(tagSet);
+};
+var resolveMetadataDisplayProperties = (options) => {
+  const profile = METADATA_VIEW_PROFILES[options?.profileId || "default-metadata-display"];
+  const displayConfig = profile.metadataDisplay;
+  const supported = DEFAULT_METADATA_DISPLAY_PROPERTIES;
+  const profileScoped = applyIncludeExclude(
+    supported,
+    displayConfig?.includeProperties,
+    displayConfig?.excludeProperties
+  );
+  return applyIncludeExclude(
+    profileScoped,
+    toInformationUnitPropertyKeys(options?.includeProperties),
+    toInformationUnitPropertyKeys(options?.excludeProperties)
+  );
+};
+
+// src/index.ts
+var extractId = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  return value.id;
+};
+var pickHtmlRenditionPath = (renditions) => {
+  if (!Array.isArray(renditions) || renditions.length === 0) {
+    return null;
+  }
+  const htmlRendition = renditions.find((r) => String(r.contentType ?? r.mimeType ?? r.mediaType ?? "").toLowerCase().includes("html")) ?? renditions[0];
+  return htmlRendition?.binaryPath ?? htmlRendition?.path ?? htmlRendition?.renditionUrl ?? null;
+};
+var TopicsService = class {
+  async getList(query) {
+    return topicsGetAllServer(query);
+  }
+};
+var DocumentTypesService = class {
+  async getList(query) {
+    return documentTypesGetAllServer(query);
+  }
+  async getLabels() {
+    const result = await documentTypesGetAllServer();
+    const entries = result?.items ?? [];
+    return entries.map((item) => {
+      const firstLabel = item?.labels?.[0]?.label ?? item?.labels?.[0]?.value ?? item?.shortId ?? "";
+      return {
+        shortId: String(item?.shortId ?? ""),
+        label: String(firstLabel)
+      };
+    }).filter((item) => item.shortId.length > 0 && item.label.length > 0);
+  }
+};
+var InformationUnitsService = class {
+  async getList(query) {
+    return informationUnitsGetAllServer(query);
+  }
+  async getItem(params) {
+    return informationUnitsGetByIdServer(params);
+  }
+};
+var DirectoryNodesService = class {
+  async getItem(id) {
+    return directoryNodesGetByIdServer({ id: extractId(id) });
+  }
+};
+var RenditionsService = class {
+  async getHTMLRendition(params) {
+    const binaryPath = pickHtmlRenditionPath(params.renditions);
+    if (!binaryPath) {
+      return "";
+    }
+    const result = await renditionsGetWithBinaryWithBinaryPathServer({ id: "", binaryPath });
+    return String(result?.content ?? result?.html ?? "");
+  }
+};
+var LanguageService = class {
+  async getList(query) {
+    return informationUnitsLanguagesServer(query);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_LOGO_SRC,
+  DirectoryNodesService,
+  DocumentTypesService,
+  INFORMATION_UNIT_PROPERTY_PRESENTATION,
+  InformationUnitsService,
+  LanguageService,
+  METADATA_VIEW_PROFILES,
+  READMODEL_CACHE_POLICY,
+  RenditionsService,
+  TopicsService,
+  administrativeMetadataGetAllClientService,
+  administrativeMetadataGetAllServer,
+  administrativeMetadataGetByIdClientService,
+  administrativeMetadataGetByIdServer,
+  afterUsesGetAllClientService,
+  afterUsesGetAllServer,
+  afterUsesGetByIdClientService,
+  afterUsesGetByIdServer,
+  buildTelephoneEntries,
+  categoriesGetAllClientService,
+  categoriesGetAllServer,
+  categoriesGetByIdClientService,
+  categoriesGetByIdServer,
+  collectionsGetAllClientService,
+  collectionsGetAllServer,
+  collectionsGetByIdClientService,
+  collectionsGetByIdServer,
+  componentsGetAllClientService,
+  componentsGetAllServer,
+  componentsGetByIdClientService,
+  componentsGetByIdServer,
+  conceptsGetAllClientService,
+  conceptsGetAllServer,
+  conceptsGetByIdClientService,
+  conceptsGetByIdServer,
+  conformitiesGetAllClientService,
+  conformitiesGetAllServer,
+  conformitiesGetByIdClientService,
+  conformitiesGetByIdServer,
+  consumablesGetAllClientService,
+  consumablesGetAllServer,
+  consumablesGetByIdClientService,
+  consumablesGetByIdServer,
+  contentLifeCycleStatusGetAllClientService,
+  contentLifeCycleStatusGetAllServer,
+  contentLifeCycleStatusGetByIdClientService,
+  contentLifeCycleStatusGetByIdServer,
+  decodeEncodedVcardId,
+  designAndRealizationsGetAllClientService,
+  designAndRealizationsGetAllServer,
+  designAndRealizationsGetByIdClientService,
+  designAndRealizationsGetByIdServer,
+  directoryNodeTypesGetAllClientService,
+  directoryNodeTypesGetAllServer,
+  directoryNodeTypesGetByIdClientService,
+  directoryNodeTypesGetByIdServer,
+  directoryNodesGetAllClientService,
+  directoryNodesGetAllServer,
+  directoryNodesGetByIdClientService,
+  directoryNodesGetByIdServer,
+  documentTypesGetAllClientService,
+  documentTypesGetAllServer,
+  documentTypesGetByIdClientService,
+  documentTypesGetByIdServer,
+  documentationMetadataGetAllClientService,
+  documentationMetadataGetAllServer,
+  documentationMetadataGetByIdClientService,
+  documentationMetadataGetByIdServer,
+  documentsGetAllClientService,
+  documentsGetAllServer,
+  documentsGetByIdClientService,
+  documentsGetByIdServer,
+  documentsLanguagesClientService,
+  documentsLanguagesServer,
+  domainEntitiesGetAllClientService,
+  domainEntitiesGetAllServer,
+  domainEntitiesGetByIdClientService,
+  domainEntitiesGetByIdServer,
+  downTimesGetAllClientService,
+  downTimesGetAllServer,
+  downTimesGetByIdClientService,
+  downTimesGetByIdServer,
+  eventsGetAllClientService,
+  eventsGetAllServer,
+  eventsGetByIdClientService,
+  eventsGetByIdServer,
+  formalitiesGetAllClientService,
+  formalitiesGetAllServer,
+  formalitiesGetByIdClientService,
+  formalitiesGetByIdServer,
+  formsGetAllClientService,
+  formsGetAllServer,
+  formsGetByIdClientService,
+  formsGetByIdServer,
+  fragmentsGetAllClientService,
+  fragmentsGetAllServer,
+  fragmentsGetByIdClientService,
+  fragmentsGetByIdServer,
+  fragmentsLanguagesClientService,
+  fragmentsLanguagesServer,
+  functionalMetadatasGetAllClientService,
+  functionalMetadatasGetAllServer,
+  functionalMetadatasGetByIdClientService,
+  functionalMetadatasGetByIdServer,
+  functionalitiesGetAllClientService,
+  functionalitiesGetAllServer,
+  functionalitiesGetByIdClientService,
+  functionalitiesGetByIdServer,
+  getApplicableForTypes,
+  getAvailableLanguagesByVersionOf,
+  getComponents,
+  getContentLifeCycleStatus,
+  getDocumentTypes,
+  getFunctionalMetadata,
+  getIndividualProfileById,
+  getIndividualsProfiles,
+  getInformationSubjects,
+  getMetadataDisplayRows,
+  getMetadataFacetLabelOverrides,
+  getMetadataPropertyResolvers,
+  getOrganizationBranding,
+  getOrganizationProfile,
+  getOrganizationProfileById,
+  getOrganizationsProfiles,
+  getParties,
+  getPlanningTimes,
+  getProductFeatures,
+  getProductLifeCyclePhases,
+  getProductMetadata,
+  getProductVariants,
+  getQualifications,
+  getServerConfig,
+  getSupplies,
+  getTopicTypes,
+  getVCardProfileById,
+  getVCardProfiles,
+  groupsGetAllClientService,
+  groupsGetAllServer,
+  groupsGetByIdClientService,
+  groupsGetByIdServer,
+  hardwareToolsGetAllClientService,
+  hardwareToolsGetAllServer,
+  hardwareToolsGetByIdClientService,
+  hardwareToolsGetByIdServer,
+  identitiesGetAllClientService,
+  identitiesGetAllServer,
+  identitiesGetByIdClientService,
+  identitiesGetByIdServer,
+  identityDomainsGetAllClientService,
+  identityDomainsGetAllServer,
+  identityDomainsGetByIdClientService,
+  identityDomainsGetByIdServer,
+  individualsGetAllClientService,
+  individualsGetAllServer,
+  individualsGetByIdClientService,
+  individualsGetByIdServer,
+  informationObjectsGetAllClientService,
+  informationObjectsGetAllServer,
+  informationObjectsGetByIdClientService,
+  informationObjectsGetByIdServer,
+  informationSubjectsGetAllClientService,
+  informationSubjectsGetAllServer,
+  informationSubjectsGetByIdClientService,
+  informationSubjectsGetByIdServer,
+  informationTypesGetAllClientService,
+  informationTypesGetAllServer,
+  informationTypesGetByIdClientService,
+  informationTypesGetByIdServer,
+  informationUnitsGetAllClientService,
+  informationUnitsGetAllServer,
+  informationUnitsGetByIdClientService,
+  informationUnitsGetByIdServer,
+  informationUnitsLanguagesClientService,
+  informationUnitsLanguagesServer,
+  learningsGetAllClientService,
+  learningsGetAllServer,
+  learningsGetByIdClientService,
+  learningsGetByIdServer,
+  locationsGetAllClientService,
+  locationsGetAllServer,
+  locationsGetByIdClientService,
+  locationsGetByIdServer,
+  lubricantsGetAllClientService,
+  lubricantsGetAllServer,
+  lubricantsGetByIdClientService,
+  lubricantsGetByIdServer,
+  maintenanceIntervalsGetAllClientService,
+  maintenanceIntervalsGetAllServer,
+  maintenanceIntervalsGetByIdClientService,
+  maintenanceIntervalsGetByIdServer,
+  mapVCardEntityToBaseProfile,
+  normalizeEmail,
+  normalizeHref,
+  operatingSuppliesGetAllClientService,
+  operatingSuppliesGetAllServer,
+  operatingSuppliesGetByIdClientService,
+  operatingSuppliesGetByIdServer,
+  organizationsGetAllClientService,
+  organizationsGetAllServer,
+  organizationsGetByIdClientService,
+  organizationsGetByIdServer,
+  packagesCreateClientAppClientService,
+  packagesCreateClientAppServer,
+  packagesGetAllClientService,
+  packagesGetAllServer,
+  packagesGetByIdClientService,
+  packagesGetByIdServer,
+  packagesLanguagesClientService,
+  packagesLanguagesServer,
+  partiesGetAllClientService,
+  partiesGetAllServer,
+  partiesGetByIdClientService,
+  partiesGetByIdServer,
+  planningTimesGetAllClientService,
+  planningTimesGetAllServer,
+  planningTimesGetByIdClientService,
+  planningTimesGetByIdServer,
+  processesGetAllClientService,
+  processesGetAllServer,
+  processesGetByIdClientService,
+  processesGetByIdServer,
+  productFeaturesGetAllClientService,
+  productFeaturesGetAllServer,
+  productFeaturesGetByIdClientService,
+  productFeaturesGetByIdServer,
+  productFunctionsGetAllClientService,
+  productFunctionsGetAllServer,
+  productFunctionsGetByIdClientService,
+  productFunctionsGetByIdServer,
+  productLifeCyclePhasesGetAllClientService,
+  productLifeCyclePhasesGetAllServer,
+  productLifeCyclePhasesGetByIdClientService,
+  productLifeCyclePhasesGetByIdServer,
+  productMetadataGetAllClientService,
+  productMetadataGetAllServer,
+  productMetadataGetByIdClientService,
+  productMetadataGetByIdServer,
+  productPropertiesGetAllClientService,
+  productPropertiesGetAllServer,
+  productPropertiesGetByIdClientService,
+  productPropertiesGetByIdServer,
+  productVariantsGetAllClientService,
+  productVariantsGetAllServer,
+  productVariantsGetByIdClientService,
+  productVariantsGetByIdServer,
+  puttingToUsesGetAllClientService,
+  puttingToUsesGetAllServer,
+  puttingToUsesGetByIdClientService,
+  puttingToUsesGetByIdServer,
+  qualificationsGetAllClientService,
+  qualificationsGetAllServer,
+  qualificationsGetByIdClientService,
+  qualificationsGetByIdServer,
+  referencesGetAllClientService,
+  referencesGetAllServer,
+  referencesGetByIdClientService,
+  referencesGetByIdServer,
+  renditionsGetAllClientService,
+  renditionsGetAllServer,
+  renditionsGetByIdClientService,
+  renditionsGetByIdServer,
+  renditionsGetWithBinaryWithBinaryPathClientService,
+  renditionsGetWithBinaryWithBinaryPathServer,
+  resolveFacetTags,
+  resolveLogoSource,
+  resolveMetadataDisplayProperties,
+  resolveSocialProviderLabel,
+  resolveTypedSocialLinks,
+  resolveUiLanguage,
+  resourcesDownloadResourceClientService,
+  resourcesDownloadResourceServer,
+  resourcesDownloadResourceWithBinaryPathClientService,
+  resourcesDownloadResourceWithBinaryPathServer,
+  resourcesGetPackageClientService,
+  resourcesGetPackageServer,
+  resourcesGetSubjectFromPackageClientService,
+  resourcesGetSubjectFromPackageServer,
+  resourcesViewResourceClientService,
+  resourcesViewResourceServer,
+  resourcesViewResourceWithBinaryPathClientService,
+  resourcesViewResourceWithBinaryPathServer,
+  rolesGetAllClientService,
+  rolesGetAllServer,
+  rolesGetByIdClientService,
+  rolesGetByIdServer,
+  safetiesGetAllClientService,
+  safetiesGetAllServer,
+  safetiesGetByIdClientService,
+  safetiesGetByIdServer,
+  searchGetAllClientService,
+  searchGetAllServer,
+  setupTimesGetAllClientService,
+  setupTimesGetAllServer,
+  setupTimesGetByIdClientService,
+  setupTimesGetByIdServer,
+  skillLevelsGetAllClientService,
+  skillLevelsGetAllServer,
+  skillLevelsGetByIdClientService,
+  skillLevelsGetByIdServer,
+  sparQLExecuteSparQlClientService,
+  sparQLExecuteSparQlServer,
+  sparePartsGetAllClientService,
+  sparePartsGetAllServer,
+  sparePartsGetByIdClientService,
+  sparePartsGetByIdServer,
+  suppliesGetAllClientService,
+  suppliesGetAllServer,
+  suppliesGetByIdClientService,
+  suppliesGetByIdServer,
+  tasksGetAllClientService,
+  tasksGetAllServer,
+  tasksGetByIdClientService,
+  tasksGetByIdServer,
+  technicalDataGetAllClientService,
+  technicalDataGetAllServer,
+  technicalDataGetByIdClientService,
+  technicalDataGetByIdServer,
+  technicalOverviewsGetAllClientService,
+  technicalOverviewsGetAllServer,
+  technicalOverviewsGetByIdClientService,
+  technicalOverviewsGetByIdServer,
+  topicTypesGetAllClientService,
+  topicTypesGetAllServer,
+  topicTypesGetByIdClientService,
+  topicTypesGetByIdServer,
+  topicsGetAllClientService,
+  topicsGetAllServer,
+  topicsGetByIdClientService,
+  topicsGetByIdServer,
+  topicsLanguagesClientService,
+  topicsLanguagesServer,
+  troubleShootingsGetAllClientService,
+  troubleShootingsGetAllServer,
+  troubleShootingsGetByIdClientService,
+  troubleShootingsGetByIdServer,
+  usesGetAllClientService,
+  usesGetAllServer,
+  usesGetByIdClientService,
+  usesGetByIdServer,
+  vCardsGetAllClientService,
+  vCardsGetAllServer,
+  vCardsGetByIdClientService,
+  vCardsGetByIdServer,
+  warningMessagesGetAllClientService,
+  warningMessagesGetAllServer,
+  warningMessagesGetByIdClientService,
+  warningMessagesGetByIdServer,
+  workingTimesGetAllClientService,
+  workingTimesGetAllServer,
+  workingTimesGetByIdClientService,
+  workingTimesGetByIdServer
+});
+//# sourceMappingURL=index.js.map