@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';
/**
 * 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;
    /**
     * Erstellt einen neuen IntegrationContentClient
     *
     * @param {IntegrationContentApi<unknown>} api - Die zugrunde liegende API-Instanz
     */
    constructor(api: IntegrationContentApi<unknown>);
    /**
     * 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 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
     *
     * @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
     *
     * @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 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 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 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 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) 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) 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.copyInte