@contiva/sap-integration-suite-client/dist/wrapper/integration-content-client.d.ts

SAP Cloud Platform Integration API Client

/**
 * 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
     *