/**
 * SAP Integration Content Client
 *
 * Diese Datei enthält eine vereinfachte Client-Klasse für die Interaktion mit
 * den Integration Content APIs von SAP Cloud Integration.
 *
 * @module sap-integration-suite-client/integration-content
 */
import { Api as IntegrationContentApi, ComSapHciApiIntegrationPackage, ComSapHciApiIntegrationPackageCreate, ComSapHciApiIntegrationDesigntimeArtifact, ComSapHciApiConfiguration, ComSapHciApiServiceEndpoint, ComSapHciApiIntegrationRuntimeArtifact, ComSapHciApiValueMappingDesigntimeArtifact, ComSapHciApiMessageMappingDesigntimeArtifact, ComSapHciApiScriptCollectionDesigntimeArtifact, ComSapHciApiIntegrationPackageUpdate, ComSapHciApiIntegrationDesigntimeArtifactCreate, ComSapHciApiIntegrationDesigntimeArtifactUpdate, ComSapHciApiResourceCreate, ComSapHciApiResourceUpdate, ComSapHciApiBuildAndDeployStatus, ComSapHciApiDesignGuidlineExecutionResult, ComSapHciApiDesignGuidelineExecutionResultsSkip, ComSapHciApiValueMappingDesigntimeArtifactCreate, ComSapHciApiMessageMappingDesigntimeArtifactCreate, ComSapHciApiScriptCollectionDesigntimeArtifactCreate, ComSapHciApiScriptCollectionDesigntimeArtifactUpdate, ComSapHciApiResource, ComSapHciApiValMapSchema, ComSapHciApiValMaps, ComSapHciApiCustomTagsConfiguration, ComSapHciApiCustomTagsConfigurationCreate, ComSapHciApiIntegrationAdapterDesigntimeArtifact, ComSapHciApiIntegrationAdapterDesigntimeArtifactImport, ComSapHciApiMDIDeltaToken, ComSapHciApiRuntimeArtifactErrorInformation } from '../types/sap.IntegrationContent';
import { PackageWithArtifacts, DetailedErrorInformation, ParsedErrorDetails } from '../types/sap.ContentClient';
import { CacheManager } from '../core/cache-manager';
import { ArtifactStatusUpdate, CacheInfo } from '../types/cache';
/**
 * Erweiterter SAP Integration Content Client
 *
 * Diese Klasse stellt eine vereinfachte API für die Interaktion
 * mit den SAP Integration Content APIs bereit.
 */
export declare class IntegrationContentClient {
    private api;
    private normalizer;
    private advancedClient;
    private cacheManager;
    private hostname;
    /**
     * Erstellt einen neuen IntegrationContentClient
     *
     * @param {IntegrationContentApi<unknown>} api - Die zugrunde liegende API-Instanz
     * @param {CacheManager} [cacheManager] - Optional: CacheManager für Cache-Updates
     * @param {string} [hostname] - Optional: Hostname für Cache-Key-Generierung
     */
    constructor(api: IntegrationContentApi<unknown>, cacheManager?: CacheManager | null, hostname?: string);
    /**
     * Gibt alle Integrationspakete zurück
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Pakete
     * @param {number} [options.skip] Anzahl der zu überspringenden Pakete
     * @param {string} [options.author] Filtern nach Autor (Custom Tag)
     * @param {string} [options.lob] Filtern nach Line of Business (Custom Tag)
     * @returns {Promise<ComSapHciApiIntegrationPackage[]>} Promise mit einer Liste von Integrationspaketen
     *
     * @example
     * // Alle Integrationspakete abrufen
     * const packages = await client.getIntegrationPackages();
     *
     * @example
     * // Pakete mit Paginierung abrufen
     * const packages = await client.getIntegrationPackages({ top: 10, skip: 20 });
     */
    getIntegrationPackages(options?: {
        top?: number;
        skip?: number;
        author?: string;
        lob?: string;
    }): Promise<ComSapHciApiIntegrationPackage[]>;
    /**
     * Gibt alle Integrationspakete zurück (mit Caching)
     *
     * Diese Methode implementiert das Stale-While-Revalidate Pattern:
     * - Frische Daten aus Cache werden sofort zurückgegeben
     * - Veraltete Daten werden sofort zurückgegeben und im Hintergrund aktualisiert
     * - Bei Cache-Miss werden frische Daten von SAP geholt und gecacht
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Pakete
     * @param {number} [options.skip] Anzahl der zu überspringenden Pakete
     * @param {string} [options.author] Filtern nach Autor (Custom Tag)
     * @param {string} [options.lob] Filtern nach Line of Business (Custom Tag)
     * @param {boolean} [forceRefresh=false] Erzwingt das Laden frischer Daten von SAP
     * @returns {Promise<{data: ComSapHciApiIntegrationPackage[], cacheInfo: CacheInfo}>} Pakete mit Cache-Informationen
     *
     * @example
     * const { data, cacheInfo } = await client.getIntegrationPackagesWithCache();
     * console.log(cacheInfo.hit);    // true/false
     * console.log(cacheInfo.status); // 'HIT', 'HIT-STALE', 'MISS', or 'DISABLED'
     */
    getIntegrationPackagesWithCache(options?: {
        top?: number;
        skip?: number;
        author?: string;
        lob?: string;
    }, forceRefresh?: boolean): Promise<{
        data: ComSapHciApiIntegrationPackage[];
        cacheInfo: CacheInfo;
    }>;
    /**
     * Gibt ein Integrationspaket anhand seiner ID zurück
     *
     * @param {string} packageId ID des Integrationspakets
     * @returns {Promise<ComSapHciApiIntegrationPackage>} Promise mit dem Integrationspaket
     *
     * @example
     * const package = await client.getIntegrationPackageById('MyPackageId');
     */
    getIntegrationPackageById(packageId: string): Promise<ComSapHciApiIntegrationPackage>;
    /**
     * Erstellt ein neues Integrationspaket
     *
     * @param {ComSapHciApiIntegrationPackageCreate} packageData Daten des Integrationspakets
     * @param {boolean} [overwrite=false] Ob ein existierendes Paket mit der gleichen ID überschrieben werden soll
     * @returns {Promise<ComSapHciApiIntegrationPackage>} Promise mit dem erstellten Integrationspaket
     *
     * @example
     * const newPackage = await client.createIntegrationPackage({
     *   Id: 'MyNewPackage',
     *   Name: 'My New Integration Package',
     *   Description: 'This is a new package'
     * });
     */
    createIntegrationPackage(packageData: ComSapHciApiIntegrationPackageCreate, overwrite?: boolean): Promise<ComSapHciApiIntegrationPackage>;
    /**
     * Löscht ein Integrationspaket anhand seiner ID
     *
     * @param {string} packageId ID des zu löschenden Integrationspakets
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn das Paket gelöscht wurde
     *
     * @example
     * await client.deleteIntegrationPackage('MyPackageId');
     */
    deleteIntegrationPackage(packageId: string): Promise<void>;
    /**
     * Gibt alle Integrationsflows für ein bestimmtes Paket zurück
     *
     * @param {string} packageId ID des Integrationspakets
     * @returns {Promise<ComSapHciApiIntegrationDesigntimeArtifact[]>} Promise mit einer Liste von Integrationsflows
     *
     * @example
     * const flows = await client.getIntegrationFlows('MyPackageId');
     */
    getIntegrationFlows(packageId: string): Promise<ComSapHciApiIntegrationDesigntimeArtifact[]>;
    /**
     * Gibt einen bestimmten Integrationsflow anhand seiner ID und Version zurück
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} version Version des Integrationsflows (Standard: 'active')
     * @returns {Promise<ComSapHciApiIntegrationDesigntimeArtifact>} Promise mit dem Integrationsflow
     *
     * @example
     * const flow = await client.getIntegrationFlowById('MyFlowId', '1.0.0');
     */
    getIntegrationFlowById(flowId: string, version?: string): Promise<ComSapHciApiIntegrationDesigntimeArtifact | undefined>;
    /**
     * Erstellt oder lädt einen neuen Integrationsflow hoch.
     *
     * @param {ComSapHciApiIntegrationDesigntimeArtifactCreate} flowData Daten des zu erstellenden Flows
     * @returns {Promise<ComSapHciApiIntegrationDesigntimeArtifact>} Promise mit dem erstellten Integrationsflow
     *
     * @example
     * const newFlow = await client.createIntegrationFlow({
     *   Id: 'MyNewFlow',
     *   Name: 'My New Flow',
     *   PackageId: 'MyPackageId',
     *   ArtifactContent: 'base64encodedZipContent' // Base64 kodierter ZIP-Inhalt
     * });
     */
    createIntegrationFlow(flowData: ComSapHciApiIntegrationDesigntimeArtifactCreate): Promise<ComSapHciApiIntegrationDesigntimeArtifact | undefined>;
    /**
     * Aktualisiert einen vorhandenen Integrationsflow.
     *
     * @param {string} flowId ID des zu aktualisierenden Flows
     * @param {string} version Version des zu aktualisierenden Flows
     * @param {ComSapHciApiIntegrationDesigntimeArtifactUpdate} flowData Die zu aktualisierenden Daten
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn der Flow aktualisiert wurde
     *
     * @example
     * await client.updateIntegrationFlow('MyFlowId', '1.0.0', {
     *   Name: 'Updated Flow Name',
     *   ArtifactContent: 'newBase64encodedZipContent' // Neuer Base64 kodierter ZIP-Inhalt
     * });
     */
    updateIntegrationFlow(flowId: string, version: string, flowData: ComSapHciApiIntegrationDesigntimeArtifactUpdate): Promise<void>;
    /**
     * Löscht einen Integrationsflow anhand seiner ID und Version.
     *
     * @param {string} flowId ID des zu löschenden Integrationsflows
     * @param {string} version Version des zu löschenden Integrationsflows
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn der Flow gelöscht wurde
     *
     * @example
     * await client.deleteIntegrationFlow('MyFlowId', '1.0.0');
     */
    deleteIntegrationFlow(flowId: string, version: string): Promise<void>;
    /**
     * Lädt einen Integrationsflow als ZIP-Datei herunter.
     *
     * Hinweis: Download von Flows aus Configure-Only-Paketen ist nicht möglich.
     * Die Methode gibt in Node.js-Umgebungen einen Buffer zurück und
     * in Browser-Umgebungen einen Blob/File.
     *
     * @param {string} flowId ID des herunterzuladenden Flows
     * @param {string} [version='active'] Version des herunterzuladenden Flows
     * @returns {Promise<Buffer | Blob>} Promise mit den Binärdaten des Flows
     *
     * @example
     * // In Node.js:
     * try {
     *   const buffer = await client.downloadIntegrationFlow('MyFlowId', '1.0.1');
     *   fs.writeFileSync('MyFlowId.zip', buffer);
     * } catch (error) {
     *   console.error('Download failed:', error);
     * }
     */
    downloadIntegrationFlow(flowId: string, version?: string): Promise<Buffer | Blob>;
    /**
     * Deployed einen Integrationsflow
     *
     * SAP erwartet Single Quotes in der URL, die NICHT URL-encoded sein dürfen.
     * Deshalb wird hier ein direkter HTTP-Request gemacht, der die URL manuell baut.
     *
     * @param {string} flowId ID des zu deployenden Integrationsflows
     * @param {string} [version='active'] Version des Integrationsflows
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn das Deployment gestartet wurde
     *
     * @example
     * await client.deployIntegrationFlow('MyFlowId');
     */
    deployIntegrationFlow(flowId: string, version?: string): Promise<void>;
    /**
     * Undeployed einen Integrationsflow
     *
     * SAP erwartet Single Quotes im URL-Pfad, die NICHT URL-encoded sein dürfen.
     * Die standard API-Methode würde die Quotes als %27 encodieren, deshalb verwenden wir axios direkt.
     *
     * @param {string} flowId ID des zu undeployenden Integrationsflows
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn der Flow undeployed wurde
     *
     * @example
     * await client.undeployIntegrationFlow('MyFlowId');
     */
    undeployIntegrationFlow(flowId: string): Promise<void>;
    /**
     * Gibt alle deployten Integrationsartefakte zurück
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Artefakte
     * @param {number} [options.skip] Anzahl der zu überspringenden Artefakte
     * @param {string} [options.filter] OData-Filterausdruck
     * @returns {Promise<ComSapHciApiIntegrationRuntimeArtifact[]>} Promise mit einer Liste von Runtime-Artefakten
     *
     * @example
     * // Alle deployten Artefakte abrufen
     * const runtimeArtifacts = await client.getDeployedArtifacts();
     *
     * @example
     * // Deployten Artefakte mit Filter abrufen
     * const errorArtifacts = await client.getDeployedArtifacts({
     *   filter: "Status eq 'ERROR'"
     * });
     */
    getDeployedArtifacts(options?: {
        top?: number;
        skip?: number;
        filter?: string;
    }): Promise<ComSapHciApiIntegrationRuntimeArtifact[]>;
    /**
     * Gibt deployed Artefakte zurück (mit Caching)
     *
     * Diese Methode implementiert das Stale-While-Revalidate Pattern:
     * - Frische Daten aus Cache werden sofort zurückgegeben
     * - Veraltete Daten werden sofort zurückgegeben und im Hintergrund aktualisiert
     * - Bei Cache-Miss werden frische Daten von SAP geholt und gecacht
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Artefakte
     * @param {number} [options.skip] Anzahl der zu überspringenden Artefakte
     * @param {string} [options.filter] OData-Filterausdruck
     * @param {boolean} [forceRefresh=false] Erzwingt das Laden frischer Daten von SAP
     * @returns {Promise<{data: ComSapHciApiIntegrationRuntimeArtifact[], cacheInfo: CacheInfo}>} Artefakte mit Cache-Informationen
     *
     * @example
     * const { data, cacheInfo } = await client.getDeployedArtifactsWithCache();
     * console.log(cacheInfo.hit);    // true/false
     * console.log(cacheInfo.status); // 'HIT', 'HIT-STALE', 'MISS', or 'DISABLED'
     */
    getDeployedArtifactsWithCache(options?: {
        top?: number;
        skip?: number;
        filter?: string;
    }, forceRefresh?: boolean): Promise<{
        data: ComSapHciApiIntegrationRuntimeArtifact[];
        cacheInfo: CacheInfo;
    }>;
    /**
     * Gibt Konfigurationsparameter für einen Integrationsflow zurück
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} [version='active'] Version des Integrationsflows
     * @param {string} [filter] Optionaler OData-Filterausdruck
     * @returns {Promise<ComSapHciApiConfiguration[]>} Promise mit einer Liste von Konfigurationen
     *
     * @example
     * const configs = await client.getIntegrationFlowConfigurations('MyFlowId');
     */
    getIntegrationFlowConfigurations(flowId: string, version?: string, filter?: string): Promise<ComSapHciApiConfiguration[]>;
    /**
     * Gibt Konfigurationsparameter für einen Integrationsflow zurück (mit Caching)
     *
     * Diese Methode implementiert das Stale-While-Revalidate Pattern.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} [version='active'] Version des Integrationsflows
     * @param {string} [filter] Optionaler OData-Filterausdruck
     * @param {boolean} [forceRefresh=false] Erzwingt das Laden frischer Daten von SAP
     * @returns {Promise<{data: ComSapHciApiConfiguration[], cacheInfo: CacheInfo}>} Konfigurationen mit Cache-Informationen
     *
     * @example
     * const { data, cacheInfo } = await client.getIntegrationFlowConfigurationsWithCache('MyFlowId');
     */
    getIntegrationFlowConfigurationsWithCache(flowId: string, version?: string, filter?: string, forceRefresh?: boolean): Promise<{
        data: ComSapHciApiConfiguration[];
        cacheInfo: CacheInfo;
    }>;
    /**
     * Gibt die Anzahl der Konfigurationsparameter für einen Integrationsflow zurück.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} [version='active'] Version des Integrationsflows
     * @param {string} [filter] Optionaler OData-Filterausdruck
     * @returns {Promise<number>} Promise mit der Anzahl der Konfigurationen
     *
     * @example
     * const count = await client.getIntegrationFlowConfigurationCount('MyFlowId');
     * console.log(`Flow has ${count} configurations.`);
     */
    getIntegrationFlowConfigurationCount(flowId: string, version?: string, filter?: string): Promise<number>;
    /**
     * Aktualisiert einen Konfigurationsparameter für einen Integrationsflow
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} parameterKey Schlüssel des zu aktualisierenden Parameters
     * @param {string} parameterValue Neuer Wert für den Parameter
     * @param {string} [dataType] Datentyp des Parameters (z.B., 'xsd:string')
     * @param {string} [version='active'] Version des Integrationsflows
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn der Parameter aktualisiert wurde
     *
     * @example
     * await client.updateIntegrationFlowConfiguration(
     *   'MyFlowId',
     *   'Receiver_Host',
     *   'api.example.com',
     *   'xsd:string'
     * );
     */
    updateIntegrationFlowConfiguration(flowId: string, parameterKey: string, parameterValue: string, dataType?: string, version?: string): Promise<void>;
    /**
     * Gibt alle Service-Endpoints von deployten Integrationsflows zurück
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Endpoints
     * @param {number} [options.skip] Anzahl der zu überspringenden Endpoints
     * @param {string} [options.filter] OData-Filterausdruck
     * @returns {Promise<ComSapHciApiServiceEndpoint[]>} Promise mit einer Liste von Service-Endpoints
     *
     * @example
     * const endpoints = await client.getServiceEndpoints();
     */
    getServiceEndpoints(options?: {
        top?: number;
        skip?: number;
        filter?: string;
    }): Promise<ComSapHciApiServiceEndpoint[]>;
    /**
     * Gibt Fehlerinformationen für ein deployten Integrationsartefakt zurück
     *
     * @param {string} artifactId ID des deployten Integrationsartefakts
     * @returns {Promise<ComSapHciApiRuntimeArtifactErrorInformation | null>} Promise mit den Fehlerinformationen oder null bei Fehlern
     *
     * @example
     * const errorInfo = await client.getArtifactErrorInformation('MyFailedFlow');
     * if (errorInfo && errorInfo.Id) {
     *   console.log(`Fehler-ID: ${errorInfo.Id}`);
     * }
     */
    getArtifactErrorInformation(artifactId: string): Promise<ComSapHciApiRuntimeArtifactErrorInformation | null>;
    /**
     * Gibt Fehlerinformationen für ein Artefakt zurück (mit Caching)
     *
     * Diese Methode implementiert das Stale-While-Revalidate Pattern.
     * Nutzt kürzere Revalidierungszeit da Fehlerinformationen sich häufig ändern können.
     *
     * @param {string} artifactId ID des Artefakts
     * @param {boolean} [forceRefresh=false] Erzwingt das Laden frischer Daten von SAP
     * @returns {Promise<{data: ComSapHciApiRuntimeArtifactErrorInformation | null, cacheInfo: CacheInfo}>}
     *
     * @example
     * const { data, cacheInfo } = await client.getArtifactErrorInformationWithCache('MyArtifactId');
     */
    getArtifactErrorInformationWithCache(artifactId: string, forceRefresh?: boolean): Promise<{
        data: ComSapHciApiRuntimeArtifactErrorInformation | null;
        cacheInfo: CacheInfo;
    }>;
    /**
     * Gibt detaillierte Fehlerinformationen für ein deployten Integrationsartefakt zurück
     * Diese Methode ruft den spezifischen $value-Endpunkt auf, der mehr Details enthält
     *
     * @param {string} artifactId ID des deployten Integrationsartefakts
     * @returns {Promise<DetailedErrorInformation | null>} Promise mit den detaillierten Fehlerinformationen oder null bei Fehlern
     *
     * @example
     * const detailedError = await client.getDetailedArtifactErrorInformation('MyFailedFlow');
     * if (detailedError && detailedError.message) {
     *   console.log(`Fehlertyp: ${detailedError.message.messageId}`);
     *   if (detailedError.parameter && detailedError.parameter.length > 0) {
     *     try {
     *       const paramJson = JSON.parse(detailedError.parameter[0]);
     *       console.log(`Fehlermeldung: ${paramJson.message}`);
     *     } catch (e) {
     *       console.log(`Parameter: ${detailedError.parameter[0]}`);
     *     }
     *   }
     * }
     *
     * @deprecated Diese Methode wird in zukünftigen Versionen ausgelagert. Bitte verwenden Sie die entsprechenden Methoden im IntegrationContentAdvancedClient.
     */
    getDetailedArtifactErrorInformation(artifactId: string): Promise<DetailedErrorInformation | null>;
    /**
     * Parst die Fehlerdetails aus den Parametern einer DetailedErrorInformation
     *
     * @param {DetailedErrorInformation} errorInfo Die detaillierten Fehlerinformationen
     * @returns {ParsedErrorDetails | null} Die geparsten Fehlerdetails oder null, wenn keine Parameter vorhanden oder das Parsing fehlschlägt
     *
     * @example
     * const detailedError = await client.getDetailedArtifactErrorInformation('MyFailedFlow');
     * if (detailedError) {
     *   const errorDetails = client.parseErrorDetails(detailedError);
     *   if (errorDetails && errorDetails.message) {
     *     console.log(`Fehlermeldung: ${errorDetails.message}`);
     *
     *     if (errorDetails.childMessageInstances && errorDetails.childMessageInstances.length > 0) {
     *       console.log(`Hauptursache: ${errorDetails.childMessageInstances[0].message}`);
     *     }
     *   }
     * }
     *
     * @deprecated Diese Methode wird in zukünftigen Versionen ausgelagert. Bitte verwenden Sie die entsprechenden Methoden im IntegrationContentAdvancedClient.
     */
    parseErrorDetails(errorInfo: DetailedErrorInformation): ParsedErrorDetails | null;
    /**
     * Gibt alle Value Mappings für ein bestimmtes Paket zurück
     *
     * @param {string} packageId ID des Integrationspakets
     * @returns {Promise<ComSapHciApiValueMappingDesigntimeArtifact[]>} Promise mit einer Liste von Value Mappings
     *
     * @example
     * const valueMappings = await client.getValueMappings('MyPackageId');
     */
    getValueMappings(packageId: string): Promise<ComSapHciApiValueMappingDesigntimeArtifact[]>;
    /**
     * Gibt alle Message Mappings für ein bestimmtes Paket zurück
     *
     * @param {string} packageId ID des Integrationspakets
     * @returns {Promise<ComSapHciApiMessageMappingDesigntimeArtifact[]>} Promise mit einer Liste von Message Mappings
     *
     * @example
     * const messageMappings = await client.getMessageMappings('MyPackageId');
     */
    getMessageMappings(packageId: string): Promise<ComSapHciApiMessageMappingDesigntimeArtifact[]>;
    /**
     * Ruft alle Integrationspakete mit ihren zugehörigen Artefakten ab
     *
     * Diese Methode holt alle Integrationspakete und sammelt für jedes Paket:
     * - Integrationsflows
     * - Message Mappings
     * - Value Mappings
     * - Script Collections
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Pakete
     * @param {number} [options.skip] Anzahl der zu überspringenden Pakete
     * @param {boolean} [options.includeEmpty=false] Ob leere Pakete ohne Artefakte inkludiert werden sollen
     * @param {boolean} [options.parallel=false] Ob die Artefakte parallel abgerufen werden sollen (schneller, aber möglicherweise API-Limits)
     * @returns {Promise<PackageWithArtifacts[]>} Liste von Paketen mit ihren Artefakten
     *
     * @example
     * // Alle Pakete mit ihren Artefakten abrufen
     * const packagesWithArtifacts = await client.getPackagesWithArtifacts();
     *
     * // Nur die ersten 5 Pakete mit Artefakten abrufen
     * const packagesWithArtifacts = await client.getPackagesWithArtifacts({ top: 5 });
     *
     * // Alle Pakete mit parallelen API-Aufrufen abrufen (schneller)
     * const packagesWithArtifacts = await client.getPackagesWithArtifacts({ parallel: true });
     *
     * @deprecated Diese Methode wird in zukünftigen Versionen ausgelagert. Bitte verwenden Sie die entsprechenden Methoden im IntegrationContentAdvancedClient.
     */
    getPackagesWithArtifacts(options?: {
        top?: number;
        skip?: number;
        includeEmpty?: boolean;
        parallel?: boolean;
    }): Promise<PackageWithArtifacts[]>;
    /**
     * Ruft alle Integrationspakete mit ihren zugehörigen Artefakten ab (mit Caching)
     *
     * Diese Methode implementiert das Stale-While-Revalidate Pattern:
     * - Frische Daten aus Cache werden sofort zurückgegeben
     * - Veraltete Daten werden sofort zurückgegeben und im Hintergrund aktualisiert
     * - Bei Cache-Miss werden frische Daten von SAP geholt und gecacht
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Pakete
     * @param {number} [options.skip] Anzahl der zu überspringenden Pakete
     * @param {boolean} [options.includeEmpty=false] Ob leere Pakete ohne Artefakte inkludiert werden sollen
     * @param {boolean} [options.parallel=false] Ob die Artefakte parallel abgerufen werden sollen
     * @param {boolean} [forceRefresh=false] Erzwingt das Laden frischer Daten von SAP
     * @returns {Promise<{data: PackageWithArtifacts[], cacheInfo: CacheInfo}>} Pakete mit Cache-Informationen
     *
     * @example
     * const { data, cacheInfo } = await client.getPackagesWithArtifactsWithCache();
     * console.log(cacheInfo.hit);    // true/false
     * console.log(cacheInfo.status); // 'HIT', 'HIT-STALE', 'MISS', or 'DISABLED'
     */
    getPackagesWithArtifactsWithCache(options?: {
        top?: number;
        skip?: number;
        includeEmpty?: boolean;
        parallel?: boolean;
    }, forceRefresh?: boolean): Promise<{
        data: PackageWithArtifacts[];
        cacheInfo: CacheInfo;
    }>;
    /**
     * Ruft alle Integrationsflows aller Pakete ab
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Pakete für die Abfrage
     * @param {ComSapHciApiIntegrationPackage[]} [options.packages] Bereits abgerufene Pakete, um redundante API-Aufrufe zu vermeiden
     * @returns {Promise<ComSapHciApiIntegrationDesigntimeArtifact[]>} Liste aller Integrationsflows
     *
     * @example
     * const allFlows = await client.getAllIntegrationFlows();
     *
     * // Mit bereits vorhandenen Paketen
     * const packages = await client.getIntegrationPackages();
     * const allFlows = await client.getAllIntegrationFlows({ packages });
     *
     * @deprecated Diese Methode wird in zukünftigen Versionen ausgelagert. Bitte verwenden Sie die entsprechenden Methoden im IntegrationContentAdvancedClient.
     */
    getAllIntegrationFlows(options?: {
        top?: number;
        packages?: ComSapHciApiIntegrationPackage[];
    }): Promise<ComSapHciApiIntegrationDesigntimeArtifact[]>;
    /**
     * Ruft alle Script Collections aller Pakete ab
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Pakete für die Abfrage
     * @param {ComSapHciApiIntegrationPackage[]} [options.packages] Bereits abgerufene Pakete, um redundante API-Aufrufe zu vermeiden
     * @returns {Promise<ComSapHciApiScriptCollectionDesigntimeArtifact[]>} Liste aller Script Collections
     *
     * @example
     * const allScriptCollections = await client.getAllScriptCollections();
     *
     * // Mit bereits vorhandenen Paketen
     * const packages = await client.getIntegrationPackages();
     * const allScripts = await client.getAllScriptCollections({ packages });
     *
     * @deprecated Diese Methode wird in zukünftigen Versionen ausgelagert. Bitte verwenden Sie die entsprechenden Methoden im IntegrationContentAdvancedClient.
     */
    getAllScriptCollections(options?: {
        top?: number;
        packages?: ComSapHciApiIntegrationPackage[];
    }): Promise<ComSapHciApiScriptCollectionDesigntimeArtifact[]>;
    /**
     * Aktualisiert ein Integrationspaket anhand seiner ID
     *
     * @param {string} packageId ID des zu aktualisierenden Integrationspakets
     * @param {ComSapHciApiIntegrationPackageUpdate} packageData Die zu aktualisierenden Daten des Pakets
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn das Paket aktualisiert wurde
     *
     * @example
     * await client.updateIntegrationPackage('MyPackageId', {
     *   Name: 'Updated Package Name',
     *   Description: 'This package has been updated.'
     * });
     */
    updateIntegrationPackage(packageId: string, packageData: ComSapHciApiIntegrationPackageUpdate): Promise<void>;
    /**
     * Lädt ein Integrationspaket als ZIP-Datei herunter
     *
     * Hinweis: Download schlägt fehl, wenn das Paket Artefakte im Entwurfsstatus enthält.
     * Der Rückgabetyp `File` ist primär für Browser-Umgebungen relevant. In Node.js
     * müsste die Response anders behandelt werden (z.B. als Stream oder Buffer).
     *
     * @param {string} packageId ID des herunterzuladenden Integrationspakets
     * @returns {Promise<File>} Promise mit der heruntergeladenen Datei (im Browser-Kontext)
     *
     * @example
     * // Im Browser:
     * try {
     *   const file = await client.downloadIntegrationPackage('MyPackageId');
     *   const url = URL.createObjectURL(file);
     *   const a = document.createElement('a');
     *   a.href = url;
     *   a.download = 'MyPackageId.zip';
     *   document.body.appendChild(a);
     *   a.click();
     *   window.URL.revokeObjectURL(url);
     *   document.body.removeChild(a);
     * } catch (error) {
     *   console.error('Download failed:', error);
     * }
     */
    downloadIntegrationPackage(packageId: string): Promise<File>;
    /**
     * Speichert einen Integrationsflow unter einer neuen Version.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} newVersion Die neue Versionsnummer (z.B. '1.0.1')
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die neue Version gespeichert wurde
     *
     * @example
     * await client.saveIntegrationFlowAsVersion('MyFlowId', '1.0.1');
     */
    saveIntegrationFlowAsVersion(flowId: string, newVersion: string): Promise<void>;
    /**
     * Gibt ein spezifisches deploytes Integrationsartefakt anhand seiner ID zurück.
     *
     * @param {string} artifactId ID des deployten Artefakts
     * @returns {Promise<ComSapHciApiIntegrationRuntimeArtifact | undefined>} Promise mit dem Runtime-Artefakt oder undefined, wenn nicht gefunden.
     *
     * @example
     * const artifact = await client.getDeployedArtifactById('MyDeployedFlow');
     * if (artifact) {
     *   console.log(`Status of ${artifact.Name}: ${artifact.Status}`);
     * }
     */
    getDeployedArtifactById(artifactId: string): Promise<ComSapHciApiIntegrationRuntimeArtifact | undefined>;
    /**
     * Gibt die Anzahl der Service-Endpoints von deployten Integrationsflows zurück.
     *
     * @param {string} [filter] Optionaler OData-Filterausdruck
     * @returns {Promise<number>} Promise mit der Anzahl der Service-Endpoints
     *
     * @example
     * const count = await client.getServiceEndpointCount("Protocol eq 'SOAP'");
     * console.log(`Number of SOAP endpoints: ${count}`);
     */
    getServiceEndpointCount(filter?: string): Promise<number>;
    /**
     * Gibt den Build- und Deploy-Status für eine bestimmte Task-ID zurück.
     *
     * @param {string} taskId Die ID des Build/Deploy-Tasks
     * @returns {Promise<ComSapHciApiBuildAndDeployStatus['d'] | undefined>} Promise mit dem Status-Objekt oder undefined.
     *
     * @example
     * const status = await client.getBuildAndDeployStatus('task123');
     * if (status) {
     *   console.log(`Task ${status.TaskId} status: ${status.Status}`);
     * }
     */
    getBuildAndDeployStatus(taskId: string): Promise<ComSapHciApiBuildAndDeployStatus['d'] | undefined>;
    /**
     * Gibt alle Message Mappings (tenant-weit) direkt vom globalen Endpunkt zurück.
     * Dies ist eine interne Hilfsmethode für den Advanced Client.
     *
     * @internal
     * @returns {Promise<ComSapHciApiMessageMappingDesigntimeArtifact[]>} Promise mit einer Liste von Message Mappings
     */
    _fetchAllMessageMappingsFromGlobalEndpoint(): Promise<ComSapHciApiMessageMappingDesigntimeArtifact[]>;
    /**
     * Gibt alle Message Mappings (tenant-weit) zurück.
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Mappings
     * @param {number} [options.skip] Anzahl der zu überspringenden Mappings
     * @param {string} [options.select] Zu selektierende Properties
     * @param {string} [options.orderby] Sortierreihenfolge
     * @returns {Promise<ComSapHciApiMessageMappingDesigntimeArtifact[]>} Promise mit einer Liste von Message Mappings
     *
     * @example
     * const allMappings = await client.getAllMessageMappings({ top: 50 });
     *
     * @deprecated Diese Methode wird in zukünftigen Versionen ausgelagert. Bitte verwenden Sie die entsprechenden Methoden im IntegrationContentAdvancedClient.
     */
    getAllMessageMappings(options?: {
        top?: number;
        skip?: number;
        select?: ("Id" | "Version" | "PackageId" | "Name" | "Description" | "ArtifactContent")[];
        orderby?: ("Name" | "Name desc")[];
        packages?: ComSapHciApiIntegrationPackage[];
    }): Promise<ComSapHciApiMessageMappingDesigntimeArtifact[]>;
    /**
     * Erstellt/lädt ein neues Message Mapping hoch.
     *
     * @param {ComSapHciApiMessageMappingDesigntimeArtifactCreate} mappingData Daten des zu erstellenden Mappings
     * @returns {Promise<ComSapHciApiMessageMappingDesigntimeArtifact | undefined>} Promise mit dem erstellten Mapping
     *
     * @example
     * const newMapping = await client.createMessageMapping({
     *   Id: 'MyNewMapping',
     *   Name: 'My New Mapping',
     *   PackageId: 'MyPackageId',
     *   Description: 'Mapping Description',
     *   ArtifactContent: 'base64encodedZipContent' // Base64 kodierter ZIP-Inhalt
     * });
     */
    createMessageMapping(mappingData: ComSapHciApiMessageMappingDesigntimeArtifactCreate): Promise<ComSapHciApiMessageMappingDesigntimeArtifact | undefined>;
    /**
     * Gibt alle Value Mappings (tenant-weit) direkt vom globalen Endpunkt zurück.
     * Dies ist eine interne Hilfsmethode für den Advanced Client.
     *
     * @internal
     * @returns {Promise<ComSapHciApiValueMappingDesigntimeArtifact[]>} Promise mit einer Liste von Value Mappings
     */
    _fetchAllValueMappingsFromGlobalEndpoint(): Promise<ComSapHciApiValueMappingDesigntimeArtifact[]>;
    /**
     * Gibt alle Value Mappings (tenant-weit) zurück.
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Mappings
     * @param {number} [options.skip] Anzahl der zu überspringenden Mappings
     * @param {string} [options.select] Zu selektierende Properties
     * @param {string} [options.orderby] Sortierreihenfolge
     * @returns {Promise<ComSapHciApiValueMappingDesigntimeArtifact[]>} Promise mit einer Liste von Value Mappings
     *
     * @example
     * const allValueMappings = await client.getAllValueMappings({ top: 20 });
     */
    getAllValueMappings(options?: {
        top?: number;
        skip?: number;
        select?: ("Id" | "Version" | "PackageId" | "Name" | "Description" | "ArtifactContent")[];
        orderby?: ("Name" | "Name desc")[];
        packages?: ComSapHciApiIntegrationPackage[];
    }): Promise<ComSapHciApiValueMappingDesigntimeArtifact[]>;
    /**
     * Erstellt/lädt ein neues Value Mapping hoch.
     *
     * @param {ComSapHciApiValueMappingDesigntimeArtifactCreate} mappingData Daten des zu erstellenden Mappings
     * @returns {Promise<ComSapHciApiValueMappingDesigntimeArtifact | undefined>} Promise mit dem erstellten Mapping
     *
     * @example
     * const newMapping = await client.createValueMapping({
     *   Id: 'MyNewValueMap',
     *   Name: 'My New Value Map',
     *   PackageId: 'MyPackageId',
     *   Description: 'Value Map Description',
     *   ArtifactContent: 'base64encodedZipContent' // Base64 kodierter ZIP-Inhalt
     * });
     */
    createValueMapping(mappingData: ComSapHciApiValueMappingDesigntimeArtifactCreate): Promise<ComSapHciApiValueMappingDesigntimeArtifact | undefined>;
    /**
     * Gibt alle Value Mapping Schemas (Agency Identifiers) für ein Value Mapping zurück.
     *
     * @param {string} mappingId ID des Value Mappings
     * @param {string} [version='active'] Version des Value Mappings
     * @param {string} [filter] OData-Filterausdruck (z.B. "State eq 'Configured'")
     * @returns {Promise<ComSapHciApiValMapSchema[]>} Promise mit einer Liste von Schemas
     *
     * @example
     * const schemas = await client.getValueMappingSchemas('MyValueMapId');
     * const configuredSchemas = await client.getValueMappingSchemas('MyValueMapId', 'active', "State eq 'Configured'");
     */
    getValueMappingSchemas(mappingId: string, version?: string, filter?: string): Promise<ComSapHciApiValMapSchema[]>;
    /**
     * Gibt alle Value Mappings für ein spezifisches Schema (Agency Identifiers) zurück.
     *
     * @param {string} mappingId ID des Value Mappings
     * @param {string} version Version des Value Mappings
     * @param {string} srcAgency Source Agency
     * @param {string} srcId Source ID
     * @param {string} tgtAgency Target Agency
     * @param {string} tgtId Target ID
     * @param {string} [filter] OData-Filterausdruck (z.B. "Value/SrcValue eq 'SourceVal' and Value/TgtValue eq 'TargetVal'")
     * @returns {Promise<ComSapHciApiValMaps[]>} Promise mit einer Liste von Mappings für das Schema
     *
     * @example
     * const schemaMappings = await client.getValueMappingsForSchema(
     *   'MyValueMapId', 'active', 'SourceAgency', 'SrcID1', 'TargetAgency', 'TgtID1'
     * );
     */
    getValueMappingsForSchema(mappingId: string, version: string, srcAgency: string, srcId: string, tgtAgency: string, tgtId: string, filter?: string): Promise<ComSapHciApiValMaps[]>;
    /**
     * Gibt alle Default Value Mappings für ein spezifisches Schema (Agency Identifiers) zurück.
     *
     * @param {string} mappingId ID des Value Mappings
     * @param {string} version Version des Value Mappings
     * @param {string} srcAgency Source Agency
     * @param {string} srcId Source ID
     * @param {string} tgtAgency Target Agency
     * @param {string} tgtId Target ID
     * @returns {Promise<ComSapHciApiValMaps[]>} Promise mit einer Liste von Default Mappings für das Schema
     *
     * @example
     * const defaultMappings = await client.getDefaultValueMappingsForSchema(
     *   'MyValueMapId', 'active', 'SourceAgency', 'SrcID1', 'TargetAgency', 'TgtID1'
     * );
     */
    getDefaultValueMappingsForSchema(mappingId: string, version: string, srcAgency: string, srcId: string, tgtAgency: string, tgtId: string): Promise<ComSapHciApiValMaps[]>;
    /**
     * Deployed ein Value Mapping.
     *
     * @param {string} mappingId ID des zu deployenden Mappings
     * @param {string} [version='active'] Version des Mappings
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn das Deployment gestartet wurde
     *
     * @example
     * await client.deployValueMapping('MyValueMapId');
     */
    deployValueMapping(mappingId: string, version?: string): Promise<void>;
    /**
     * Speichert ein Value Mapping unter einer neuen Version.
     *
     * @param {string} mappingId ID des Value Mappings
     * @param {string} newVersion Die neue Versionsnummer (z.B. '1.0.1')
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die neue Version gespeichert wurde
     *
     * @example
     * await client.saveValueMappingAsVersion('MyValueMapId', '1.0.1');
     */
    saveValueMappingAsVersion(mappingId: string, newVersion: string): Promise<void>;
    /**
     * Erstellt oder aktualisiert einen Eintrag (Value Pair) in einem Value Mapping.
     *
     * @param {string} mappingId ID des Value Mappings
     * @param {string} version Version des Value Mappings
     * @param {string} srcAgency Source Agency
     * @param {string} srcId Source ID
     * @param {string} tgtAgency Target Agency
     * @param {string} tgtId Target ID
     * @param {string} srcValue Source Value
     * @param {string} tgtValue Target Value
     * @param {boolean} isConfigured Gibt an, ob das Schema konfiguriert ist
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn der Eintrag erstellt/aktualisiert wurde
     *
     * @example
     * await client.upsertValueMappingEntry(
     *   'MyValueMapId', 'active', 'AgencyA', 'ID1', 'AgencyB', 'ID2',
     *   'SourceVal1', 'TargetVal1', true
     * );
     */
    upsertValueMappingEntry(mappingId: string, version: string, srcAgency: string, srcId: string, tgtAgency: string, tgtId: string, srcValue: string, tgtValue: string, isConfigured: boolean): Promise<void>;
    /**
     * Aktualisiert den Default-Eintrag für ein Value Mapping Schema.
     *
     * @param {string} mappingId ID des Value Mappings
     * @param {string} version Version des Value Mappings
     * @param {string} srcAgency Source Agency
     * @param {string} srcId Source ID
     * @param {string} tgtAgency Target Agency
     * @param {string} tgtId Target ID
     * @param {string} valMapId ID des Value Mappings (ValMaps entry ID)
     * @param {boolean} isConfigured Gibt an, ob das Schema konfiguriert ist
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn der Default-Eintrag aktualisiert wurde
     *
     * @example
     * await client.updateDefaultValueMappingEntry(
     *   'MyValueMapId', 'active', 'AgencyA', 'ID1', 'AgencyB', 'ID2', 'valMapEntry123', true
     * );
     */
    updateDefaultValueMappingEntry(mappingId: string, version: string, srcAgency: string, srcId: string, tgtAgency: string, tgtId: string, valMapId: string, isConfigured: boolean): Promise<void>;
    /**
     * Löscht ein Value Mapping Schema (Code List Mapping) inklusive aller zugehörigen Einträge.
     *
     * @param {string} mappingId ID des Value Mappings
     * @param {string} version Version des Value Mappings
     * @param {string} srcAgency Source Agency
     * @param {string} srcId Source ID
     * @param {string} tgtAgency Target Agency
     * @param {string} tgtId Target ID
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn das Schema gelöscht wurde
     *
     * @example
     * await client.deleteValueMappingSchema(
     *   'MyValueMapId', 'active', 'AgencyA', 'ID1', 'AgencyB', 'ID2'
     * );
     */
    deleteValueMappingSchema(mappingId: string, version: string, srcAgency: string, srcId: string, tgtAgency: string, tgtId: string): Promise<void>;
    /**
     * Gibt alle Script Collections für ein bestimmtes Paket zurück.
     *
     * @param {string} packageId ID des Integrationspakets
     * @returns {Promise<ComSapHciApiScriptCollectionDesigntimeArtifact[]>} Promise mit einer Liste von Script Collections
     *
     * @example
     * const scripts = await client.getScriptCollections('MyPackageId');
     */
    getScriptCollections(packageId: string): Promise<ComSapHciApiScriptCollectionDesigntimeArtifact[]>;
    /**
     * Erstellt/lädt eine neue Script Collection hoch.
     *
     * @param {ComSapHciApiScriptCollectionDesigntimeArtifactCreate} scriptData Daten der zu erstellenden Script Collection
     * @returns {Promise<ComSapHciApiScriptCollectionDesigntimeArtifact | undefined>} Promise mit der erstellten Script Collection
     *
     * @example
     * const newScript = await client.createScriptCollection({
     *   Id: 'MyNewScriptCollection',
     *   Name: 'My New Script Collection',
     *   PackageId: 'MyPackageId',
     *   ArtifactContent: 'base64encodedZipContent' // Base64 kodierter ZIP-Inhalt
     * });
     */
    createScriptCollection(scriptData: ComSapHciApiScriptCollectionDesigntimeArtifactCreate): Promise<ComSapHciApiScriptCollectionDesigntimeArtifact | undefined>;
    /**
     * Gibt eine bestimmte Script Collection anhand ihrer ID und Version zurück.
     *
     * @param {string} scriptId ID der Script Collection
     * @param {string} [version='active'] Version der Script Collection
     * @returns {Promise<ComSapHciApiScriptCollectionDesigntimeArtifact | undefined>} Promise mit der Script Collection
     *
     * @example
     * const script = await client.getScriptCollectionById('MyScriptCollectionId', '1.1.0');
     */
    getScriptCollectionById(scriptId: string, version?: string): Promise<ComSapHciApiScriptCollectionDesigntimeArtifact | undefined>;
    /**
     * Aktualisiert eine vorhandene Script Collection.
     *
     * @param {string} scriptId ID der zu aktualisierenden Script Collection
     * @param {string} version Version der zu aktualisierenden Script Collection
     * @param {ComSapHciApiScriptCollectionDesigntimeArtifactUpdate} scriptData Die zu aktualisierenden Daten
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die Script Collection aktualisiert wurde
     *
     * @example
     * await client.updateScriptCollection('MyScriptCollectionId', '1.1.0', {
     *   Name: 'Updated Script Collection Name',
     *   ArtifactContent: 'newBase64encodedZipContent'
     * });
     */
    updateScriptCollection(scriptId: string, version: string, scriptData: ComSapHciApiScriptCollectionDesigntimeArtifactUpdate): Promise<void>;
    /**
     * Löscht eine Script Collection anhand ihrer ID und Version.
     *
     * @param {string} scriptId ID der zu löschenden Script Collection
     * @param {string} version Version der zu löschenden Script Collection
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die Script Collection gelöscht wurde
     *
     * @example
     * await client.deleteScriptCollection('MyScriptCollectionId', '1.1.0');
     */
    deleteScriptCollection(scriptId: string, version: string): Promise<void>;
    /**
     * Lädt eine Script Collection als ZIP-Datei herunter.
     *
     * Der Rückgabetyp `File` ist primär für Browser-Umgebungen relevant. In Node.js
     * müsste die Response anders behandelt werden (z.B. als Stream oder Buffer).
     *
     * @param {string} scriptId ID der herunterzuladenden Script Collection
     * @param {string} [version='active'] Version der herunterzuladenden Script Collection
     * @returns {Promise<File>} Promise mit der heruntergeladenen Datei (im Browser-Kontext)
     *
     * @example
     * // Im Browser:
     * try {
     *   const file = await client.downloadScriptCollection('MyScriptCollectionId');
     *   // ... (Code zum Speichern der Datei)
     * } catch (error) {
     *   console.error('Download failed:', error);
     * }
     */
    downloadScriptCollection(scriptId: string, version?: string): Promise<File>;
    /**
     * Deployed eine Script Collection.
     *
     * @param {string} scriptId ID der zu deployenden Script Collection
     * @param {string} [version='active'] Version der Script Collection
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn das Deployment gestartet wurde
     *
     * @example
     * await client.deployScriptCollection('MyScriptCollectionId');
     */
    deployScriptCollection(scriptId: string, version?: string): Promise<void>;
    /**
     * Speichert eine Script Collection unter einer neuen Version.
     *
     * @param {string} scriptId ID der Script Collection
     * @param {string} newVersion Die neue Versionsnummer (z.B. '1.0.1')
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die neue Version gespeichert wurde
     *
     * @example
     * await client.saveScriptCollectionAsVersion('MyScriptCollectionId', '1.0.1');
     */
    saveScriptCollectionAsVersion(scriptId: string, newVersion: string): Promise<void>;
    /**
     * Fügt eine Ressource zu einer Script Collection hinzu.
     *
     * @param {string} scriptId ID der Script Collection
     * @param {string} version Version der Script Collection
     * @param {ComSapHciApiResourceCreate} resourceData Daten der hinzuzufügenden Ressource (Name, ResourceType, ResourceContent)
     * @returns {Promise<ComSapHciApiResource | undefined>} Promise mit der hinzugefügten Ressource
     *
     * @example
     * const resource = await client.addScriptCollectionResource('MyScriptId', 'active', {
     *   Name: 'myScript.groovy',
     *   ResourceType: 'groovy',
     *   ResourceContent: 'base64EncodedScriptContent'
     * });
     */
    addScriptCollectionResource(scriptId: string, version: string, resourceData: ComSapHciApiResourceCreate): Promise<ComSapHciApiResource | undefined>;
    /**
     * Aktualisiert eine Ressource innerhalb einer Script Collection.
     *
     * @param {string} scriptId ID der Script Collection
     * @param {string} version Version der Script Collection
     * @param {string} resourceName Name der zu aktualisierenden Ressource
     * @param {string} resourceType Typ der zu aktualisierenden Ressource ('groovy', 'jar', 'js')
     * @param {ComSapHciApiResourceUpdate} resourceUpdate Daten für das Update (nur ResourceContent)
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die Ressource aktualisiert wurde
     *
     * @example
     * await client.updateScriptCollectionResource(
     *   'MyScriptId', 'active', 'myScript.groovy', 'groovy',
     *   { ResourceContent: 'newBase64EncodedScriptContent' }
     * );
     */
    updateScriptCollectionResource(scriptId: string, version: string, resourceName: string, resourceType: 'groovy' | 'jar' | 'js', resourceUpdate: ComSapHciApiResourceUpdate): Promise<void>;
    /**
     * Löscht eine Ressource aus einer Script Collection.
     *
     * @param {string} scriptId ID der Script Collection
     * @param {string} version Version der Script Collection
     * @param {string} resourceName Name der zu löschenden Ressource
     * @param {string} resourceType Typ der zu löschenden Ressource ('groovy', 'jar', 'js')
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die Ressource gelöscht wurde
     *
     * @example
     * await client.deleteScriptCollectionResource('MyScriptId', 'active', 'oldScript.jar', 'jar');
     */
    deleteScriptCollectionResource(scriptId: string, version: string, resourceName: string, resourceType: 'groovy' | 'jar' | 'js'): Promise<void>;
    /**
     * Gibt alle Ressourcen für einen bestimmten Integrationsflow und Version zurück.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} [version='active'] Version des Integrationsflows
     * @param {Object} options Optionale OData-Query-Parameter ($filter, $select, $orderby)
     * @returns {Promise<ComSapHciApiResource[]>} Promise mit einer Liste von Ressourcen
     *
     * @example
     * const resources = await client.getIntegrationFlowResources('MyFlowId');
     * const wsdlResources = await client.getIntegrationFlowResources('MyFlowId', 'active', {
     *   $filter: "ResourceType eq 'wsdl'"
     * });
     */
    getIntegrationFlowResources(flowId: string, version?: string, options?: {
        $filter?: string;
        $select?: ("Name" | "ResourceType" | "ReferencedResourceType")[];
        $orderby?: ("Name" | "Name desc" | "ResourceType" | "ResourceType desc" | "Name,ResourceType" | "Name desc,ResourceType desc")[];
    }): Promise<ComSapHciApiResource[]>;
    /**
     * Fügt eine Ressource zu einem Integrationsflow hinzu.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} version Version des Integrationsflows
     * @param {ComSapHciApiResourceCreate} resourceData Daten der hinzuzufügenden Ressource
     * @returns {Promise<ComSapHciApiResource | undefined>} Promise mit der hinzugefügten Ressource
     *
     * @example
     * const newResource = await client.addIntegrationFlowResource('MyFlowId', '1.0.0', {
     *   Name: 'mySchema.xsd',
     *   ResourceType: 'xsd',
     *   ResourceContent: 'base64EncodedSchemaContent'
     * });
     */
    addIntegrationFlowResource(flowId: string, version: string, resourceData: ComSapHciApiResourceCreate): Promise<ComSapHciApiResource | undefined>;
    /**
     * Gibt die Anzahl der Ressourcen für einen bestimmten Integrationsflow zurück.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} [version='active'] Version des Integrationsflows
     * @param {string} [filter] Optionaler OData-Filterausdruck
     * @returns {Promise<number>} Promise mit der Anzahl der Ressourcen
     *
     * @example
     * const resourceCount = await client.getIntegrationFlowResourceCount('MyFlowId');
     */
    getIntegrationFlowResourceCount(flowId: string, version?: string, filter?: string): Promise<number>;
    /**
     * Gibt eine spezifische Ressource eines Integrationsflows zurück.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} version Version des Integrationsflows
     * @param {string} resourceName Name der Ressource
     * @param {string[]} resourceType Typ der Ressource (als Array, z.B. ['xsd'])
     * @param {'wsdl'[]} [referencedResourceType] Referenzierter Ressourcentyp (nur für XSD -> WSDL)
     * @returns {Promise<ComSapHciApiResource | undefined>} Promise mit der Ressource
     *
     * @example
     * const resource = await client.getIntegrationFlowResource('MyFlowId', 'active', 'mySchema.xsd', ['xsd']);
     */
    getIntegrationFlowResource(flowId: string, version: string, resourceName: string, resourceType: ("edmx" | "groovy" | "jar" | "js" | "mmap" | "opmap" | "wsdl" | "xsd" | "xslt")[], referencedResourceType?: 'wsdl'[]): Promise<ComSapHciApiResource | undefined>;
    /**
     * Lädt den Inhalt einer spezifischen Ressource eines Integrationsflows herunter.
     *
     * Der Rückgabetyp ist `void`, da der generierte Client hier `void` zurückgibt.
     * In der Praxis müsste man die Response (Stream/Buffer) vermutlich anders verarbeiten,
     * um an den Inhalt zu kommen. Ggf. muss der generierte Client angepasst werden.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} version Version des Integrationsflows
     * @param {string} resourceName Name der Ressource
     * @param {string[]} resourceType Typ der Ressource (als Array)
     * @param {'wsdl'[]} [referencedResourceType] Referenzierter Ressourcentyp
     * @returns {Promise<void>} Promise
     *
     * @example
     * // ACHTUNG: Rückgabetyp ist void, Inhalt muss ggf. anders extrahiert werden.
     * await client.downloadIntegrationFlowResource('MyFlowId', 'active', 'myScript.groovy', ['groovy']);
     */
    downloadIntegrationFlowResource(flowId: string, version: string, resourceName: string, resourceType: ("edmx" | "groovy" | "jar" | "js" | "mmap" | "opmap" | "wsdl" | "xsd" | "xslt")[], referencedResourceType?: 'wsdl'[]): Promise<void>;
    /**
     * Aktualisiert den Inhalt einer Ressource innerhalb eines Integrationsflows.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} version Version des Integrationsflows
     * @param {string} resourceName Name der zu aktualisierenden Ressource
     * @param {string[]} resourceType Typ der zu aktualisierenden Ressource (als Array)
     * @param {ComSapHciApiResourceUpdate} resourceUpdate Daten für das Update (nur ResourceContent)
     * @param {'wsdl'[]} [referencedResourceType] Referenzierter Ressourcentyp
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die Ressource aktualisiert wurde
     *
     * @example
     * await client.updateIntegrationFlowResource(
     *   'MyFlowId', 'active', 'myScript.groovy', ['groovy'],
     *   { ResourceContent: 'newBase64EncodedScriptContent' }
     * );
     */
    updateIntegrationFlowResource(flowId: string, version: string, resourceName: string, resourceType: ("edmx" | "groovy" | "jar" | "js" | "mmap" | "opmap" | "wsdl" | "xsd" | "xslt")[], resourceUpdate: ComSapHciApiResourceUpdate, referencedResourceType?: 'wsdl'[]): Promise<void>;
    /**
     * Löscht eine Ressource aus einem Integrationsflow.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} version Version des Integrationsflows
     * @param {string} resourceName Name der zu löschenden Ressource
     * @param {string[]} resourceType Typ der zu löschenden Ressource (als Array)
     * @param {'wsdl'[]} [referencedResourceType] Referenzierter Ressourcentyp
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die Ressource gelöscht wurde
     *
     * @example
     * await client.deleteIntegrationFlowResource('MyFlowId', 'active', 'oldSchema.xsd', ['xsd']);
     */
    deleteIntegrationFlowResource(flowId: string, version: string, resourceName: string, resourceType: ("edmx" | "groovy" | "jar" | "js" | "mmap" | "opmap" | "wsdl" | "xsd" | "xslt")[], referencedResourceType?: 'wsdl'[]): Promise<void>;
    /**
     * Kopiert ein Integrationspaket aus dem 'Discover'-Bereich in den 'Design'-Bereich.
     *
     * @param {string} packageId ID des zu kopierenden Pakets
     * @param {'CREATE_COPY' | 'OVERWRITE' | 'OVERWRITE_MERGE'} [importMode='CREATE_COPY'] Importmodus
     * @param {string} [suffix] Suffix für Name/ID, falls ImportMode='CREATE_COPY' und Paket existiert
     * @returns {Promise<ComSapHciApiIntegrationPackage | undefined>} Das kopierte oder erstellte Paket
     *
     * @example
     * // Paket kopieren, überschreiben falls vorhanden
     * const copiedPackage = await client.copyIntegrationPackage('StandardPackageId', 'OVERWRITE');
     *
     * // Kopie mit Suffix erstellen
     * const copiedPackageWithSuffix = await client.copyIntegrationPackage('StandardPackageId', 'CREATE_COPY', 'MySuffix');
     */
    copyIntegrationPackage(packageId: string, importMode?: "'CREATE_COPY'" | "'OVERWRITE'" | "'OVERWRITE_MERGE'", suffix?: string): Promise<ComSapHciApiIntegrationPackage | undefined>;
    /**
     * Gibt die Custom Tags für ein bestimmtes Integrationspaket zurück.
     *
     * @param {string} packageId ID des Integrationspakets
     * @param {Object} options Optionale OData-Query-Parameter ($top, $skip, $orderby)
     * @returns {Promise<any[]>} Promise mit einer Liste von Custom Tags (Typ ist unspezifisch, da API 'void' zurückgibt)
     *
     * @example
     * const tags = await client.getCustomTagsForPackage('MyPackageId');
     */
    getCustomTagsForPackage(packageId: string, options?: {
        top?: number;
        skip?: number;
        orderby?: ("Name" | "Name desc")[];
    }): Promise<any[]>;
    /**
     * Aktualisiert den Wert eines Custom Tags für ein Integrationspaket.
     *
     * @param {string} packageId ID des Integrationspakets
     * @param {string} tagName Name des Custom Tags
     * @param {string} value Neuer Wert für das Custom Tag
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn das Tag aktualisiert wurde
     *
     * @example
     * await client.updateCustomTagForPackage('MyPackageId', 'Author', 'New Author');
     */
    updateCustomTagForPackage(packageId: string, tagName: string, value: string): Promise<void>;
    /**
     * Gibt die globale Custom Tag Konfiguration zurück.
     *
     * @returns {Promise<ComSapHciApiCustomTagsConfiguration['customTagsConfiguration'] | undefined>} Promise mit der Konfiguration
     *
     * @example
     * const config = await client.getCustomTagsConfiguration();
     * if (config) {
     *   config.forEach(tag => console.log(tag.tagName, tag.isMandatory));
     * }
     */
    getCustomTagsConfiguration(): Promise<ComSapHciApiCustomTagsConfiguration['customTagsConfiguration'] | undefined>;
    /**
     * Lädt eine neue globale Custom Tag Konfiguration hoch.
     *
     * @param {ComSapHciApiCustomTagsConfigurationCreate} configData Die hochzuladende Konfiguration (Base64-kodierter JSON-String)
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die Konfiguration hochgeladen wurde
     *
     * @example
     * const configJson = JSON.stringify({
     *   customTagsConfiguration: [ { tagName: 'NewTag', isMandatory: false } ]
     * });
     * const base64Config = Buffer.from(configJson).toString('base64url'); // Node.js Beispiel
     * await client.uploadCustomTagsConfiguration({ customTagsConfiguration: base64Config });
     */
    uploadCustomTagsConfiguration(configData: ComSapHciApiCustomTagsConfigurationCreate): Promise<void>;
    /**
     * Führt die Design Guideline Prüfung für einen Integrationsflow aus.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} [version='active'] Version des Integrationsflows
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die Ausführung gestartet wurde
     *
     * @example
     * await client.executeDesignGuidelines('MyFlowId');
     */
    executeDesignGuidelines(flowId: string, version?: string): Promise<void>;
    /**
     * Gibt die Ausführungsergebnisse der Design Guidelines für einen Integrationsflow zurück.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} [version='active'] Version des Integrationsflows
     * @returns {Promise<ComSapHciApiDesignGuidlineExecutionResult[]>} Promise mit einer Liste von Ausführungsergebnissen // Reverted to use the type with typo
     *
     * @example
     * const results = await client.getDesignGuidelineExecutionResults('MyFlowId');
     * results.forEach(result => console.log(`Execution ${result.ExecutionId}: ${result.ExecutionStatus}`));
     */
    getDesignGuidelineExecutionResults(flowId: string, version?: string): Promise<ComSapHciApiDesignGuidlineExecutionResult[]>;
    /**
     * Gibt ein spezifisches Ausführungsergebnis der Design Guidelines zurück.
     *
     * Hinweis: Der generierte Client hat hier eine doppelte Methode `designGuidelineExecutionResultsList2`.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} version Version des Integrationsflows
     * @param {string} executionId ID der Ausführung
     * @param {boolean} [expandDesignGuidelines=false] Ob die Details der Guidelines mitgeladen werden sollen
     * @returns {Promise<ComSapHciApiDesignGuidlineExecutionResult | undefined>} Promise mit dem Ausführungsergebnis // Reverted to use the type with typo
     *
     * @example
     * const result = await client.getDesignGuidelineExecutionResultById('MyFlowId', 'active', 'exec123', true);
     */
    getDesignGuidelineExecutionResultById(flowId: string, version: string, executionId: string, expandDesignGuidelines?: boolean): Promise<ComSapHciApiDesignGuidlineExecutionResult | undefined>;
    /**
     * Lädt den Report eines Design Guideline Ausführungsergebnisses herunter.
     *
     * Der Rückgabetyp `File` ist primär für Browser-Umgebungen relevant. In Node.js
     * müsste die Response anders behandelt werden (z.B. als Stream oder Buffer).
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} version Version des Integrationsflows
     * @param {string} executionId ID der Ausführung
     * @param {string} [reportType] Typ des Reports (z.B. 'pdf')
     * @returns {Promise<File>} Promise mit der heruntergeladenen Datei
     *
     * @example
     * try {
     *   const reportFile = await client.downloadDesignGuidelineExecutionReport('MyFlowId', 'active', 'exec123', 'pdf');
     *   // ... (Code zum Speichern der Datei)
     * } catch (error) {
     *   console.error('Download failed:', error);
     * }
     */
    downloadDesignGuidelineExecutionReport(flowId: string, version: string, executionId: string, reportType?: string): Promise<File>;
    /**
     * Überspringt eine Design Guideline oder macht das Überspringen rückgängig.
     *
     * @param {string} flowId ID des Integrationsflows
     * @param {string} version Version des Integrationsflows
     * @param {string} executionId ID der Ausführung
     * @param {ComSapHciApiDesignGuidelineExecutionResultsSkip} skipData Daten zum Überspringen/Rückgängigmachen
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn die Aktion ausgeführt wurde
     *
     * @example
     * // Guideline überspringen
     * await client.skipOrRevertDesignGuideline('MyFlowId', 'active', 'exec123', {
     *   GudelineId: 'Guideline1', // Beachte Typo in API GudelineId
     *   IsGuidelineSkipped: true,
     *   SkipReason: 'Not applicable'
     * });
     *
     * // Überspringen rückgängig machen
     * await client.skipOrRevertDesignGuideline('MyFlowId', 'active', 'exec123', {
     *   GudelineId: 'Guideline1',
     *   IsGuidelineSkipped: false
     * });
     */
    skipOrRevertDesignGuideline(flowId: string, version: string, executionId: string, skipData: ComSapHciApiDesignGuidelineExecutionResultsSkip): Promise<void>;
    /**
     * Gibt die Anzahl aller deployten Integrationsartefakte zurück.
     *
     * @param {string} [filter] Optionaler OData-Filterausdruck
     * @returns {Promise<number>} Promise mit der Anzahl der deployten Artefakte
     *
     * @example
     * const totalDeployed = await client.getDeployedArtifactCount();
     * const errorCount = await client.getDeployedArtifactCount("Status eq 'ERROR'");
     */
    getDeployedArtifactCount(filter?: string): Promise<number>;
    /**
     * Importiert einen Integrationsadapter (.esa Datei).
     * Nur in Cloud Foundry verfügbar.
     *
     * @param {ComSapHciApiIntegrationAdapterDesigntimeArtifactImport} adapterData Importdaten (PackageId, ArtifactContent)
     * @returns {Promise<ComSapHciApiIntegrationAdapterDesigntimeArtifact | undefined>} Promise mit dem importierten Adapter
     *
     * @example
     * const adapter = await client.importIntegrationAdapter({
     *   PackageId: 'MyAdapterPackage',
     *   ArtifactContent: 'base64EncodedEsaContent'
     * });
     */
    importIntegrationAdapter(adapterData: ComSapHciApiIntegrationAdapterDesigntimeArtifactImport): Promise<ComSapHciApiIntegrationAdapterDesigntimeArtifact | undefined>;
    /**
     * Deployed einen Integrationsadapter.
     * Nur in Cloud Foundry verfügbar.
     *
     * @param {string} adapterId ID des zu deployenden Adapters
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn das Deployment gestartet wurde
     *
     * @example
     * await client.deployIntegrationAdapter('MyCustomAdapterId');
     */
    deployIntegrationAdapter(adapterId: string): Promise<void>;
    /**
     * Löscht einen Integrationsadapter.
     * Nur in Cloud Foundry verfügbar.
     *
     * @param {string} adapterId ID des zu löschenden Adapters
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn der Adapter gelöscht wurde
     *
     * @example
     * await client.deleteIntegrationAdapter('MyCustomAdapterId');
     */
    deleteIntegrationAdapter(adapterId: string): Promise<void>;
    /**
     * Ruft das Delta Token für den MDI Receiver Adapter ab.
     *
     * @param {string} operation Operation (z.B. 'READ')
     * @param {string} entity Entität (z.B. 'BusinessPartner')
     * @param {string} version Version (z.B. '1.0')
     * @returns {Promise<ComSapHciApiMDIDeltaToken['d'] | undefined>} Promise mit den Delta Token Informationen
     *
     * @example
     * const tokenInfo = await client.getMdiDeltaToken('READ', 'BusinessPartner', '1.0');
     * if (tokenInfo) {
     *   console.log('Delta Token:', tokenInfo.DeltaToken);
     * }
     */
    getMdiDeltaToken(operation: string, entity: string, version: string): Promise<ComSapHciApiMDIDeltaToken['d'] | undefined>;
    /**
     * Löscht das Delta Token für den MDI Receiver Adapter.
     *
     * @param {string} operation Operation (z.B. 'READ')
     * @param {string} entity Entität (z.B. 'BusinessPartner')
     * @param {string} version Version (z.B. '1.0')
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn das Token gelöscht wurde
     *
     * @example
     * await client.deleteMdiDeltaToken('READ', 'BusinessPartner', '1.0');
     */
    deleteMdiDeltaToken(operation: string, entity: string, version: string): Promise<void>;
    /**
     * Aktualisiert den Status eines Artefakts im Cache
     * Aktualisiert nur den Status, ohne das gesamte Package neu abzurufen
     *
     * **Wichtig**: Diese Methode aktualisiert das Artefakt in:
     * - Einzelnes Artefakt-Cache: `GET:/IntegrationRuntimeArtifacts('artifactId')`
     * - Collection-Caches: `GET:/IntegrationRuntimeArtifacts` (alle Artefakte)
     * - Package-Cache: `GET:/IntegrationPackages('packageId')` (falls packageId angegeben)
     * - Collection-Caches: `GET:/IntegrationPackages` (alle Packages)
     * - Weitere Collection-Endpunkte: `GET:/IntegrationDesigntimeArtifacts`, `GET:/MessageMappingDesigntimeArtifacts`, etc.
     *
     * Dies stellt sicher, dass beim Aufruf von Methoden wie `getDeployedArtifacts()` oder `getAllIntegrationFlows()`
     * der aktualisierte Status in den gecachten Ergebnissen reflektiert wird.
     *
     * @param {string} artifactId - Die ID des Artefakts
     * @param {ArtifactStatusUpdate} statusData - Die Status-Daten zum Aktualisieren
     * @param {string} [packageId] - Optional: Die Package-ID (wird aus Cache ermittelt falls nicht angegeben)
     * @param {string} [baseUrl] - Optional: Die Base-URL für Cache-Key-Generierung
     * @returns {Promise<void>} Promise, der aufgelöst wird, wenn das Update abgeschlossen ist
     *
     * @example
     * // Status nach Deployment aktualisieren
     * await client.updateArtifactStatus('MyArtifact', {
     *   Status: 'STARTED',
     *   DeployedBy: 'user@example.com',
     *   DeployedOn: '2024-01-01T00:00:00Z'
     * }, 'MyPackage');
     *
     * // Dies aktualisiert:
     * // - Einzelnes Artefakt-Cache: GET:/IntegrationRuntimeArtifacts('MyArtifact')
     * // - Collection-Cache: GET:/IntegrationRuntimeArtifacts (alle Artefakte)
     * // - Package-Cache: GET:/IntegrationPackages('MyPackage')
     * // - Collection-Cache: GET:/IntegrationPackages (alle Packages)
     * // - Alle anderen Collection-Caches, die dieses Artefakt enthalten
     */
    updateArtifactStatus(artifactId: string, statusData: ArtifactStatusUpdate, packageId?: string, baseUrl?: string): Promise<void>;
    /**
     * Adds an artifact to relevant collection caches
     * Finds all collection cache keys matching the patterns and adds the artifact to them
     *
     * @param artifact - The artifact to add to the cache
     * @param options - Optional configuration
     * @param options.cachePatterns - Custom cache key patterns to search (defaults to collection patterns)
     * @param options.preventDuplicates - If true, prevents adding duplicate artifacts
     * @returns The number of cache keys that were successfully updated
     *
     * @example
     * const updatedCount = await client.addArtifactToCache(newArtifact, {
     *   preventDuplicates: true
     * });
     */
    addArtifactToCache(artifact: any, options?: {
        cachePatterns?: string[];
        preventDuplicates?: boolean;
    }): Promise<number>;
    /**
     * Removes an artifact from relevant collection caches
     * Finds all collection cache keys matching the patterns and removes the artifact from them
     *
     * @param artifactId - The ID of the artifact to remove from the cache
     * @param options - Optional configuration
     * @param options.cachePatterns - Custom cache key patterns to search (defaults to collection patterns)
     * @returns The number of cache keys that were successfully updated
     *
     * @example
     * const updatedCount = await client.removeArtifactFromCache('MyArtifactId');
     */
    removeArtifactFromCache(artifactId: string, options?: {
        cachePatterns?: string[];
    }): Promise<number>;
    /**
     * Warms the cache by pre-loading frequently used endpoints
     *
     * @param options - Optional configuration for cache warming
     * @param options.endpoints - Custom endpoints to warm (array of endpoint paths like '/IntegrationPackages')
     * @param options.includePackages - Whether to include IntegrationPackages endpoint (default: true)
     * @param options.includeArtifacts - Whether to include IntegrationRuntimeArtifacts endpoint (default: true)
     * @param options.includeDesigntimeArtifacts - Whether to include IntegrationDesigntimeArtifacts endpoint (default: false)
     * @returns The number of endpoints successfully warmed
     *
     * @example
     * // Warm all standard endpoints
     * const count = await client.warmCache();
     *
     * @example
     * // Warm only packages
     * const count = await client.warmCache({ includeArtifacts: false });
     *
     * @example
     * // Warm custom endpoints
     * const count = await client.warmCache({ endpoints: ['/IntegrationPackages', '/CustomEndpoint'] });
     */
    warmCache(options?: {
        endpoints?: string[];
        includePackages?: boolean;
        includeArtifacts?: boolean;
        includeDesigntimeArtifacts?: boolean;
    }): Promise<number>;
}