@manta-eu/ldo 0.1.0

package/dist/namespaces.d.ts

@@ -0,0 +1,368 @@
+export * from "./.ldkit/namespaces.js";
+export declare const google: {
+    CustomerClient: "google:CustomerClient";
+    status: "google:status";
+    callToAction: "google:callToAction";
+    text: "google:text";
+    Recommendation: "google:Recommendation";
+    currencyCode: "google:currencyCode";
+    AdGroup: "google:AdGroup";
+    AdGroupAd: "google:AdGroupAd";
+    AdGroupCriterion: "google:AdGroupCriterion";
+    Asset: "google:Asset";
+    AssetGroup: "google:AssetGroup";
+    AssetGroupAsset: "google:AssetGroupAsset";
+    BudgetOption: "google:BudgetOption";
+    Campaign: "google:Campaign";
+    CampaignAsset: "google:CampaignAsset";
+    CampaignBudget: "google:CampaignBudget";
+    CampaignCriterion: "google:CampaignCriterion";
+    CampaignInsight: "google:CampaignInsight";
+    Customer: "google:Customer";
+    CustomerAsset: "google:CustomerAsset";
+    CustomerClientSetting: "google:CustomerClientSetting";
+    Description: "google:Description";
+    Descriptions: "google:Descriptions";
+    GeoTargetConstant: "google:GeoTargetConstant";
+    Headline: "google:Headline";
+    Headlines: "google:Headlines";
+    HotelBidModifier: "google:HotelBidModifier";
+    HotelGroupInsight: "google:HotelGroupInsight";
+    HotelListingGroup: "google:HotelListingGroup";
+    HotelPerformanceInsight: "google:HotelPerformanceInsight";
+    HotelReconciliation: "google:HotelReconciliation";
+    MediaFile: "google:MediaFile";
+    ResponsiveSearchAdDescription: "google:ResponsiveSearchAdDescription";
+    ResponsiveSearchAdDescriptions: "google:ResponsiveSearchAdDescriptions";
+    ResponsiveSearchAdHeadline: "google:ResponsiveSearchAdHeadline";
+    ResponsiveSearchAdHeadlines: "google:ResponsiveSearchAdHeadlines";
+    SearchTerm: "google:SearchTerm";
+    SearchTermInsight: "google:SearchTermInsight";
+    SearchTerms: "google:SearchTerms";
+    TargetRestriction: "google:TargetRestriction";
+    TargetRestrictions: "google:TargetRestrictions";
+    adGroup: "google:adGroup";
+    adGroupAdAdFinalUrls: "google:adGroupAdAdFinalUrls";
+    adGroupAdAdResourceName: "google:adGroupAdAdResourceName";
+    adGroupAdAdResponsiveSearchAdDescriptions: "google:adGroupAdAdResponsiveSearchAdDescriptions";
+    adGroupAdAdResponsiveSearchAdHeadlines: "google:adGroupAdAdResponsiveSearchAdHeadlines";
+    adGroupAdAdTypex: "google:adGroupAdAdTypex";
+    adGroupAdPolicySummaryApprovalStatus: "google:adGroupAdPolicySummaryApprovalStatus";
+    adGroupAdPolicySummaryReviewStatus: "google:adGroupAdPolicySummaryReviewStatus";
+    adGroupAdResourceName: "google:adGroupAdResourceName";
+    adGroupAdStatus: "google:adGroupAdStatus";
+    adGroupBidModifierBidModifier: "google:adGroupBidModifierBidModifier";
+    adGroupBidModifierBidModifierSource: "google:adGroupBidModifierBidModifierSource";
+    adGroupBidModifierDeviceType: "google:adGroupBidModifierDeviceType";
+    adGroupBidModifierHotelAdvanceBookingWindowMaxDays: "google:adGroupBidModifierHotelAdvanceBookingWindowMaxDays";
+    adGroupBidModifierHotelAdvanceBookingWindowMinDays: "google:adGroupBidModifierHotelAdvanceBookingWindowMinDays";
+    adGroupBidModifierHotelCheckInDateRangeEndDate: "google:adGroupBidModifierHotelCheckInDateRangeEndDate";
+    adGroupBidModifierHotelCheckInDateRangeStartDate: "google:adGroupBidModifierHotelCheckInDateRangeStartDate";
+    adGroupBidModifierHotelCheckInDayDayOfWeek: "google:adGroupBidModifierHotelCheckInDayDayOfWeek";
+    adGroupBidModifierHotelDateSelectionType: "google:adGroupBidModifierHotelDateSelectionType";
+    adGroupBidModifierHotelLengthOfStayMaxNights: "google:adGroupBidModifierHotelLengthOfStayMaxNights";
+    adGroupBidModifierHotelLengthOfStayMinNights: "google:adGroupBidModifierHotelLengthOfStayMinNights";
+    adGroupBidModifierResourceName: "google:adGroupBidModifierResourceName";
+    adGroupCampaign: "google:adGroupCampaign";
+    adGroupCpcBidMicros: "google:adGroupCpcBidMicros";
+    adGroupCpmBidMicros: "google:adGroupCpmBidMicros";
+    adGroupCpvBidMicros: "google:adGroupCpvBidMicros";
+    adGroupCriterionCpcBidMicros: "google:adGroupCriterionCpcBidMicros";
+    adGroupCriterionEffectivePercentCpcBidMicros: "google:adGroupCriterionEffectivePercentCpcBidMicros";
+    adGroupCriterionKeywordMatchType: "google:adGroupCriterionKeywordMatchType";
+    adGroupCriterionKeywordText: "google:adGroupCriterionKeywordText";
+    adGroupCriterionNegative: "google:adGroupCriterionNegative";
+    adGroupCriterionPercentCpcBidMicros: "google:adGroupCriterionPercentCpcBidMicros";
+    adGroupCriterionQualityInfoCreativeQualityScore: "google:adGroupCriterionQualityInfoCreativeQualityScore";
+    adGroupCriterionQualityInfoPostClickQualityScore: "google:adGroupCriterionQualityInfoPostClickQualityScore";
+    adGroupCriterionQualityInfoQualityScore: "google:adGroupCriterionQualityInfoQualityScore";
+    adGroupCriterionQualityInfoSearchPredictedCtr: "google:adGroupCriterionQualityInfoSearchPredictedCtr";
+    adGroupCriterionResourceName: "google:adGroupCriterionResourceName";
+    adGroupCriterionStatus: "google:adGroupCriterionStatus";
+    adGroupCriterionTypex: "google:adGroupCriterionTypex";
+    adGroupName: "google:adGroupName";
+    adGroupResourceName: "google:adGroupResourceName";
+    adGroupStatus: "google:adGroupStatus";
+    adGroupTargetCpaMicros: "google:adGroupTargetCpaMicros";
+    adGroupTargetCpmMicros: "google:adGroupTargetCpmMicros";
+    adGroupTargetingSettingTargetRestrictions: "google:adGroupTargetingSettingTargetRestrictions";
+    adGroupTypex: "google:adGroupTypex";
+    asset: "google:asset";
+    assetCalloutAssetCalloutText: "google:assetCalloutAssetCalloutText";
+    assetCalloutAssetEndDate: "google:assetCalloutAssetEndDate";
+    assetCalloutAssetStartDate: "google:assetCalloutAssetStartDate";
+    assetGroup: "google:assetGroup";
+    assetGroupAssetFieldType: "google:assetGroupAssetFieldType";
+    assetGroupAssetPolicySummaryApprovalStatus: "google:assetGroupAssetPolicySummaryApprovalStatus";
+    assetGroupAssetPolicySummaryReviewStatus: "google:assetGroupAssetPolicySummaryReviewStatus";
+    assetGroupAssetPrimaryStatus: "google:assetGroupAssetPrimaryStatus";
+    assetGroupAssetResourceName: "google:assetGroupAssetResourceName";
+    assetGroupAssetSource: "google:assetGroupAssetSource";
+    assetName: "google:assetName";
+    assetPerformanceLabel: "google:assetPerformanceLabel";
+    assetPolicySummaryApprovalStatus: "google:assetPolicySummaryApprovalStatus";
+    assetPolicySummaryReviewStatus: "google:assetPolicySummaryReviewStatus";
+    assetResourceName: "google:assetResourceName";
+    assetSitelinkAssetDescription1: "google:assetSitelinkAssetDescription1";
+    assetSitelinkAssetDescription2: "google:assetSitelinkAssetDescription2";
+    assetSitelinkAssetEndDate: "google:assetSitelinkAssetEndDate";
+    assetSitelinkAssetLinkText: "google:assetSitelinkAssetLinkText";
+    assetSitelinkAssetStartDate: "google:assetSitelinkAssetStartDate";
+    assetTypex: "google:assetTypex";
+    bidOnly: "google:bidOnly";
+    budgetAmountMicros: "google:budgetAmountMicros";
+    campaign: "google:campaign";
+    campaignAccessibleBiddingStrategy: "google:campaignAccessibleBiddingStrategy";
+    campaignAdvertisingChannelSubType: "google:campaignAdvertisingChannelSubType";
+    campaignAdvertisingChannelType: "google:campaignAdvertisingChannelType";
+    campaignAssetFieldType: "google:campaignAssetFieldType";
+    campaignAssetPrimaryStatus: "google:campaignAssetPrimaryStatus";
+    campaignAssetResourceName: "google:campaignAssetResourceName";
+    campaignAssetSource: "google:campaignAssetSource";
+    campaignAssetStatus: "google:campaignAssetStatus";
+    campaignBiddingStrategy: "google:campaignBiddingStrategy";
+    campaignBiddingStrategySystemStatus: "google:campaignBiddingStrategySystemStatus";
+    campaignBiddingStrategyType: "google:campaignBiddingStrategyType";
+    campaignBudget: "google:campaignBudget";
+    campaignBudgetAlignedBiddingStrategy: "google:campaignBudgetAlignedBiddingStrategy";
+    campaignBudgetAmountMicros: "google:campaignBudgetAmountMicros";
+    campaignBudgetDeliveryMethod: "google:campaignBudgetDeliveryMethod";
+    campaignBudgetExplicitlyShared: "google:campaignBudgetExplicitlyShared";
+    campaignBudgetHasRecommendedBudget: "google:campaignBudgetHasRecommendedBudget";
+    campaignBudgetName: "google:campaignBudgetName";
+    campaignBudgetPeriod: "google:campaignBudgetPeriod";
+    campaignBudgetRecommendedBudgetAmountMicros: "google:campaignBudgetRecommendedBudgetAmountMicros";
+    campaignBudgetRecommendedBudgetEstimatedChangeWeeklyClicks: "google:campaignBudgetRecommendedBudgetEstimatedChangeWeeklyClicks";
+    campaignBudgetRecommendedBudgetEstimatedChangeWeeklyCostMicros: "google:campaignBudgetRecommendedBudgetEstimatedChangeWeeklyCostMicros";
+    campaignBudgetRecommendedBudgetEstimatedChangeWeeklyInteractions: "google:campaignBudgetRecommendedBudgetEstimatedChangeWeeklyInteractions";
+    campaignBudgetReferenceCount: "google:campaignBudgetReferenceCount";
+    campaignBudgetResourceName: "google:campaignBudgetResourceName";
+    campaignBudgetStatus: "google:campaignBudgetStatus";
+    campaignBudgetTotalAmountMicros: "google:campaignBudgetTotalAmountMicros";
+    campaignBudgetTypex: "google:campaignBudgetTypex";
+    campaignCommissionCommissionRateMicros: "google:campaignCommissionCommissionRateMicros";
+    campaignContainsEuPoliticalAdvertising: "google:campaignContainsEuPoliticalAdvertising";
+    campaignCriterionCampaign: "google:campaignCriterionCampaign";
+    campaignCriterionDisplayName: "google:campaignCriterionDisplayName";
+    campaignCriterionKeywordMatchType: "google:campaignCriterionKeywordMatchType";
+    campaignCriterionKeywordText: "google:campaignCriterionKeywordText";
+    campaignCriterionLanguageLanguageConstant: "google:campaignCriterionLanguageLanguageConstant";
+    campaignCriterionLocationGeoTargetConstant: "google:campaignCriterionLocationGeoTargetConstant";
+    campaignCriterionLocationGroupEnableCustomerLevelLocationAssetSet: "google:campaignCriterionLocationGroupEnableCustomerLevelLocationAssetSet";
+    campaignCriterionLocationGroupFeedItemSets: "google:campaignCriterionLocationGroupFeedItemSets";
+    campaignCriterionLocationGroupGeoTargetConstants: "google:campaignCriterionLocationGroupGeoTargetConstants";
+    campaignCriterionLocationGroupLocationGroupAssetSets: "google:campaignCriterionLocationGroupLocationGroupAssetSets";
+    campaignCriterionLocationGroupRadius: "google:campaignCriterionLocationGroupRadius";
+    campaignCriterionLocationGroupRadiusUnits: "google:campaignCriterionLocationGroupRadiusUnits";
+    campaignCriterionNegative: "google:campaignCriterionNegative";
+    campaignCriterionProximityAddressCityName: "google:campaignCriterionProximityAddressCityName";
+    campaignCriterionProximityAddressCountryCode: "google:campaignCriterionProximityAddressCountryCode";
+    campaignCriterionProximityAddressPostalCode: "google:campaignCriterionProximityAddressPostalCode";
+    campaignCriterionProximityAddressProvinceCode: "google:campaignCriterionProximityAddressProvinceCode";
+    campaignCriterionProximityAddressProvinceName: "google:campaignCriterionProximityAddressProvinceName";
+    campaignCriterionProximityAddressStreetAddress: "google:campaignCriterionProximityAddressStreetAddress";
+    campaignCriterionProximityGeoPointLatitudeInMicroDegrees: "google:campaignCriterionProximityGeoPointLatitudeInMicroDegrees";
+    campaignCriterionProximityGeoPointLongitudeInMicroDegrees: "google:campaignCriterionProximityGeoPointLongitudeInMicroDegrees";
+    campaignCriterionProximityRadius: "google:campaignCriterionProximityRadius";
+    campaignCriterionProximityRadiusUnits: "google:campaignCriterionProximityRadiusUnits";
+    campaignCriterionResourceName: "google:campaignCriterionResourceName";
+    campaignCriterionStatus: "google:campaignCriterionStatus";
+    campaignCriterionTypex: "google:campaignCriterionTypex";
+    campaignEndDate: "google:campaignEndDate";
+    campaignFixedCpmGoal: "google:campaignFixedCpmGoal";
+    campaignFixedCpmTargetFrequencyInfoTargetCount: "google:campaignFixedCpmTargetFrequencyInfoTargetCount";
+    campaignFixedCpmTargetFrequencyInfoTimeUnit: "google:campaignFixedCpmTargetFrequencyInfoTimeUnit";
+    campaignGeoTargetTypeSettingNegativeGeoTargetType: "google:campaignGeoTargetTypeSettingNegativeGeoTargetType";
+    campaignGeoTargetTypeSettingPositiveGeoTargetType: "google:campaignGeoTargetTypeSettingPositiveGeoTargetType";
+    campaignManualCpcEnhancedCpcEnabled: "google:campaignManualCpcEnhancedCpcEnabled";
+    campaignMaximizeConversionValueTargetRoas: "google:campaignMaximizeConversionValueTargetRoas";
+    campaignMaximizeConversionValueTargetRoasTolerancePercentMillis: "google:campaignMaximizeConversionValueTargetRoasTolerancePercentMillis";
+    campaignMaximizeConversionsTargetCpaMicros: "google:campaignMaximizeConversionsTargetCpaMicros";
+    campaignName: "google:campaignName";
+    campaignNetworkSettingsTargetContentNetwork: "google:campaignNetworkSettingsTargetContentNetwork";
+    campaignNetworkSettingsTargetGoogleSearch: "google:campaignNetworkSettingsTargetGoogleSearch";
+    campaignNetworkSettingsTargetPartnerSearchNetwork: "google:campaignNetworkSettingsTargetPartnerSearchNetwork";
+    campaignNetworkSettingsTargetSearchNetwork: "google:campaignNetworkSettingsTargetSearchNetwork";
+    campaignOptimizationGoalSettingOptimizationGoalTypes: "google:campaignOptimizationGoalSettingOptimizationGoalTypes";
+    campaignOptimizationScore: "google:campaignOptimizationScore";
+    campaignPaymentMode: "google:campaignPaymentMode";
+    campaignPercentCpcCpcBidCeilingMicros: "google:campaignPercentCpcCpcBidCeilingMicros";
+    campaignPercentCpcEnhancedCpcEnabled: "google:campaignPercentCpcEnhancedCpcEnabled";
+    campaignPrimaryStatus: "google:campaignPrimaryStatus";
+    campaignPrimaryStatusReasons: "google:campaignPrimaryStatusReasons";
+    campaignResourceName: "google:campaignResourceName";
+    campaignSelectiveOptimizationConversionActions: "google:campaignSelectiveOptimizationConversionActions";
+    campaignServingStatus: "google:campaignServingStatus";
+    campaignStartDate: "google:campaignStartDate";
+    campaignStatus: "google:campaignStatus";
+    campaignTargetCpaCpcBidCeilingMicros: "google:campaignTargetCpaCpcBidCeilingMicros";
+    campaignTargetCpaCpcBidFloorMicros: "google:campaignTargetCpaCpcBidFloorMicros";
+    campaignTargetCpaTargetCpaMicros: "google:campaignTargetCpaTargetCpaMicros";
+    campaignTargetCpcTargetCpcMicros: "google:campaignTargetCpcTargetCpcMicros";
+    campaignTargetCpmTargetFrequencyGoalTargetCount: "google:campaignTargetCpmTargetFrequencyGoalTargetCount";
+    campaignTargetCpmTargetFrequencyGoalTimeUnit: "google:campaignTargetCpmTargetFrequencyGoalTimeUnit";
+    campaignTargetImpressionShareCpcBidCeilingMicros: "google:campaignTargetImpressionShareCpcBidCeilingMicros";
+    campaignTargetImpressionShareLocation: "google:campaignTargetImpressionShareLocation";
+    campaignTargetImpressionShareLocationFractionMicros: "google:campaignTargetImpressionShareLocationFractionMicros";
+    campaignTargetRoasCpcBidCeilingMicros: "google:campaignTargetRoasCpcBidCeilingMicros";
+    campaignTargetRoasCpcBidFloorMicros: "google:campaignTargetRoasCpcBidFloorMicros";
+    campaignTargetRoasTargetRoas: "google:campaignTargetRoasTargetRoas";
+    campaignTargetRoasTargetRoasTolerancePercentMillis: "google:campaignTargetRoasTargetRoasTolerancePercentMillis";
+    campaignTargetSpendCpcBidCeilingMicros: "google:campaignTargetSpendCpcBidCeilingMicros";
+    campaignTargetSpendTargetSpendMicros: "google:campaignTargetSpendTargetSpendMicros";
+    campaignTargetingSettingTargetRestrictions: "google:campaignTargetingSettingTargetRestrictions";
+    clientCustomer: "google:clientCustomer";
+    customer: "google:customer";
+    customerAssetFieldType: "google:customerAssetFieldType";
+    customerAssetPrimaryStatus: "google:customerAssetPrimaryStatus";
+    customerAssetResourceName: "google:customerAssetResourceName";
+    customerAssetSource: "google:customerAssetSource";
+    customerAssetStatus: "google:customerAssetStatus";
+    customerAutoTaggingEnabled: "google:customerAutoTaggingEnabled";
+    customerCallReportingSettingCallConversionAction: "google:customerCallReportingSettingCallConversionAction";
+    customerCallReportingSettingCallConversionReportingEnabled: "google:customerCallReportingSettingCallConversionReportingEnabled";
+    customerCallReportingSettingCallReportingEnabled: "google:customerCallReportingSettingCallReportingEnabled";
+    customerConversionTrackingSettingAcceptedCustomerDataTerms: "google:customerConversionTrackingSettingAcceptedCustomerDataTerms";
+    customerConversionTrackingSettingConversionTracking: "google:customerConversionTrackingSettingConversionTracking";
+    customerConversionTrackingSettingConversionTrackingStatus: "google:customerConversionTrackingSettingConversionTrackingStatus";
+    customerConversionTrackingSettingCrossAccountConversionTracking: "google:customerConversionTrackingSettingCrossAccountConversionTracking";
+    customerConversionTrackingSettingEnhancedConversionsForLeadsEnabled: "google:customerConversionTrackingSettingEnhancedConversionsForLeadsEnabled";
+    customerConversionTrackingSettingGoogleAdsConversionCustomer: "google:customerConversionTrackingSettingGoogleAdsConversionCustomer";
+    customerCurrencyCode: "google:customerCurrencyCode";
+    customerCustomerAgreementSettingAcceptedLeadFormTerms: "google:customerCustomerAgreementSettingAcceptedLeadFormTerms";
+    customerDescriptiveName: "google:customerDescriptiveName";
+    customerFinalUrlSuffix: "google:customerFinalUrlSuffix";
+    customerHasPartnersBadge: "google:customerHasPartnersBadge";
+    customerImageAssetAutoMigrationDone: "google:customerImageAssetAutoMigrationDone";
+    customerImageAssetAutoMigrationDoneDateTime: "google:customerImageAssetAutoMigrationDoneDateTime";
+    customerLocalServicesSettingsGranularInsuranceStatuses: "google:customerLocalServicesSettingsGranularInsuranceStatuses";
+    customerLocalServicesSettingsGranularLicenseStatuses: "google:customerLocalServicesSettingsGranularLicenseStatuses";
+    customerLocationAssetAutoMigrationDone: "google:customerLocationAssetAutoMigrationDone";
+    customerLocationAssetAutoMigrationDoneDateTime: "google:customerLocationAssetAutoMigrationDoneDateTime";
+    customerManager: "google:customerManager";
+    customerOptimizationScore: "google:customerOptimizationScore";
+    customerOptimizationScoreWeight: "google:customerOptimizationScoreWeight";
+    customerRemarketingSettingGoogleGlobalSiteTag: "google:customerRemarketingSettingGoogleGlobalSiteTag";
+    customerResourceName: "google:customerResourceName";
+    customerStatus: "google:customerStatus";
+    customerTestAccount: "google:customerTestAccount";
+    customerTimeZone: "google:customerTimeZone";
+    customerTrackingUrlTemplate: "google:customerTrackingUrlTemplate";
+    customerVideoBrandSafetySuitability: "google:customerVideoBrandSafetySuitability";
+    descriptiveName: "google:descriptiveName";
+    estimatedWeeklySearchCount: "google:estimatedWeeklySearchCount";
+    geoTargetConstantCanonicalName: "google:geoTargetConstantCanonicalName";
+    geoTargetConstantCountryCode: "google:geoTargetConstantCountryCode";
+    geoTargetConstantName: "google:geoTargetConstantName";
+    geoTargetConstantParentGeoTarget: "google:geoTargetConstantParentGeoTarget";
+    geoTargetConstantReach: "google:geoTargetConstantReach";
+    geoTargetConstantResourceName: "google:geoTargetConstantResourceName";
+    geoTargetConstantStatus: "google:geoTargetConstantStatus";
+    geoTargetConstantTargetType: "google:geoTargetConstantTargetType";
+    hidden: "google:hidden";
+    hotelCenterId: "google:hotelCenterId";
+    hotelCityCriterion: "google:hotelCityCriterion";
+    hotelClass: "google:hotelClass";
+    hotelCountryRegionCriterion: "google:hotelCountryRegionCriterion";
+    hotelListingGroup: "google:hotelListingGroup";
+    hotelReconciliationBilled: "google:hotelReconciliationBilled";
+    hotelReconciliationCheckInDate: "google:hotelReconciliationCheckInDate";
+    hotelReconciliationCheckOutDate: "google:hotelReconciliationCheckOutDate";
+    hotelReconciliationOrderId: "google:hotelReconciliationOrderId";
+    hotelReconciliationReconciledValueMicros: "google:hotelReconciliationReconciledValueMicros";
+    hotelReconciliationResourceName: "google:hotelReconciliationResourceName";
+    hotelReconciliationStatus: "google:hotelReconciliationStatus";
+    hotelStateCriterion: "google:hotelStateCriterion";
+    imageUrl: "google:imageUrl";
+    impactBaseMetricsClicks: "google:impactBaseMetricsClicks";
+    impactBaseMetricsConversions: "google:impactBaseMetricsConversions";
+    impactBaseMetricsCostMicros: "google:impactBaseMetricsCostMicros";
+    impactBaseMetricsImpressions: "google:impactBaseMetricsImpressions";
+    impactPotentialMetricsClicks: "google:impactPotentialMetricsClicks";
+    impactPotentialMetricsConversions: "google:impactPotentialMetricsConversions";
+    impactPotentialMetricsCostMicros: "google:impactPotentialMetricsCostMicros";
+    impactPotentialMetricsImpressions: "google:impactPotentialMetricsImpressions";
+    keywordIdeaGeoTargetConstants: "google:keywordIdeaGeoTargetConstants";
+    keywordIdeaSeedUrl: "google:keywordIdeaSeedUrl";
+    level: "google:level";
+    listingGroupType: "google:listingGroupType";
+    mediaKind: "google:mediaKind";
+    metricsAllConversions: "google:metricsAllConversions";
+    metricsAllConversionsValue: "google:metricsAllConversionsValue";
+    metricsAverageCartSize: "google:metricsAverageCartSize";
+    metricsAverageCpc: "google:metricsAverageCpc";
+    metricsBounceRate: "google:metricsBounceRate";
+    metricsClicks: "google:metricsClicks";
+    metricsConversions: "google:metricsConversions";
+    metricsConversionsValue: "google:metricsConversionsValue";
+    metricsCostMicros: "google:metricsCostMicros";
+    metricsCostPerAllConversions: "google:metricsCostPerAllConversions";
+    metricsCostPerConversion: "google:metricsCostPerConversion";
+    metricsCtr: "google:metricsCtr";
+    metricsGrossProfitMargin: "google:metricsGrossProfitMargin";
+    metricsGrossProfitMicros: "google:metricsGrossProfitMicros";
+    metricsHotelAverageLeadValueMicros: "google:metricsHotelAverageLeadValueMicros";
+    metricsHotelEligibleImpressions: "google:metricsHotelEligibleImpressions";
+    metricsHotelPriceDifferencePercentage: "google:metricsHotelPriceDifferencePercentage";
+    metricsImpressions: "google:metricsImpressions";
+    metricsInteractions: "google:metricsInteractions";
+    metricsRevenueMicros: "google:metricsRevenueMicros";
+    metricsSearchBudgetLostImpressionShare: "google:metricsSearchBudgetLostImpressionShare";
+    metricsSearchImpressionShare: "google:metricsSearchImpressionShare";
+    metricsSearchRankLostImpressionShare: "google:metricsSearchRankLostImpressionShare";
+    metricsUniqueUsers: "google:metricsUniqueUsers";
+    metricsValuePerAllConversions: "google:metricsValuePerAllConversions";
+    metricsValuePerConversion: "google:metricsValuePerConversion";
+    metricsViewThroughConversions: "google:metricsViewThroughConversions";
+    parentListingGroup: "google:parentListingGroup";
+    partnerHotelId: "google:partnerHotelId";
+    policySummaryInfoApprovalStatus: "google:policySummaryInfoApprovalStatus";
+    policySummaryInfoReviewStatus: "google:policySummaryInfoReviewStatus";
+    primaryStatus: "google:primaryStatus";
+    recommendationAdGroup: "google:recommendationAdGroup";
+    recommendationCampaign: "google:recommendationCampaign";
+    recommendationCampaignBudget: "google:recommendationCampaignBudget";
+    recommendationCampaigns: "google:recommendationCampaigns";
+    recommendationDismissed: "google:recommendationDismissed";
+    recommendationImpactBaseMetricsClicks: "google:recommendationImpactBaseMetricsClicks";
+    recommendationImpactBaseMetricsConversions: "google:recommendationImpactBaseMetricsConversions";
+    recommendationImpactBaseMetricsConversionsValue: "google:recommendationImpactBaseMetricsConversionsValue";
+    recommendationImpactBaseMetricsCostMicros: "google:recommendationImpactBaseMetricsCostMicros";
+    recommendationImpactBaseMetricsImpressions: "google:recommendationImpactBaseMetricsImpressions";
+    recommendationImpactPotentialMetricsClicks: "google:recommendationImpactPotentialMetricsClicks";
+    recommendationImpactPotentialMetricsConversions: "google:recommendationImpactPotentialMetricsConversions";
+    recommendationImpactPotentialMetricsConversionsValue: "google:recommendationImpactPotentialMetricsConversionsValue";
+    recommendationImpactPotentialMetricsCostMicros: "google:recommendationImpactPotentialMetricsCostMicros";
+    recommendationImpactPotentialMetricsImpressions: "google:recommendationImpactPotentialMetricsImpressions";
+    recommendationKeywordRecommendationKeywordMatchType: "google:recommendationKeywordRecommendationKeywordMatchType";
+    recommendationKeywordRecommendationKeywordText: "google:recommendationKeywordRecommendationKeywordText";
+    recommendationKeywordRecommendationSearchTerms: "google:recommendationKeywordRecommendationSearchTerms";
+    recommendationMarginalRoiCampaignBudgetRecommendationBudgetOptions: "google:recommendationMarginalRoiCampaignBudgetRecommendationBudgetOptions";
+    recommendationMarginalRoiCampaignBudgetRecommendationCurrentBudgetAmountMicros: "google:recommendationMarginalRoiCampaignBudgetRecommendationCurrentBudgetAmountMicros";
+    recommendationMarginalRoiCampaignBudgetRecommendationRecommendedBudgetAmountMicros: "google:recommendationMarginalRoiCampaignBudgetRecommendationRecommendedBudgetAmountMicros";
+    recommendationResourceName: "google:recommendationResourceName";
+    recommendationResponsiveSearchAdImproveAdStrengthRecommendationCurrentAdFinalMobileUrls: "google:recommendationResponsiveSearchAdImproveAdStrengthRecommendationCurrentAdFinalMobileUrls";
+    recommendationResponsiveSearchAdImproveAdStrengthRecommendationCurrentAdFinalUrls: "google:recommendationResponsiveSearchAdImproveAdStrengthRecommendationCurrentAdFinalUrls";
+    recommendationResponsiveSearchAdImproveAdStrengthRecommendationCurrentAdId: "google:recommendationResponsiveSearchAdImproveAdStrengthRecommendationCurrentAdId";
+    recommendationResponsiveSearchAdImproveAdStrengthRecommendationCurrentAdResponsiveSearchAdDescriptions: "google:recommendationResponsiveSearchAdImproveAdStrengthRecommendationCurrentAdResponsiveSearchAdDescriptions";
+    recommendationResponsiveSearchAdImproveAdStrengthRecommendationCurrentAdResponsiveSearchAdHeadlines: "google:recommendationResponsiveSearchAdImproveAdStrengthRecommendationCurrentAdResponsiveSearchAdHeadlines";
+    recommendationResponsiveSearchAdImproveAdStrengthRecommendationRecommendedAdFinalMobileUrls: "google:recommendationResponsiveSearchAdImproveAdStrengthRecommendationRecommendedAdFinalMobileUrls";
+    recommendationResponsiveSearchAdImproveAdStrengthRecommendationRecommendedAdFinalUrls: "google:recommendationResponsiveSearchAdImproveAdStrengthRecommendationRecommendedAdFinalUrls";
+    recommendationResponsiveSearchAdImproveAdStrengthRecommendationRecommendedAdResponsiveSearchAdDescriptions: "google:recommendationResponsiveSearchAdImproveAdStrengthRecommendationRecommendedAdResponsiveSearchAdDescriptions";
+    recommendationResponsiveSearchAdImproveAdStrengthRecommendationRecommendedAdResponsiveSearchAdHeadlines: "google:recommendationResponsiveSearchAdImproveAdStrengthRecommendationRecommendedAdResponsiveSearchAdHeadlines";
+    recommendationTypex: "google:recommendationTypex";
+    resourceName: "google:resourceName";
+    searchTermViewResourceName: "google:searchTermViewResourceName";
+    searchTermViewSearchTerm: "google:searchTermViewSearchTerm";
+    searchTermViewStatus: "google:searchTermViewStatus";
+    segmentsDate: "google:segmentsDate";
+    targetingDimension: "google:targetingDimension";
+    testAccount: "google:testAccount";
+    textContent: "google:textContent";
+    timeZone: "google:timeZone";
+    usedGeoTargetConstant: "google:usedGeoTargetConstant";
+    youtubeVideoId: "google:youtubeVideoId";
+    $prefix: "google:";
+    $iri: string;
+};
+//# sourceMappingURL=namespaces.d.ts.map

package/dist/namespaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespaces.d.ts","sourceRoot":"","sources":["../namespaces.ts"],"names":[],"mappings":"AAIA,cAAc,qBAAqB,CAAC;AAWpC,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGlB,CAAC"}

package/dist/namespaces.js

@@ -0,0 +1,16 @@
+import { createNamespace } from "ldkit";
+import { google as generatedGoogle } from "./.ldkit/namespaces.js";
+import { vocab } from "./realm.js";
+export * from "./.ldkit/namespaces.js";
+// google:CustomerClient is still used as an account-tree root type, but no SHACL shape
+// currently targets it so LDKit codegen omits the term. Keep the LDO namespace API here
+// until a shape lands and codegen emits it.
+const googleManual = createNamespace({
+    iri: vocab("google"),
+    prefix: "google:",
+    terms: ["CustomerClient"],
+});
+export const google = {
+    ...generatedGoogle,
+    CustomerClient: googleManual.CustomerClient,
+};

package/dist/realm.d.ts

@@ -0,0 +1,20 @@
+export declare const canonicalVocabRoot = "https://hiremanta.com/vocab";
+export declare const canonicalVocabLabel = "Hiremanta";
+export type RealmEntry = {
+    vocabRoot: string;
+    label: string;
+};
+export type RealmRegistry = Record<string, RealmEntry>;
+export type Realm = string;
+export type KeycloakRealm = Realm;
+export type VocabRoot = string;
+export declare function realmRegistry(): RealmRegistry;
+export declare const realmVocabRoots: Record<string, string>;
+export declare const defaultRealm: Realm;
+export declare function isRealm(realm: string): realm is Realm;
+export declare function activeRealm(): Realm;
+export declare function vocabRoot(realm?: string): VocabRoot;
+export declare const vocabBase: string;
+export declare function vocab(path: string, realm?: string): string;
+export declare function realmVocabLabel(realm?: Realm): string;
+//# sourceMappingURL=realm.d.ts.map

package/dist/realm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realm.d.ts","sourceRoot":"","sources":["../realm.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,kBAAkB,gCAAgC,CAAC;AAEhE,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAE/C,MAAM,MAAM,UAAU,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAEvD,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC;AAG3B,MAAM,MAAM,aAAa,GAAG,KAAK,CAAC;AAElC,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AA+C/B,wBAAgB,aAAa,IAAI,aAAa,CAE7C;AAED,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAElD,CAAC;AAIF,eAAO,MAAM,YAAY,EAAE,KAA0E,CAAC;AAItG,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,KAAK,CAErD;AAmBD,wBAAgB,WAAW,IAAI,KAAK,CAiBnC;AAED,wBAAgB,SAAS,CAAC,KAAK,GAAE,MAAsB,GAAG,SAAS,CAMlE;AAED,eAAO,MAAM,SAAS,EAAE,MAA0B,CAAC;AAEnD,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,MAAsB,GAAG,MAAM,CAEzE;AAED,wBAAgB,eAAe,CAAC,KAAK,GAAE,KAAqB,GAAG,MAAM,CAMpE"}

package/dist/realm.js

@@ -0,0 +1,97 @@
+// Realms share one vocabulary; only the base IRI differs. Generated artifacts (.ldkit/namespaces.ts,
+// catalog.generated.ts) are produced from the canonical SHACL and compose their IRIs from
+// `vocabBase`/`vocab()` so they resolve against the realm the app runs as.
+// Which realms exist is the deploying application's business, not this package's: the roster names
+// customers, and this package is published. The application injects it through the environment, the
+// same way it already names the active realm. See `agents/src/realms.ts` for the one we deploy.
+//
+// It arrives through the environment rather than a `configureRealms()` call because the generated
+// namespaces call `vocab()` at module scope: a registration made from an app entry point would run
+// after those IRIs had already been composed.
+// The fallback an unconfigured caller resolves against: codegen scripts and tooling run without a
+// realm pinned, and before the roster was injected this is what `defaultRealm` produced for them.
+// Manta's own domain, not a customer's - the roster this package must not name is the other three.
+export const canonicalVocabRoot = "https://hiremanta.com/vocab";
+export const canonicalVocabLabel = "Hiremanta";
+function environment() {
+    return { ...globalThis.process?.env, ...import.meta.env };
+}
+// An application that injects no roster still resolves vocabulary IRIs: codegen scripts and tooling
+// run against the canonical space, which is what they author in.
+function parseRegistry(raw) {
+    if (!raw)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (cause) {
+        throw new Error(`@manta-eu/ldo/realm: VITE_REALM_REGISTRY is not valid JSON.`, { cause });
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`@manta-eu/ldo/realm: VITE_REALM_REGISTRY must be an object of realm slug to { vocabRoot, label }.`);
+    }
+    for (const [slug, entry] of Object.entries(parsed)) {
+        const { vocabRoot, label } = (entry ?? {});
+        if (typeof vocabRoot !== "string" || typeof label !== "string") {
+            throw new Error(`@manta-eu/ldo/realm: realm "${slug}" needs both a vocabRoot and a label.`);
+        }
+    }
+    return parsed;
+}
+// Resolved once: neither the roster nor the realm changes during a process lifetime, and
+// activeRealm() is the default argument of vocabRoot()/vocab(), so re-reading would run hundreds of
+// times.
+const registry = parseRegistry(environment().VITE_REALM_REGISTRY);
+export function realmRegistry() {
+    return registry;
+}
+export const realmVocabRoots = Object.fromEntries(Object.entries(registry).map(([slug, { vocabRoot }]) => [slug, vocabRoot]));
+// With no roster injected there is nothing to enumerate, so the canonical space stands in - that is
+// what an unconfigured tool resolves against.
+export const defaultRealm = environment().VITE_REALM_DEFAULT ?? Object.keys(registry)[0] ?? "";
+const knownRealms = Object.keys(registry).join(", ");
+export function isRealm(realm) {
+    return Object.hasOwn(registry, realm);
+}
+// An unrecognized realm is a misconfiguration. Falling back would silently resolve every vocabulary
+// IRI against the wrong realm, so fail instead of shipping a broken vocabulary.
+function assertRealm(realm, source) {
+    if (isRealm(realm))
+        return;
+    const known = knownRealms
+        ? `Use one of: ${knownRealms}.`
+        : "No realm registry is injected: set VITE_REALM_REGISTRY to the roster this application deploys.";
+    throw new Error(`@manta-eu/ldo/realm: unknown realm "${realm}" (${source}). Vocabulary IRIs would resolve against the ` +
+        `wrong realm. ${known}`);
+}
+let resolvedRealm;
+export function activeRealm() {
+    if (resolvedRealm !== undefined)
+        return resolvedRealm;
+    const configuredRealm = environment().VITE_KEYCLOAK_REALM;
+    // Unset is the supported default: codegen scripts and tooling run without a realm pinned.
+    if (!configuredRealm) {
+        resolvedRealm = defaultRealm;
+        return resolvedRealm;
+    }
+    assertRealm(configuredRealm, "VITE_KEYCLOAK_REALM");
+    resolvedRealm = configuredRealm;
+    return resolvedRealm;
+}
+export function vocabRoot(realm = activeRealm()) {
+    if (!realm)
+        return canonicalVocabRoot;
+    assertRealm(realm, "vocabRoot argument");
+    return registry[realm].vocabRoot;
+}
+export const vocabBase = `${vocabRoot()}#`;
+export function vocab(path, realm = activeRealm()) {
+    return `${vocabRoot(realm)}/${path}#`;
+}
+export function realmVocabLabel(realm = activeRealm()) {
+    if (!realm)
+        return canonicalVocabLabel;
+    assertRealm(realm, "realmVocabLabel argument");
+    return registry[realm].label;
+}

package/dist/redirect-queries.d.ts

@@ -0,0 +1,22 @@
+import type { SparqlBinding } from "./sparql-types.js";
+export type { SparqlBinding } from "./sparql-types.js";
+export type SparqlFetcher = (query: string) => Promise<SparqlBinding[]>;
+export type RedirectLookup = {
+    entityTypeUri: string;
+    externalId: string;
+    params: Record<string, string>;
+};
+export declare function redirectPath(iri: string, endpoint?: string): string;
+export declare function buildEntityIdentityQuery(iri: string): string;
+export declare function buildEntityExistsQuery(iri: string): string;
+export declare function entityExists(iri: string, fetch: SparqlFetcher): Promise<boolean>;
+export declare function parseEntityIdentity(bindings: SparqlBinding[], iri: string): {
+    entityTypeUri: string;
+    externalId: string;
+} | undefined;
+export declare function buildUrlParamsQuery(iri: string, entityTypeUri: string): {
+    query: string;
+    extractParams: (bindings: SparqlBinding[]) => Record<string, string>;
+} | undefined;
+export declare function resolveRedirectTarget(iri: string, fetch: SparqlFetcher): Promise<RedirectLookup | undefined>;
+//# sourceMappingURL=redirect-queries.d.ts.map

package/dist/redirect-queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redirect-queries.d.ts","sourceRoot":"","sources":["../redirect-queries.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAIpD,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;AAExE,MAAM,MAAM,cAAc,GAAG;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC,CAAC;AAEF,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,SAAc,UAE/D;AAED,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ5D;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG1D;AAKD,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAGtF;AAQD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,aAAa,EAAE,EACzB,GAAG,EAAE,MAAM,GACV;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAa3D;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,aAAa,EAAE,MAAM,GACpB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,SAAS,CA0CrG;AAED,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAUlH"}

package/dist/redirect-queries.js

@@ -0,0 +1,93 @@
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { match } from "ts-pattern";
+import { figma } from "./.ldkit/namespaces.js";
+import { metaEntityTypesNeedingAccountParam } from "./ad-platform-links.js";
+const df = new DataFactory();
+export function redirectPath(iri, endpoint = "/redirect") {
+    return `${endpoint}?iri=${encodeURIComponent(iri)}`;
+}
+export function buildEntityIdentityQuery(iri) {
+    const subject = df.namedNode(iri);
+    return SELECT `?type ?identifier`.WHERE `
+    ${subject} a ?type EXPLICIT TRUE .
+    OPTIONAL { ${subject} schema:identifier ?identifier }
+  `
+        .LIMIT(1)
+        .build();
+}
+export function buildEntityExistsQuery(iri) {
+    const subject = df.namedNode(iri);
+    return SELECT `?p`.WHERE `${subject} ?p ?o`.LIMIT(1).build();
+}
+// Identity resolution needs an explicit rdf:type, so an entity can be real and still unidentifiable
+// (inference-only types, or a multi-typed entity whose picked type isn't the one in its IRI). This
+// probe separates those from an IRI nothing describes at all.
+export async function entityExists(iri, fetch) {
+    const bindings = await fetch(buildEntityExistsQuery(iri));
+    return bindings.length > 0;
+}
+function externalIdFromEntityIri(iri, entityTypeUri) {
+    const prefix = `${entityTypeUri}_`;
+    return iri.startsWith(prefix) && iri.length > prefix.length ? iri.slice(prefix.length) : undefined;
+}
+export function parseEntityIdentity(bindings, iri) {
+    const row = bindings[0];
+    const entityTypeUri = row?.type?.value;
+    if (!entityTypeUri)
+        return undefined;
+    const identifier = row?.identifier;
+    const externalId = identifier?.type === "literal" && identifier.value ? identifier.value : externalIdFromEntityIri(iri, entityTypeUri);
+    if (!externalId)
+        return undefined;
+    return { entityTypeUri, externalId };
+}
+export function buildUrlParamsQuery(iri, entityTypeUri) {
+    const subject = df.namedNode(iri);
+    return match(entityTypeUri)
+        .when((uri) => metaEntityTypesNeedingAccountParam.has(uri), () => ({
+        query: SELECT `?accountId`.WHERE `
+          ${subject} meta:account ?account .
+          ?account schema:identifier ?accountId
+        `
+            .LIMIT(1)
+            .build(),
+        extractParams: (bindings) => {
+            const accountId = bindings[0]?.accountId?.value;
+            return accountId ? { accountId } : {};
+        },
+    }))
+        .with(figma.Node, () => ({
+        query: SELECT `?fileKey`.WHERE `
+        ${subject} ${df.namedNode(figma.file)} ?file .
+        ?file schema:identifier ?fileKey
+      `
+            .LIMIT(1)
+            .build(),
+        extractParams: (bindings) => {
+            const fileKey = bindings[0]?.fileKey?.value;
+            return fileKey ? { fileKey } : {};
+        },
+    }))
+        .with(figma.File, () => ({
+        query: SELECT `?url`.WHERE `
+        ${subject} schema:url ?url
+      `
+            .LIMIT(1)
+            .build(),
+        extractParams: (bindings) => {
+            const url = bindings[0]?.url?.value;
+            return url ? { url } : {};
+        },
+    }))
+        .otherwise(() => undefined);
+}
+export async function resolveRedirectTarget(iri, fetch) {
+    const identityBindings = await fetch(buildEntityIdentityQuery(iri));
+    const identity = parseEntityIdentity(identityBindings, iri);
+    if (!identity)
+        return undefined;
+    const urlParamsQuery = buildUrlParamsQuery(iri, identity.entityTypeUri);
+    const params = urlParamsQuery ? urlParamsQuery.extractParams(await fetch(urlParamsQuery.query)) : {};
+    return { ...identity, params };
+}