hcloud-sdk 0.0.16 → 15.0.0

package/lib/service/high5/wave/s3/index.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3 = void 0;
+const Base_1 = require("../../../../Base");
+const axios_1 = require("../../../../interfaces/axios");
+/**
+ * Class for reading the S3 bucket of a wave engine and catalogs
+ */
+class S3 extends Base_1.default {
+    constructor(options, axios) {
+        super(options, axios);
+    }
+    /**
+     * Get the registry.json of the default wave catalog from the S3 bucket
+     * @param waveBucketUrl Public base url to S3 bucket
+     * @returns registry.json
+     */
+    getCatalogRegistry(waveBucketUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.get(`${waveBucketUrl}/catalogs/registry.json`, { headers: axios_1.disableCacheHeaders });
+            return resp.data;
+        });
+    }
+    /**
+     * Get the registry.json of the default wave engine from the S3 bucket
+     * @param waveBucketUrl Public base url to S3 bucket
+     * @returns registry.json
+     */
+    getEngineRegistry(waveBucketUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.get(`${waveBucketUrl}/engines/registry.json`, { headers: axios_1.disableCacheHeaders });
+            return resp.data;
+        });
+    }
+    /**
+     * Get the catalog.json from the S3 bucket
+     * @param catalogUrl Public url of the catalog
+     * @returns index.json of catalog
+     */
+    getCatalog(catalogUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.get(`${catalogUrl}`, { headers: axios_1.disableCacheHeaders });
+            return resp.data;
+        });
+    }
+    /**
+     * Get the catalog.json from the S3 bucket
+     * @param catalogUrl Public url of the catalog
+     * @returns index.json of catalog
+     */
+    getEngine(engineUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.get(`${engineUrl}`, { headers: axios_1.disableCacheHeaders });
+            return resp.data;
+        });
+    }
+    /**
+     * Get the node specifications of all nodes of a specific catalog version from the S3 bucket
+     * @param catalogUrl Public url of the catalog
+     * @param version The catalog version
+     * @returns StreamNodeSpecification[] | StreamNodeSpecificationWrappedWithEngineVersion an array of all node specification of that catalog version, maybe wrapped in an object with the engine version
+     */
+    getCatalogVersion(catalogUrl, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const specificationUrl = catalogUrl.split("/").slice(0, -1).join("/") + "/" + version + "/specification.json";
+            const resp = yield this.axios.get(specificationUrl, {
+                headers: axios_1.disableCacheHeaders,
+            });
+            return resp.data;
+        });
+    }
+    /**
+     * Get the node documentation from the S3 bucket
+     * @param catalogUrl Public url of the catalog
+     * @param version The catalog version
+     * @returns string the markdown documentation of the node
+     */
+    getNodeDocumentation(catalogUrl, version, nodeName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const specificationUrl = catalogUrl.split("/").slice(0, -1).join("/") + `/${version}/docs/${nodeName}.md`;
+            const resp = yield this.axios.get(specificationUrl).catch(err => {
+                throw new Error(`Node documentation not found: ${err}`);
+            });
+            return resp.data;
+        });
+    }
+    getEndpoint() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.S3 = S3;

package/lib/service/idp/index.d.ts

@@ -0,0 +1,84 @@
+import Base from "../../Base";
+import { Version } from "../../interfaces/global";
+import { PreLoginResponse } from "../../interfaces/idp";
+import { SuccessfulAuth } from "../../interfaces/idp/user/SuccessfulAuth";
+import { IdpInternal } from "./internal";
+import { IdpOAuth } from "./oauth";
+import { IdpOrganization } from "./organization";
+import { IdpRegistration } from "./registration";
+import { IdpUser } from "./user";
+export default class Idp extends Base {
+    /**
+     * Handles everything around organizations
+     */
+    get organization(): IdpOrganization;
+    private _organization?;
+    /**
+     * Handles everything around registration
+     */
+    get registration(): IdpRegistration;
+    private _registration?;
+    /**
+     * Handles everything around open authorization and openId requests
+     */
+    get oAuth(): IdpOAuth;
+    private _oAuth?;
+    /**
+     * Handles everything around a user
+     */
+    get user(): IdpUser;
+    private _user?;
+    /**
+     * Handles everything around idp's internal endpoints
+     */
+    get internal(): IdpInternal;
+    private _internal?;
+    /**
+     * Requests the endpoint version
+     * @returns Version object
+     */
+    version(): Promise<Version>;
+    /**
+     * Authenticates against the identity provider with a given email and password.
+     * @param email Email of the user
+     * @param password Password of the user
+     * @param token (optional) token if 2FA-TOTP is enabled
+     * @returns SuccessfulAuth object holding the token and the user
+     */
+    login(email: string, password: string, token?: string): Promise<SuccessfulAuth>;
+    /**
+     * Starts the login process via OIDC
+     * @param origin The starting URL of the process. After obtaining the credentials, the user will be redirected back to this url.
+     * @param oidcProvider The provider to use for the process. Only optional if the user is part of an organization that has a preferred
+     * OIDC provider and an associated email that matches the user's. The list of available providers can be found in the public config endpoint.
+     * @param hint Valid email address of the user that wants to login. Hint must be defined when provider is not.
+     * @returns URL that must be accessed via a browser to continue the login process.
+     */
+    loginWithOIDC(origin: string, oidcProvider?: string, hint?: string): Promise<string>;
+    /**
+     * Starts the login process via SAML 2.0
+     * @param origin The starting URL of the process. After obtaining the credentials, the user will be redirected back to this url.
+     * @param email  Email of the user. The email domain will be used to determine the appropriate SAML 2.0 provider to use going forward.
+     * @returns URL that must be accessed via a browser to continue the login process.
+     */
+    loginWithSAML(origin: string, email: string): Promise<string>;
+    /**
+     * Determine if/how the given email can authenticate.
+     *
+     * @param email  Email of the user
+     * @param origin The starting URL of the process. If the authentication process bound to this email is SAML or OIDC,
+     *               then the response's location property will include this origin.
+     * @returns object that dictates if: the user needs to REGISTER; the user needs to VERIFY_EMAIL; the user can LOGIN using this email;
+     *          or the authentication process should continue via an EXTERNAL provider that can be found via the location property.
+     */
+    preLogin(email: string, origin: string): Promise<PreLoginResponse>;
+    /**
+     * Initiate the password reset process. An email will be sent to the user to move to the next phase.
+     *
+     * @param email Email of the user
+     * @param captcha Valid google reCAPTCHAV2
+     * @param targetUrl Optional url the link in the mail will point to
+     */
+    resetPassword(email: string, captcha: string, targetUrl?: string): Promise<void>;
+    protected getEndpoint(endpoint: string): string;
+}

package/lib/service/idp/index.js

@@ -0,0 +1,185 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Base_1 = require("../../Base");
+const internal_1 = require("./internal");
+const oauth_1 = require("./oauth");
+const organization_1 = require("./organization");
+const registration_1 = require("./registration");
+const user_1 = require("./user");
+class Idp extends Base_1.default {
+    /**
+     * Handles everything around organizations
+     */
+    get organization() {
+        if (this._organization === undefined) {
+            this._organization = new organization_1.IdpOrganization(this.options, this.axios);
+        }
+        return this._organization;
+    }
+    /**
+     * Handles everything around registration
+     */
+    get registration() {
+        if (this._registration === undefined) {
+            this._registration = new registration_1.IdpRegistration(this.options, this.axios);
+        }
+        return this._registration;
+    }
+    /**
+     * Handles everything around open authorization and openId requests
+     */
+    get oAuth() {
+        if (this._oAuth === undefined) {
+            this._oAuth = new oauth_1.IdpOAuth(this.options, this.axios);
+        }
+        return this._oAuth;
+    }
+    /**
+     * Handles everything around a user
+     */
+    get user() {
+        if (this._user === undefined) {
+            this._user = new user_1.IdpUser(this.options, this.axios);
+        }
+        return this._user;
+    }
+    /**
+     * Handles everything around idp's internal endpoints
+     */
+    get internal() {
+        if (this._internal === undefined) {
+            this._internal = new internal_1.IdpInternal(this.options, this.axios);
+        }
+        return this._internal;
+    }
+    /**
+     * Requests the endpoint version
+     * @returns Version object
+     */
+    version() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.get(this.getEndpoint("/v1/version"));
+            return resp.data;
+        });
+    }
+    /**
+     * Authenticates against the identity provider with a given email and password.
+     * @param email Email of the user
+     * @param password Password of the user
+     * @param token (optional) token if 2FA-TOTP is enabled
+     * @returns SuccessfulAuth object holding the token and the user
+     */
+    login(email, password, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let body = { email: email, password: password };
+            if (token) {
+                body = Object.assign(Object.assign({}, body), { token: token });
+            }
+            const resp = yield this.axios.post(this.getEndpoint("/v1/login"), body);
+            const authed = {
+                token: ((_a = resp.headers["authorization"]) === null || _a === void 0 ? void 0 : _a.toString()) || "",
+                user: resp.data,
+            };
+            return authed;
+        });
+    }
+    /**
+     * Starts the login process via OIDC
+     * @param origin The starting URL of the process. After obtaining the credentials, the user will be redirected back to this url.
+     * @param oidcProvider The provider to use for the process. Only optional if the user is part of an organization that has a preferred
+     * OIDC provider and an associated email that matches the user's. The list of available providers can be found in the public config endpoint.
+     * @param hint Valid email address of the user that wants to login. Hint must be defined when provider is not.
+     * @returns URL that must be accessed via a browser to continue the login process.
+     */
+    loginWithOIDC(origin, oidcProvider, hint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.get(this.getEndpoint("/v1/login/oidc"), {
+                params: {
+                    origin,
+                    provider: oidcProvider,
+                    hint,
+                },
+                maxRedirects: 0,
+                validateStatus: status => {
+                    return status >= 300 && status < 400;
+                },
+            });
+            const location = resp.headers.location;
+            if (!location) {
+                throw new Error("Location header is undefined.");
+            }
+            return location;
+        });
+    }
+    /**
+     * Starts the login process via SAML 2.0
+     * @param origin The starting URL of the process. After obtaining the credentials, the user will be redirected back to this url.
+     * @param email  Email of the user. The email domain will be used to determine the appropriate SAML 2.0 provider to use going forward.
+     * @returns URL that must be accessed via a browser to continue the login process.
+     */
+    loginWithSAML(origin, email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.get(this.getEndpoint("/v1/login/saml"), {
+                params: {
+                    origin,
+                    email,
+                },
+                maxRedirects: 0,
+                validateStatus: status => {
+                    return status >= 300 && status < 400;
+                },
+            });
+            const location = resp.headers.location;
+            if (!location) {
+                throw new Error("Location header is undefined.");
+            }
+            return location;
+        });
+    }
+    /**
+     * Determine if/how the given email can authenticate.
+     *
+     * @param email  Email of the user
+     * @param origin The starting URL of the process. If the authentication process bound to this email is SAML or OIDC,
+     *               then the response's location property will include this origin.
+     * @returns object that dictates if: the user needs to REGISTER; the user needs to VERIFY_EMAIL; the user can LOGIN using this email;
+     *          or the authentication process should continue via an EXTERNAL provider that can be found via the location property.
+     */
+    preLogin(email, origin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.get(this.getEndpoint("/v1/login/pre"), {
+                params: {
+                    origin,
+                    email,
+                },
+            });
+            return resp.data;
+        });
+    }
+    /**
+     * Initiate the password reset process. An email will be sent to the user to move to the next phase.
+     *
+     * @param email Email of the user
+     * @param captcha Valid google reCAPTCHAV2
+     * @param targetUrl Optional url the link in the mail will point to
+     */
+    resetPassword(email, captcha, targetUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.post(this.getEndpoint("/v1/login/forgot_password"), { email, captcha, targetUrl });
+        });
+    }
+    getEndpoint(endpoint) {
+        return `${this.options.server}/api/account${endpoint}`;
+    }
+}
+exports.default = Idp;

package/lib/service/idp/internal/index.d.ts

@@ -0,0 +1,17 @@
+import Base from "../../../Base";
+import { User } from "../../../interfaces/idp/user";
+export declare class IdpInternal extends Base {
+    /**
+     * Creates an agent user for an organization.
+     *
+     * This is an internal endpoint and requires HCloud admin credentials to use.
+     *
+     * @param orgName Name of the organization
+     * @returns the created user and a pat token
+     */
+    createAgentUser(orgName: string): Promise<{
+        user: User;
+        pat: string;
+    }>;
+    protected getEndpoint(endpoint: string): string;
+}

package/lib/service/idp/internal/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdpInternal = void 0;
+const Base_1 = require("../../../Base");
+class IdpInternal extends Base_1.default {
+    /**
+     * Creates an agent user for an organization.
+     *
+     * This is an internal endpoint and requires HCloud admin credentials to use.
+     *
+     * @param orgName Name of the organization
+     * @returns the created user and a pat token
+     */
+    createAgentUser(orgName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.axios.post(this.getEndpoint(`/internal/v1/org/${orgName}/agent`));
+            return { user: res.data, pat: res.headers.authorization };
+        });
+    }
+    getEndpoint(endpoint) {
+        return `${this.options.server}/api/account${endpoint}`;
+    }
+}
+exports.IdpInternal = IdpInternal;

package/lib/service/idp/oauth/index.d.ts

@@ -0,0 +1,49 @@
+import Base from "../../../Base";
+import { OAuthToken, OAuthTokenRequest } from "../../../interfaces/idp/oauth";
+import { OAuthAppWithConsent } from "../../../interfaces/idp/organization/settings/oauthApp";
+export declare class IdpOAuth extends Base {
+    /**
+     * getAuthorizationCodeInsideRedirectUrl throws for an invalid request (query params do not match OAuthApp).
+     * It returns the redirect URL with the code, which is used to redirect to the client application,
+     * which can use the code for a back-channel request to get the access token.
+     * @param queryString expect the user's / browser's query string, containing the  response_type, client_id,
+     * redirect_uri, scopes and optionally state.
+     * @returns the entire redirect uri including the authorization code if successful
+     */
+    getAuthorizationCodeInsideRedirectUrl(queryString: string, doNotRedirect?: boolean): Promise<string>;
+    /**
+     * Check if the user has consented to specified scopes. If the user has already consented this request
+     * will return the redirect URL, otherwise, it will be a consent.not.given error.
+     *
+     * To consent the createScopesAndGetAuthorizationCodeInsideRedirectUrl method should be used.
+     * @see IdpOAuth.createScopesAndGetAuthorizationCodeInsideRedirectUrl
+     *
+     * @param queryString {string} - Query string containing the OAuth parameters: response_type, client_id, scope, state
+     * @param doNotRedirect [boolean] - Flag to make the request return a 200 instead of a 3xx status code
+     * @returns A string with the redirect URL if the user already consented to the specificied scope. Otherwise, an OAuthApp
+     * @see OAuthApp
+     */
+    getInfoOrAuthorizationCodeInsideRedirectUrl(queryString: string, doNotRedirect?: boolean): Promise<string>;
+    /**
+     * createScopesAndGetAuthorizationCodeInsideRedirectUrl throws for an invalid request (query params do not match OAuthApp).
+     * It returns the redirect URL with the code, which is used to redirect to the client application,
+     * which can use the code for a back-channel request to get the access token. It also adds the scopes for the user.
+     * @param queryString expect the user's / browser's query string, containing the  response_type, client_id,
+     * redirect_uri, scopes and optionally state.
+     * @returns the entire redirect uri including the authorization code if successful
+     */
+    createScopesAndGetAuthorizationCodeInsideRedirectUrl(queryString: string, doNotRedirect?: boolean): Promise<string>;
+    /**
+     * A valid code can be used to request a new API token.
+     * @param tokenRequest contains the code, client_id, client_secret and redirect_uri
+     */
+    exchangeCodeForToken(tokenRequest: OAuthTokenRequest): Promise<OAuthToken>;
+    /**
+     * Get OAuth app public information via client ID
+     *
+     * @param clientId {string} - Client ID of the OAuth app
+     * @returns Public OAuth app information
+     */
+    getOAuthAppInfo: (clientId: string) => Promise<OAuthAppWithConsent>;
+    protected getEndpoint(endpoint: string): string;
+}

package/lib/service/idp/oauth/index.js

@@ -0,0 +1,117 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdpOAuth = void 0;
+const Base_1 = require("../../../Base");
+class IdpOAuth extends Base_1.default {
+    constructor() {
+        super(...arguments);
+        /**
+         * Get OAuth app public information via client ID
+         *
+         * @param clientId {string} - Client ID of the OAuth app
+         * @returns Public OAuth app information
+         */
+        this.getOAuthAppInfo = (clientId) => __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.get(this.getEndpoint(`/v1/login/oauth/app/${clientId}`));
+            return response.data;
+        });
+    }
+    /**
+     * getAuthorizationCodeInsideRedirectUrl throws for an invalid request (query params do not match OAuthApp).
+     * It returns the redirect URL with the code, which is used to redirect to the client application,
+     * which can use the code for a back-channel request to get the access token.
+     * @param queryString expect the user's / browser's query string, containing the  response_type, client_id,
+     * redirect_uri, scopes and optionally state.
+     * @returns the entire redirect uri including the authorization code if successful
+     */
+    getAuthorizationCodeInsideRedirectUrl(queryString, doNotRedirect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!queryString.startsWith("?")) {
+                queryString = `?${queryString}`;
+            }
+            if (doNotRedirect) {
+                queryString += "&no_redirect=true";
+            }
+            const response = yield this.axios.get(this.getEndpoint(`/v1/login/oauth/authorize${queryString}`), { maxRedirects: 0 });
+            if (doNotRedirect) {
+                return response.data.redirectUrl;
+            }
+            return response.headers.location;
+        });
+    }
+    /**
+     * Check if the user has consented to specified scopes. If the user has already consented this request
+     * will return the redirect URL, otherwise, it will be a consent.not.given error.
+     *
+     * To consent the createScopesAndGetAuthorizationCodeInsideRedirectUrl method should be used.
+     * @see IdpOAuth.createScopesAndGetAuthorizationCodeInsideRedirectUrl
+     *
+     * @param queryString {string} - Query string containing the OAuth parameters: response_type, client_id, scope, state
+     * @param doNotRedirect [boolean] - Flag to make the request return a 200 instead of a 3xx status code
+     * @returns A string with the redirect URL if the user already consented to the specificied scope. Otherwise, an OAuthApp
+     * @see OAuthApp
+     */
+    getInfoOrAuthorizationCodeInsideRedirectUrl(queryString, doNotRedirect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!queryString.startsWith("?")) {
+                queryString = `?${queryString}`;
+            }
+            if (doNotRedirect) {
+                queryString += "&no_redirect=true";
+            }
+            const response = yield this.axios.get(this.getEndpoint(`/v1/login/oauth/info${queryString}`), {
+                maxRedirects: 0,
+            });
+            if (response.status < 300) {
+                return response.data.redirectUrl;
+            }
+            return response.headers.location;
+        });
+    }
+    /**
+     * createScopesAndGetAuthorizationCodeInsideRedirectUrl throws for an invalid request (query params do not match OAuthApp).
+     * It returns the redirect URL with the code, which is used to redirect to the client application,
+     * which can use the code for a back-channel request to get the access token. It also adds the scopes for the user.
+     * @param queryString expect the user's / browser's query string, containing the  response_type, client_id,
+     * redirect_uri, scopes and optionally state.
+     * @returns the entire redirect uri including the authorization code if successful
+     */
+    createScopesAndGetAuthorizationCodeInsideRedirectUrl(queryString, doNotRedirect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!queryString.startsWith("?")) {
+                queryString = `?${queryString}`;
+            }
+            if (doNotRedirect) {
+                queryString += "&no_redirect=true";
+            }
+            const response = yield this.axios.post(this.getEndpoint(`/v1/login/oauth/authorize${queryString}`));
+            if (doNotRedirect) {
+                return response.data.redirectUrl;
+            }
+            return response.data;
+        });
+    }
+    /**
+     * A valid code can be used to request a new API token.
+     * @param tokenRequest contains the code, client_id, client_secret and redirect_uri
+     */
+    exchangeCodeForToken(tokenRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post(this.getEndpoint(`/v1/login/oauth/access_token`), tokenRequest);
+            return response.data;
+        });
+    }
+    getEndpoint(endpoint) {
+        return `${this.options.server}/api/account${endpoint}`;
+    }
+}
+exports.IdpOAuth = IdpOAuth;

package/lib/service/idp/organization/index.d.ts

@@ -0,0 +1,56 @@
+import Base from "../../../Base";
+import { Organization, OrganizationQueryOptions } from "../../../interfaces/idp/organization";
+import { IdpOrganizationLicense } from "./license";
+import { IdpOrganizationMember } from "./member";
+import IdpOrganizationSettings from "./settings";
+import { IdpOrganizationTeams } from "./team";
+export declare class IdpOrganization extends Base {
+    /**
+     * Handles everything around organization members
+     */
+    get member(): IdpOrganizationMember;
+    private _member?;
+    /**
+     * Handles everything around organization settings
+     */
+    get settings(): IdpOrganizationSettings;
+    private _settings?;
+    /**
+     * Handles everything around teams of organizations.
+     */
+    get teams(): IdpOrganizationTeams;
+    private _teams?;
+    /**
+     * Handles everything around licenses.
+     */
+    get license(): IdpOrganizationLicense;
+    private _license?;
+    /**
+     * Updates an Organization.
+     * @param orgName Current name of the Organization
+     * @param newName New name for the organization
+     * @param company (optional) New company name
+     * @returns The updated Organization
+     */
+    updateOrganization(orgName: string, newName: string, company?: string): Promise<Organization>;
+    /**
+     * Creates a new Organization.
+     * @param name Name of the new Organization
+     * @param company (optional) Company name for the new Organization
+     * @returns The created Organization
+     */
+    createOrganization(name: string, company?: string): Promise<Organization>;
+    /**
+     * Retrieves an Organization by its name.
+     * @param orgName Name of the Organization
+     * @param options Defines query options to retrieve additional properties in the response
+     * @returns The requested Organization
+     */
+    getOrganization(orgName: string, options?: OrganizationQueryOptions): Promise<Organization>;
+    /**
+     * Deletes an Organization. This will also delete all dependencies that the Organization has (Teams, Spaces, apps, ...).
+     * @param orgName Name of the Organization to be deleted
+     */
+    deleteOrganization(orgName: string): Promise<void>;
+    protected getEndpoint(endpoint: string): string;
+}