@contiva/sap-integration-suite-client
Version:
SAP Cloud Platform Integration API Client
1,015 lines (1,014 loc) • 52.6 kB
JavaScript
"use strict";
/* eslint-disable */
/* tslint:disable */
// @ts-nocheck
/*
* ---------------------------------------------------------------
* ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API ##
* ## ##
* ## AUTHOR: acacode ##
* ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
* ---------------------------------------------------------------
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.Api = exports.HttpClient = exports.ContentType = void 0;
var ContentType;
(function (ContentType) {
ContentType["Json"] = "application/json";
ContentType["FormData"] = "multipart/form-data";
ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
ContentType["Text"] = "text/plain";
})(ContentType || (exports.ContentType = ContentType = {}));
class HttpClient {
constructor(apiConfig = {}) {
this.baseUrl = "https://{Account Short Name}-tmn.{SSL Host}.{Landscapehost}/api/v1";
this.securityData = null;
this.abortControllers = new Map();
this.customFetch = (...fetchParams) => fetch(...fetchParams);
this.baseApiParams = {
credentials: "same-origin",
headers: {},
redirect: "follow",
referrerPolicy: "no-referrer",
};
this.setSecurityData = (data) => {
this.securityData = data;
};
this.contentFormatters = {
[ContentType.Json]: (input) => input !== null && (typeof input === "object" || typeof input === "string") ? JSON.stringify(input) : input,
[ContentType.Text]: (input) => (input !== null && typeof input !== "string" ? JSON.stringify(input) : input),
[ContentType.FormData]: (input) => Object.keys(input || {}).reduce((formData, key) => {
const property = input[key];
formData.append(key, property instanceof Blob
? property
: typeof property === "object" && property !== null
? JSON.stringify(property)
: `${property}`);
return formData;
}, new FormData()),
[ContentType.UrlEncoded]: (input) => this.toQueryString(input),
};
this.createAbortSignal = (cancelToken) => {
if (this.abortControllers.has(cancelToken)) {
const abortController = this.abortControllers.get(cancelToken);
if (abortController) {
return abortController.signal;
}
return void 0;
}
const abortController = new AbortController();
this.abortControllers.set(cancelToken, abortController);
return abortController.signal;
};
this.abortRequest = (cancelToken) => {
const abortController = this.abortControllers.get(cancelToken);
if (abortController) {
abortController.abort();
this.abortControllers.delete(cancelToken);
}
};
this.request = async ({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }) => {
const secureParams = ((typeof secure === "boolean" ? secure : this.baseApiParams.secure) &&
this.securityWorker &&
(await this.securityWorker(this.securityData))) ||
{};
const requestParams = this.mergeRequestParams(params, secureParams);
const queryString = query && this.toQueryString(query);
const payloadFormatter = this.contentFormatters[type || ContentType.Json];
const responseFormat = format || requestParams.format;
return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, {
...requestParams,
headers: {
...(requestParams.headers || {}),
...(type && type !== ContentType.FormData ? { "Content-Type": type } : {}),
},
signal: (cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal) || null,
body: typeof body === "undefined" || body === null ? null : payloadFormatter(body),
}).then(async (response) => {
const r = response.clone();
r.data = null;
r.error = null;
const data = !responseFormat
? r
: await response[responseFormat]()
.then((data) => {
if (r.ok) {
r.data = data;
}
else {
r.error = data;
}
return r;
})
.catch((e) => {
r.error = e;
return r;
});
if (cancelToken) {
this.abortControllers.delete(cancelToken);
}
if (!response.ok)
throw data;
return data;
});
};
Object.assign(this, apiConfig);
}
encodeQueryParam(key, value) {
const encodedKey = encodeURIComponent(key);
return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : `${value}`)}`;
}
addQueryParam(query, key) {
return this.encodeQueryParam(key, query[key]);
}
addArrayQueryParam(query, key) {
const value = query[key];
return value.map((v) => this.encodeQueryParam(key, v)).join("&");
}
toQueryString(rawQuery) {
const query = rawQuery || {};
const keys = Object.keys(query).filter((key) => "undefined" !== typeof query[key]);
return keys
.map((key) => (Array.isArray(query[key]) ? this.addArrayQueryParam(query, key) : this.addQueryParam(query, key)))
.join("&");
}
addQueryParams(rawQuery) {
const queryString = this.toQueryString(rawQuery);
return queryString ? `?${queryString}` : "";
}
mergeRequestParams(params1, params2) {
return {
...this.baseApiParams,
...params1,
...(params2 || {}),
headers: {
...(this.baseApiParams.headers || {}),
...(params1.headers || {}),
...((params2 && params2.headers) || {}),
},
};
}
}
exports.HttpClient = HttpClient;
/**
* @title Security Content
* @version 1.0.0
* @baseUrl https://{Account Short Name}-tmn.{SSL Host}.{Landscapehost}/api/v1
* @externalDocs https://help.sap.com/docs/integration-suite/sap-integration-suite/e01d3f0076384cf7b2d18adbccb067a1.html
*
* Security content enables you to get, write or delete various security content. Depending on the kind of connection, the applied authorization and authentication options, and the direction of the request (either inbound or outbound), different kind of security content needs to be created and deployed on the tenant. You can manage the floowing security content types:
* * User credentials
* * OAuth2 client credentials
* * Keystore entries
* * Certificate-to-user mappings
*
* This API is implemented based on OData version 2 specification.
* If you like to request the OData API on your tenant, you need to know how to find out the address of the HTTP call. For more information, see [HTTP Calls and URL Components](https://help.sap.com/docs/SAP_INTEGRATION_SUITE/51ab953548be4459bfe8539ecaeee98d/ca75e12fc5904d96a038aef6c00db5fc.html).
* If you face problems using the API, you can create a ticket. Check out for the right support component on this page: [Support Components](https://help.sap.com/docs/SAP_INTEGRATION_SUITE/51ab953548be4459bfe8539ecaeee98d/bd2d883ae8ee4e2696038be7741d93d7.html).
*/
class Api extends HttpClient {
constructor() {
super(...arguments);
/**
* @description You can use the following request to request the CSRF token for this session, which is required for write access via POST, PUT and DELETE operations. Copy the received X-CSRF-Token from the response header.<br> **In API sandbox this request is not relevant!**
*
* @tags CSRF Token Handling
* @name GetRoot
* @summary Get CSRF token.
* @request GET:/
* @secure
*/
this.getRoot = (params = {}) => this.request({
path: `/`,
method: "GET",
secure: true,
...params,
});
this.userCredentials = {
/**
* @description You can use the following request to get all deployed user credentials.
*
* @tags User Credentials
* @name UserCredentialsList
* @summary Get all deployed user credentials.
* @request GET:/UserCredentials
* @secure
*/
userCredentialsList: (params = {}) => this.request({
path: `/UserCredentials`,
method: "GET",
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to add user credentials.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to add user credentials.
*
* @tags User Credentials
* @name UserCredentialsCreate
* @summary Add user credentials.
* @request POST:/UserCredentials
* @secure
*/
userCredentialsCreate: (UserCredential, params = {}) => this.request({
path: `/UserCredentials`,
method: "POST",
body: UserCredential,
secure: true,
type: ContentType.Json,
...params,
}),
};
this.userCredentialsName = {
/**
* @description You can use the following request to get user credentials for a given credentials name.
*
* @tags User Credentials
* @name UserCredentialsList
* @summary Get user credentials by name.
* @request GET:/UserCredentials('{Name}')
* @secure
*/
userCredentialsList: (name, params = {}) => this.request({
path: `/UserCredentials('${name}')`,
method: "GET",
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to update user credentials.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to update user credentials.
*
* @tags User Credentials
* @name UserCredentialsUpdate
* @summary Update user credentials.
* @request PUT:/UserCredentials('{Name}')
* @secure
*/
userCredentialsUpdate: (name, UserCredential, params = {}) => this.request({
path: `/UserCredentials('${name}')`,
method: "PUT",
body: UserCredential,
secure: true,
type: ContentType.Json,
...params,
}),
/**
* @description You can use the following request to delete user credentials.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to delete user credentials.
*
* @tags User Credentials
* @name UserCredentialsDelete
* @summary Delete user credentials.
* @request DELETE:/UserCredentials('{Name}')
* @secure
*/
userCredentialsDelete: (name, params = {}) => this.request({
path: `/UserCredentials('${name}')`,
method: "DELETE",
secure: true,
...params,
}),
};
this.secureParameters = {
/**
* @description You can use the following request to get all deployed secure parameters. The response body does not contain the values for the secure parameters. You can only store the values with the OData API, but you can't retrieve the values. This resource is only available in the Neo environment.
*
* @tags Secure Parameters
* @name SecureParametersList
* @summary Get all deployed secure parameters.
* @request GET:/SecureParameters
* @secure
*/
secureParametersList: (params = {}) => this.request({
path: `/SecureParameters`,
method: "GET",
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to add secure parameters.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to add secure parameters. This resource is only available in the Neo environment.
*
* @tags Secure Parameters
* @name SecureParametersCreate
* @summary Add secure parameters.
* @request POST:/SecureParameters
* @secure
*/
secureParametersCreate: (SecureParameter, params = {}) => this.request({
path: `/SecureParameters`,
method: "POST",
body: SecureParameter,
secure: true,
type: ContentType.Json,
...params,
}),
};
this.secureParametersName = {
/**
* @description You can use the following request to get secure parameters for a artifact name. This resource is only available in the Neo environment.
*
* @tags Secure Parameters
* @name SecureParametersList
* @summary Get secure parameters by name.
* @request GET:/SecureParameters('{Name}')
* @secure
*/
secureParametersList: (name, params = {}) => this.request({
path: `/SecureParameters('${name}')`,
method: "GET",
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to update secure parameters.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to update secure parameters. There are the following length restrictions: Name: 150 characters, SecureParam: 255 characters, Description: 1024 chacracters. This resource is only available in the Neo environment.
*
* @tags Secure Parameters
* @name SecureParametersUpdate
* @summary Update secure parameters.
* @request PUT:/SecureParameters('{Name}')
* @secure
*/
secureParametersUpdate: (name, SecureParameters, params = {}) => this.request({
path: `/SecureParameters('${name}')`,
method: "PUT",
body: SecureParameters,
secure: true,
type: ContentType.Json,
...params,
}),
/**
* @description You can use the following request to delete secure parameters.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to delete secure parameters. This resource is only available in the Neo environment.
*
* @tags Secure Parameters
* @name SecureParametersDelete
* @summary Delete secure parameters.
* @request DELETE:/SecureParameters('{Name}')
* @secure
*/
secureParametersDelete: (name, params = {}) => this.request({
path: `/SecureParameters('${name}')`,
method: "DELETE",
secure: true,
...params,
}),
};
this.oAuth2ClientCredentials = {
/**
* @description You can use the following request to get all OAuth2 client credentials.
*
* @tags OAuth2 Client Credentials
* @name OAuth2ClientCredentialsList
* @summary Get all OAuth2 client credentials.
* @request GET:/OAuth2ClientCredentials
* @secure
*/
oAuth2ClientCredentialsList: (query, params = {}) => this.request({
path: `/OAuth2ClientCredentials`,
method: "GET",
query: query,
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to add OAuth2 client credentials.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to add credentials.
*
* @tags OAuth2 Client Credentials
* @name OAuth2ClientCredentialsCreate
* @summary Add OAuth2 client credentials
* @request POST:/OAuth2ClientCredentials
* @secure
*/
oAuth2ClientCredentialsCreate: (OAuth2ClientCredentials, params = {}) => this.request({
path: `/OAuth2ClientCredentials`,
method: "POST",
body: OAuth2ClientCredentials,
secure: true,
type: ContentType.Json,
...params,
}),
};
this.oAuth2ClientCredentialsName = {
/**
* @description You can use the following request to get OAuth2 client credentials for a given credentials name.
*
* @tags OAuth2 Client Credentials
* @name OAuth2ClientCredentialsList
* @summary Get OAuth2 client credentials by name.
* @request GET:/OAuth2ClientCredentials('{Name}')
* @secure
*/
oAuth2ClientCredentialsList: (name, query, params = {}) => this.request({
path: `/OAuth2ClientCredentials('${name}')`,
method: "GET",
query: query,
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to update OAuth2 client credentials.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to update credentials.
*
* @tags OAuth2 Client Credentials
* @name OAuth2ClientCredentialsUpdate
* @summary Update OAuth2 client credentials
* @request PUT:/OAuth2ClientCredentials('{Name}')
* @secure
*/
oAuth2ClientCredentialsUpdate: (name, OAuth2ClientCredentials, params = {}) => this.request({
path: `/OAuth2ClientCredentials('${name}')`,
method: "PUT",
body: OAuth2ClientCredentials,
secure: true,
type: ContentType.Json,
...params,
}),
/**
* @description You can use the following request to delete OAuth2 client credentials.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to delete credentials.
*
* @tags OAuth2 Client Credentials
* @name OAuth2ClientCredentialsDelete
* @summary Delete OAuth2 client credentials
* @request DELETE:/OAuth2ClientCredentials('{Name}')
* @secure
*/
oAuth2ClientCredentialsDelete: (name, params = {}) => this.request({
path: `/OAuth2ClientCredentials('${name}')`,
method: "DELETE",
secure: true,
...params,
}),
};
this.certificateResourcesHexalias = {
/**
* @description You can use the following request to import or update a certificate.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to add/update certificates.
*
* @tags Certificate
* @name ValueUpdate
* @summary Import/update a certificate.
* @request PUT:/CertificateResources('{Hexalias}')/$value
* @secure
*/
valueUpdate: (hexalias, query, CertificateResource, params = {}) => this.request({
path: `/CertificateResources('${hexalias}')/$value`,
method: "PUT",
query: query,
body: CertificateResource,
secure: true,
type: ContentType.Json,
format: "json",
...params,
}),
};
this.keystoreEntriesHexalias = {
/**
* @description You can use the following request to export a certificate for a certain alias (hex encoded value). If the specified alias represents a key pair, the certificate with the public key is exported.
*
* @tags Certificate
* @name CertificateValueList
* @summary Export certificate.
* @request GET:/KeystoreEntries('{Hexalias}')/Certificate/$value
* @secure
*/
certificateValueList: (hexalias, query, params = {}) => this.request({
path: `/KeystoreEntries('${hexalias}')/Certificate/$value`,
method: "GET",
query: query,
secure: true,
...params,
}),
/**
* @description You can use the following request to generate a certificate signing request.
*
* @tags Key Pair
* @name SigningRequestValueList
* @summary Generate a certificate signing request.
* @request GET:/KeystoreEntries('{Hexalias}')/SigningRequest/$value
* @secure
*/
signingRequestValueList: (hexalias, params = {}) => this.request({
path: `/KeystoreEntries('${hexalias}')/SigningRequest/$value`,
method: "GET",
secure: true,
...params,
}),
/**
* @description You can use the following request to get a certificate chain of a key pair.
*
* @tags Key Pair
* @name ChainCertificatesList
* @summary Get certificate chain.
* @request GET:/KeystoreEntries('{Hexalias}')/ChainCertificates
* @secure
*/
chainCertificatesList: (hexalias, query, params = {}) => this.request({
path: `/KeystoreEntries('${hexalias}')/ChainCertificates`,
method: "GET",
query: query,
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to export a certificate chain.
*
* @tags Key Pair
* @name ChainResourceValueList
* @summary Export certificate chain.
* @request GET:/KeystoreEntries('{Hexalias}')/ChainResource/$value
* @secure
*/
chainResourceValueList: (hexalias, query, params = {}) => this.request({
path: `/KeystoreEntries('${hexalias}')/ChainResource/$value`,
method: "GET",
query: query,
secure: true,
...params,
}),
/**
* @description You can use the following request to get a keystore entry for a certain alias.
*
* @tags Keystore Entry
* @name KeystoreEntriesList
* @summary Get keystore entry by alias
* @request GET:/KeystoreEntries('{Hexalias}')
* @secure
*/
keystoreEntriesList: (hexalias, query, params = {}) => this.request({
path: `/KeystoreEntries('${hexalias}')`,
method: "GET",
query: query,
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to rename entry alias of the current tenant keystore.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions for the keystore.
*
* @tags Keystore Entry
* @name KeystoreEntriesUpdate
* @summary Rename an entry alias of tenant keystore.
* @request PUT:/KeystoreEntries('{Hexalias}')
* @secure
*/
keystoreEntriesUpdate: (hexalias, KeystoreEntry, query, params = {}) => this.request({
path: `/KeystoreEntries('${hexalias}')`,
method: "PUT",
query: query,
body: KeystoreEntry,
secure: true,
type: ContentType.Json,
format: "json",
...params,
}),
/**
* @description You can use the following request to delete an entry of the tenant keystore or to activate an entry from the renewal keystore (keystoreName=KeyRenewal).<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions for the keystore.
*
* @tags Keystore Entry
* @name KeystoreEntriesDelete
* @summary Delete/activate keystore entry.
* @request DELETE:/KeystoreEntries('{Hexalias}')
* @secure
*/
keystoreEntriesDelete: (hexalias, query, params = {}) => this.request({
path: `/KeystoreEntries('${hexalias}')`,
method: "DELETE",
query: query,
secure: true,
format: "json",
...params,
}),
};
this.keyPairGenerationRequests = {
/**
* @description You can use the following request to generate a key pair.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to generate key pair.
*
* @tags Key Pair
* @name KeyPairGenerationRequestsCreate
* @summary Generate a key pair.
* @request POST:/KeyPairGenerationRequests
* @secure
*/
keyPairGenerationRequestsCreate: (query, KeyPairGenerationRequest, params = {}) => this.request({
path: `/KeyPairGenerationRequests`,
method: "POST",
query: query,
body: KeyPairGenerationRequest,
secure: true,
type: ContentType.Json,
format: "json",
...params,
}),
};
this.rsaKeyGenerationRequests = {
/**
* @description You can use the following request to generate an RSA key pair.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to generate key pair.<br>As 'Hexalias', provide any hexadecimal value; the system calculates the correct hexadecimal value from the specified 'Alias' property.<br>Note the following regarding the 'RSAFile': If you're using a simple HTTP request with a JSON body, the value of the property 'RSAFile' must contain the base64-encoded private key with padding.<br>Possible values for 'SignatureAlgorithm' are 'SHA-512/RSA', 'SHA-256/RSA', 'SHA-384/RSA', 'SHA-224/RSA', 'SHA-1/RSA'.<br>For private keys, only PKCS#1 format with a PEM header 'BEGIN RSA PRIVATE KEY' is supported. This operation can only by performed on the 'system' keystore.
*
* @tags Key Pair
* @name RsaKeyGenerationRequestsCreate
* @summary Generate an RSA key pair.
* @request POST:/RSAKeyGenerationRequests
* @secure
*/
rsaKeyGenerationRequestsCreate: (query, RSAKeyGenerationRequest, params = {}) => this.request({
path: `/RSAKeyGenerationRequests`,
method: "POST",
query: query,
body: RSAKeyGenerationRequest,
secure: true,
type: ContentType.Json,
format: "json",
...params,
}),
};
this.sshKeyGenerationRequests = {
/**
* @description You can use the following request to generate an SSH private key pair from an OpenSSH key (with cryptographic algorithms RSA, DSA or EC) or a PuTTY file (with cryptographic algorithms RSA or DSA, but not EC). The alias for the generated key pair depends on the algorithm: id_rsa, id_dsa or id_ec.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to generate key pair.
*
* @tags Key Pair
* @name SshKeyGenerationRequestsCreate
* @summary Generate SSH private key pair.
* @request POST:/SSHKeyGenerationRequests
* @secure
*/
sshKeyGenerationRequestsCreate: (query, SSHKeyGenerationRequest, params = {}) => this.request({
path: `/SSHKeyGenerationRequests`,
method: "POST",
query: query,
body: SSHKeyGenerationRequest,
secure: true,
type: ContentType.Json,
format: "json",
...params,
}),
};
this.keyPairResources = {
/**
* @description You can use the following request to import or update a key pair.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to add/update key pair.
*
* @tags Key Pair
* @name KeyPairResourcesCreate
* @summary Import/update a key pair.
* @request POST:/KeyPairResources
* @secure
*/
keyPairResourcesCreate: (query, KeyPairResource, params = {}) => this.request({
path: `/KeyPairResources`,
method: "POST",
query: query,
body: KeyPairResource,
secure: true,
type: ContentType.Json,
format: "json",
...params,
}),
};
this.certificateChainResourcesHexalias = {
/**
* @description You can use the following request to import a certificate chain.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions for the keystore.
*
* @tags Key Pair
* @name ValueUpdate
* @summary Import a certificate chain.
* @request PUT:/CertificateChainResources('{Hexalias}')/$value
* @secure
*/
valueUpdate: (hexalias, query, CertificateChainResource, params = {}) => this.request({
path: `/CertificateChainResources('${hexalias}')/$value`,
method: "PUT",
query: query,
body: CertificateChainResource,
secure: true,
type: ContentType.Json,
format: "json",
...params,
}),
};
this.keystoreEntries = {
/**
* @description You can use the following request to get all entries of a keystore.
*
* @tags Keystore Entry
* @name KeystoreEntriesList
* @summary Get all entries of a keystore.
* @request GET:/KeystoreEntries
* @secure
*/
keystoreEntriesList: (query, params = {}) => this.request({
path: `/KeystoreEntries`,
method: "GET",
query: query,
secure: true,
format: "json",
...params,
}),
};
this.keystoreEntries69645F727361 = {
/**
* @description You can use the following request to export the public key of the provided certificate/key pair in OpenSSH format.
*
* @tags Keystore Entry
* @name SshkeyValueList
* @summary Export public key in OpenSSH format.
* @request GET:/KeystoreEntries('69645F727361')/Sshkey/$value
* @secure
*/
sshkeyValueList: (params = {}) => this.request({
path: `/KeystoreEntries('69645F727361')/Sshkey/$value`,
method: "GET",
secure: true,
...params,
}),
};
this.keystoresKeystoreName = {
/**
* @description You can use the following request to get keystore properties and entries.
*
* @tags Keystore
* @name KeystoresList
* @summary Get keystore properties and entries.
* @request GET:/Keystores('{KeystoreName}')
* @secure
*/
keystoresList: (keystoreName, query, params = {}) => this.request({
path: `/Keystores('${keystoreName}')`,
method: "GET",
query: query,
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to get the number of keystore entries.
*
* @tags Keystore
* @name SizeValueList
* @summary Get number of keystore entries.
* @request GET:/Keystores('{KeystoreName}')/Size/$value
* @secure
*/
sizeValueList: (keystoreName, params = {}) => this.request({
path: `/Keystores('${keystoreName}')/Size/$value`,
method: "GET",
secure: true,
...params,
}),
};
this.keystoreResources = {
/**
* @description You can use the following request to import entries to the tenant keystore (target keystore name ```system```) or to back up the keystore entries owned by tenant administrator (target keystore name ```backup_admin_system```). For the import entries are ignored during import, which do not represent a X.509 certificate entry or a key pair entry with a certificate chain of X.509 certificates. The backup overwrites the old backup keystore. <br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to import the keystore entries.
*
* @tags Keystore
* @name KeystoreResourcesCreate
* @summary Import/back up a keystore.
* @request POST:/KeystoreResources
* @secure
*/
keystoreResourcesCreate: (Keystore, query, params = {}) => this.request({
path: `/KeystoreResources`,
method: "POST",
query: query,
body: Keystore,
secure: true,
type: ContentType.Json,
format: "json",
...params,
}),
};
this.keystoreResourcesKeystoreName = {
/**
* @description You can use the following request to export the public content of the keystore, which was created by SAP or tenant administrator.<br> For a private key entry the complete chain is exported as described in the following example: If the key pair entry has the alias ```test```, and has a chain of three certificates, the certificate of the entry gets the alias ```test``` in the exported keystore, the intermediate CA certificate gets the alias ```test_1```, and the root CA certificate gets the alias ```test_2```. If entries with ```test_1```or ```test_2``` already exist, an additional underscore ```_``` is added to the alias until it is unique.
*
* @tags Keystore
* @name KeystoreResourcesList
* @summary Export public keystore content.
* @request GET:/KeystoreResources('{KeystoreName}')
* @secure
*/
keystoreResourcesList: (keystoreName, params = {}) => this.request({
path: `/KeystoreResources('${keystoreName}')`,
method: "GET",
secure: true,
format: "json",
...params,
}),
};
this.keystoreResourcesSystem = {
/**
* @description You can use the following request to retrieve backed up keystore entries or to delete several entries of the current keystore, which are owned by tenant administrator.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions for the keystore.
*
* @tags Keystore
* @name KeystoreResourcesSystemUpdate
* @summary Retrieve backed up/delete keystore entries.
* @request PUT:/KeystoreResources('system')
* @secure
*/
keystoreResourcesSystemUpdate: (KeystoreResource, query, params = {}) => this.request({
path: `/KeystoreResources('system')`,
method: "PUT",
query: query,
body: KeystoreResource,
secure: true,
type: ContentType.Json,
format: "json",
...params,
}),
};
this.historyKeystoreEntries = {
/**
* @description You can use the following request to get entries of the history keystore.
*
* @tags Keystore History
* @name HistoryKeystoreEntriesList
* @summary Get entries of the history keystore.
* @request GET:/HistoryKeystoreEntries
* @secure
*/
historyKeystoreEntriesList: (query, params = {}) => this.request({
path: `/HistoryKeystoreEntries`,
method: "GET",
query: query,
secure: true,
format: "json",
...params,
}),
};
this.historyKeystoreEntriesHexalias = {
/**
* @description You can use the following request to get a keystore history entry for a certain alias.
*
* @tags Keystore History
* @name HistoryKeystoreEntriesList
* @summary Get keystore history entry by alias
* @request GET:/HistoryKeystoreEntries('{Hexalias}')
* @secure
*/
historyKeystoreEntriesList: (hexalias, query, params = {}) => this.request({
path: `/HistoryKeystoreEntries('${hexalias}')`,
method: "GET",
query: query,
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to restore an entry from the keystore history to the renewal keystore.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions for the keystore.
*
* @tags Keystore History
* @name HistoryKeystoreEntriesUpdate
* @summary Restore an entry from history to renewal keystore.
* @request PUT:/HistoryKeystoreEntries('{Hexalias}')
* @secure
*/
historyKeystoreEntriesUpdate: (hexalias, query, KeystoreEntry, params = {}) => this.request({
path: `/HistoryKeystoreEntries('${hexalias}')`,
method: "PUT",
query: query,
body: KeystoreEntry,
secure: true,
type: ContentType.Json,
...params,
}),
};
this.certificateUserMappings = {
/**
* @description You can use the following request to get all certificate-to-user mappings.This resource is only available in the Neo environment.<br>For more information, see SAP Help Portal documentation at [Environment-Specific Aspects Integration Developers Should Know](https://help.sap.com/docs/CLOUD_INTEGRATION/368c481cd6954bdfa5d0435479fd4eaf/639a0612e32c498fa7480580d90c9ea6.html?locale=en-US).
*
* @tags Certificate-to-User Mapping
* @name CertificateUserMappingsList
* @summary Get all certificate-to-user mappings.
* @request GET:/CertificateUserMappings
* @secure
*/
certificateUserMappingsList: (query, params = {}) => this.request({
path: `/CertificateUserMappings`,
method: "GET",
query: query,
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to add a new certificate-to-user mapping or to update the user of an existing mapping.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to create certificate-to-user mappings.This resource is only available in the Neo environment.<br>For more information, see SAP Help Portal documentation at [Environment-Specific Aspects Integration Developers Should Know](https://help.sap.com/docs/CLOUD_INTEGRATION/368c481cd6954bdfa5d0435479fd4eaf/639a0612e32c498fa7480580d90c9ea6.html?locale=en-US).
*
* @tags Certificate-to-User Mapping
* @name CertificateUserMappingsCreate
* @summary Add new certificate-to-user mapping.
* @request POST:/CertificateUserMappings
* @secure
*/
certificateUserMappingsCreate: (CertificateUserMapping, params = {}) => this.request({
path: `/CertificateUserMappings`,
method: "POST",
body: CertificateUserMapping,
secure: true,
type: ContentType.Json,
format: "json",
...params,
}),
};
this.certificateUserMappingsId = {
/**
* @description You can use the following request to get a certificate-to-user mapping for a given Id.This resource is only available in the Neo environment.<br>For more information, see SAP Help Portal documentation at [Environment-Specific Aspects Integration Developers Should Know](https://help.sap.com/docs/CLOUD_INTEGRATION/368c481cd6954bdfa5d0435479fd4eaf/639a0612e32c498fa7480580d90c9ea6.html?locale=en-US).
*
* @tags Certificate-to-User Mapping
* @name CertificateUserMappingsList
* @summary Get certificate-to-user mapping.
* @request GET:/CertificateUserMappings('{Id}')
* @secure
*/
certificateUserMappingsList: (id, query, params = {}) => this.request({
path: `/CertificateUserMappings('${id}')`,
method: "GET",
query: query,
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to delete certificate-to-user mapping.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to delete certificate-to-user mappings.This resource is only available in the Neo environment.<br>For more information, see SAP Help Portal documentation at [Environment-Specific Aspects Integration Developers Should Know](https://help.sap.com/docs/CLOUD_INTEGRATION/368c481cd6954bdfa5d0435479fd4eaf/639a0612e32c498fa7480580d90c9ea6.html?locale=en-US).
*
* @tags Certificate-to-User Mapping
* @name CertificateUserMappingsDelete
* @summary Delete certificate-to-user mapping.
* @request DELETE:/CertificateUserMappings('{Id}')
* @secure
*/
certificateUserMappingsDelete: (id, params = {}) => this.request({
path: `/CertificateUserMappings('${id}')`,
method: "DELETE",
secure: true,
...params,
}),
};
this.accessPolicies = {
/**
* @description You can use the following request to get all access policies.<br>
*
* @tags Access Policies
* @name AccessPoliciesList
* @summary Get all access policies.
* @request GET:/AccessPolicies
* @secure
*/
accessPoliciesList: (query, params = {}) => this.request({
path: `/AccessPolicies`,
method: "GET",
query: query,
secure: true,
format: "json",
...params,
}),
/**
* @description You can use the following request to add access policies. You can also create respective artifact reference in one call.<br> **ArtifactReference** - Following values of the *Type* property: 'MESSAGE_QUEUE' 'GLOBAL_DATA_STORE' 'GLOBAL_VARIABLE' have only one value for the property *ConditionAttribute*: 'Name' Check the ArtifactReference model for more values.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to add user credentials.
*
* @tags Access Policies
* @name AccessPoliciesCreate
* @summary Add access policies.
* @request POST:/AccessPolicies
* @secure
*/
accessPoliciesCreate: (AccessPolicy, params = {}) => this.request({
path: `/AccessPolicies`,
method: "POST",
body: AccessPolicy,
secure: true,
type: ContentType.Json,
...params,
}),
};
this.accessPoliciesId = {
/**
* @description You can use the following request to delete access policy.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to delete access policies.
*
* @tags Access Policies
* @name AccessPoliciesDelete
* @summary Delete access policy with a certain Id.
* @request DELETE:/AccessPolicies({Id})
* @secure
*/
accessPoliciesDelete: (id, params = {}) => this.request({
path: `/AccessPolicies(${id})`,
method: "DELETE",
secure: true,
...params,
}),
/**
* @description You can use the following request to update access policy.<br> In API sandbox only read APIs could be tested. You need to configure an API endpoint for your account, where you have the required write permissions to update access policies.
*
* @tags Access Policies
* @name AccessPoliciesPartialUpdate
* @summary Updates access policy with a certain Id.
* @request PATCH:/AccessPolicies({Id})
* @secure
*/
accessPoliciesPartialUpdate: (id, params = {}) => this.request({
path: `/AccessPolicies(${id})`,
method: "PATCH",
secure: true,
...params,
}),
};
this.artifactReferences = {