hcloud-sdk 18.0.0 → 19.0.0

package/lib/interfaces/cosmo/stats/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/interfaces/cosmo/tag/tag.d.ts

@@ -8,5 +8,6 @@ export interface CreateTag {
     color?: string;
 }
 export interface PatchTag {
-    color: string;
+    name?: string;
+    color?: string;
 }

package/lib/interfaces/global/Products.d.ts

@@ -3,7 +3,6 @@ export declare enum Products {
     auditor = "auditor",
     mailer = "mailer",
     high5 = "high5",
-    fuse = "fuse",
     dali = "dali",
     client = "client",
     all = "all",

package/lib/interfaces/global/Products.js

@@ -7,7 +7,6 @@ var Products;
     Products["auditor"] = "auditor";
     Products["mailer"] = "mailer";
     Products["high5"] = "high5";
-    Products["fuse"] = "fuse";
     Products["dali"] = "dali";
     Products["client"] = "client";
     Products["all"] = "all";

package/lib/interfaces/global/Views.d.ts

@@ -4,6 +4,5 @@ export declare enum Views {
     high5 = "/high5",
     auditor = "/auditor",
     mailer = "/mailer",
-    fuse = "/fuse",
     cosmo = "/cosmo"
 }

package/lib/interfaces/global/Views.js

@@ -8,6 +8,5 @@ var Views;
     Views["high5"] = "/high5";
     Views["auditor"] = "/auditor";
     Views["mailer"] = "/mailer";
-    Views["fuse"] = "/fuse";
     Views["cosmo"] = "/cosmo";
 })(Views || (exports.Views = Views = {}));

package/lib/interfaces/high5/space/event/stream/design/StreamDesign.d.ts

@@ -46,6 +46,7 @@ export interface DesignerNodeInput {
     advanced?: boolean;
     type: StreamNodeSpecificationInputType;
     selectedLanguage?: StringMap;
+    expression?: boolean;
     example: string | number | boolean | string[] | StringMap | StringMap[] | SortedStringMap[];
     value?: string | number | boolean | string[] | StringMap | StringMap[] | SortedStringMap[];
     mandatory?: boolean;

package/lib/interfaces/high5/space/event/stream/node/index.d.ts

@@ -52,6 +52,7 @@ export interface StreamSingleNodeResult {
     uuid: string;
     nodeUuid: string;
     failed: boolean;
+    streamId?: string;
     startTimestamp: number;
     endTimestamp?: number;
     name: string;

package/lib/interfaces/high5/space/execution/index.d.ts

@@ -171,6 +171,7 @@ export interface StreamNode {
     breakpoint?: boolean;
     color?: string;
     nodeType?: NodeType;
+    streamId?: string;
 }
 export interface High5ExecuteOnAgentRequest {
     organizationName: string;

package/lib/interfaces/high5/space/job/index.d.ts

@@ -1,7 +1,62 @@
-import { Select } from "../../../../utils/Types";
-import { Header, HttpMethod, ReducedSpace } from "../../../global";
+import { ReducedSpace } from "../../../global";
 import { ReducedOrganization } from "../../../idp/organization";
 import { ReducedUser } from "../../../idp/user";
+import { ReducedEvent } from "../event";
+declare enum IntervalType {
+    MINUTE = "minute",
+    HOUR = "hour",
+    DAY = "day",
+    MONTH = "month",
+    YEAR = "year",
+    CUSTOM = "custom"
+}
+interface MinuteCronjob {
+    type: IntervalType.MINUTE;
+    values: {
+        minute: number;
+    };
+}
+interface HourCronjob {
+    type: IntervalType.HOUR;
+    values: {
+        hour: number;
+    };
+}
+interface DayCronjob {
+    type: IntervalType.DAY;
+    values: {
+        hour: number;
+        minute: number;
+    };
+}
+interface MonthCronjob {
+    type: IntervalType.MONTH;
+    values: {
+        day: number;
+        hour: number;
+        minute: number;
+    };
+}
+interface YearCronjob {
+    type: IntervalType.YEAR;
+    values: {
+        month: number;
+        day: number;
+        hour: number;
+        minute: number;
+    };
+}
+interface CustomCronjob {
+    type: IntervalType.CUSTOM;
+    values: {
+        year: number;
+        month: number;
+        day: number;
+        hour: number;
+        minute: number;
+    };
+}
+type CronjobType = MinuteCronjob | HourCronjob | DayCronjob | MonthCronjob | YearCronjob | CustomCronjob;
 export interface Job {
     _id: string;
     name: string;
@@ -9,30 +64,20 @@ export interface Job {
     organization: ReducedOrganization;
     creator: ReducedUser;
     space: ReducedSpace;
-    targetUrl: string;
-    httpMethod: HttpMethod;
-    acceptInvalidSSL: boolean;
+    targetEvent: ReducedEvent;
     timezone: string;
     description?: string;
-    headers?: Header[];
-    body?: string;
+    payload?: string;
     enabled?: boolean;
+    target: string;
     createDate: number;
     modifyDate: number;
     nextExecution?: number[];
     lastStatus?: number;
     lastTriggered?: number;
-    hmacSettings?: HmacSettings;
-}
-export type HmacSettings = {
-    headerName: string;
-    secret: string;
-    algorithm: HmacHashingAlgo;
-};
-export declare enum HmacHashingAlgo {
-    SHA_1 = "SHA-1",
-    SHA_256 = "SHA-256"
+    time?: CronjobType;
 }
-export type JobCreate = Pick<Job, "name" | "expression" | "targetUrl" | "httpMethod" | "headers" | "body" | "enabled" | "description" | "lastStatus" | "lastTriggered"> & Partial<Pick<Job, "acceptInvalidSSL" | "timezone">> & {
-    hmacSettings: Select<HmacSettings, "headerName" | "algorithm", "secret">;
+export type JobCreate = Pick<Job, "name" | "expression" | "payload" | "target" | "enabled" | "description" | "lastStatus" | "lastTriggered" | "time"> & {
+    targetEvent: string;
 };
+export {};

package/lib/interfaces/high5/space/job/index.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HmacHashingAlgo = void 0;
-var HmacHashingAlgo;
-(function (HmacHashingAlgo) {
-    HmacHashingAlgo["SHA_1"] = "SHA-1";
-    HmacHashingAlgo["SHA_256"] = "SHA-256";
-})(HmacHashingAlgo || (exports.HmacHashingAlgo = HmacHashingAlgo = {}));
+var IntervalType;
+(function (IntervalType) {
+    IntervalType["MINUTE"] = "minute";
+    IntervalType["HOUR"] = "hour";
+    IntervalType["DAY"] = "day";
+    IntervalType["MONTH"] = "month";
+    IntervalType["YEAR"] = "year";
+    IntervalType["CUSTOM"] = "custom";
+})(IntervalType || (IntervalType = {}));

package/lib/interfaces/high5/wave/dependentInputs.d.ts

@@ -0,0 +1,42 @@
+type Primitive = string | number | boolean | null | Date | undefined;
+type InputObject = Record<string, Primitive | Primitive[] | Record<string, Primitive>>;
+type ComparisonCondition<T extends Primitive> = {
+    $eq?: T;
+    $ne?: T;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+};
+type StringCondition = {
+    $contains?: string;
+    $startsWith?: string;
+    $endsWith?: string;
+    $regex?: string;
+};
+type ArrayCondition<T extends Primitive> = {
+    $in?: T[];
+    $nin?: T[];
+};
+type MetaCondition = {
+    $exists?: boolean;
+    $type?: "string" | "number" | "boolean" | "object";
+};
+type FieldCondition<T extends Primitive = Primitive> = ComparisonCondition<T> & StringCondition & ArrayCondition<T> & MetaCondition;
+type FieldQuery<T extends InputObject> = {
+    [K in keyof T]?: T[K] extends Primitive ? T[K] | FieldCondition<T[K]> : T[K] extends Primitive[] ? T[K] | ArrayCondition<T[K][number]> : T[K] extends Record<string, Primitive> ? NestedFieldQuery<T[K]> | Query<T[K]> : never;
+};
+/** Allows dot-notation-style conditions on nested object fields */
+type NestedFieldQuery<T extends Record<string, Primitive>> = {
+    [K in keyof T]?: T[K] | FieldCondition<T[K]>;
+};
+type LogicalQuery<T extends InputObject> = {
+    $and?: Query<T>[];
+    $or?: Query<T>[];
+    $nor?: Query<T>[];
+    $not?: Query<T>;
+};
+type Query<T extends InputObject = InputObject> = FieldQuery<T> & LogicalQuery<T>;
+declare function matchesQuery<T extends InputObject>(input: T, query: Query<T>): boolean;
+export type { Primitive, InputObject, FieldCondition, Query };
+export { matchesQuery };

package/lib/interfaces/high5/wave/dependentInputs.js

@@ -0,0 +1,144 @@
+"use strict";
+/* eslint-disable complexity */
+// ---------------------------------------------------------------------------
+// Primitive & input types
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesQuery = matchesQuery;
+// ---------------------------------------------------------------------------
+// Engine implementation
+// ---------------------------------------------------------------------------
+function matchesQuery(input, query) {
+    for (const key of Object.keys(query)) {
+        if (key === "$and") {
+            const clauses = query.$and;
+            if (!clauses.every(subQuery => matchesQuery(input, subQuery)))
+                return false;
+            continue;
+        }
+        if (key === "$or") {
+            const clauses = query.$or;
+            if (!clauses.some(subQuery => matchesQuery(input, subQuery)))
+                return false;
+            continue;
+        }
+        if (key === "$nor") {
+            const clauses = query.$nor;
+            if (clauses.some(subQuery => matchesQuery(input, subQuery)))
+                return false;
+            continue;
+        }
+        if (key === "$not") {
+            if (matchesQuery(input, query.$not))
+                return false;
+            continue;
+        }
+        // Field-level check
+        const fieldKey = key;
+        const fieldValue = input[fieldKey];
+        const condition = query[fieldKey];
+        if (condition === undefined)
+            continue;
+        // Nested object: recurse into it as a sub-query
+        if (fieldValue !== null &&
+            typeof fieldValue === "object" &&
+            !Array.isArray(fieldValue) &&
+            !(fieldValue instanceof Date) &&
+            !isFieldCondition(condition)) {
+            if (!matchesQuery(fieldValue, condition))
+                return false;
+        }
+        else if (isFieldCondition(condition)) {
+            if (!matchesCondition(fieldValue, condition))
+                return false;
+        }
+        else {
+            if (!isEqual(fieldValue, condition))
+                return false;
+        }
+    }
+    return true;
+}
+function matchesCondition(value, condition) {
+    // Comparison
+    if ("$eq" in condition && !isEqual(value, condition.$eq))
+        return false;
+    if ("$ne" in condition && isEqual(value, condition.$ne))
+        return false;
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if ("$gt" in condition && !(value > condition.$gt))
+        return false;
+    if ("$gte" in condition && !(value >= condition.$gte))
+        return false;
+    if ("$lt" in condition && !(value < condition.$lt))
+        return false;
+    if ("$lte" in condition && !(value <= condition.$lte))
+        return false;
+    // String
+    if ("$contains" in condition) {
+        if (typeof value !== "string" || !value.includes(condition.$contains))
+            return false;
+    }
+    if ("$startsWith" in condition) {
+        if (typeof value !== "string" || !value.startsWith(condition.$startsWith))
+            return false;
+    }
+    if ("$endsWith" in condition) {
+        if (typeof value !== "string" || !value.endsWith(condition.$endsWith))
+            return false;
+    }
+    if ("$regex" in condition) {
+        if (typeof value !== "string" || !new RegExp(condition.$regex).test(value))
+            return false;
+    }
+    // Array membership
+    if ("$in" in condition && !condition.$in.some(o => isEqual(value, o)))
+        return false;
+    if ("$nin" in condition && condition.$nin.some(o => isEqual(value, o)))
+        return false;
+    // Meta
+    if ("$exists" in condition) {
+        const exists = value !== undefined && value !== null;
+        if (condition.$exists !== exists)
+            return false;
+    }
+    if ("$type" in condition && typeof value !== condition.$type)
+        return false;
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function isFieldCondition(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const operators = [
+        "$eq",
+        "$ne",
+        "$gt",
+        "$gte",
+        "$lt",
+        "$lte",
+        "$contains",
+        "$startsWith",
+        "$endsWith",
+        "$regex",
+        "$in",
+        "$nin",
+        "$exists",
+        "$type",
+    ];
+    return Object.keys(value).some(k => operators.includes(k));
+}
+function isEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() === b.getTime();
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((v, i) => isEqual(v, b[i]));
+    }
+    return false;
+}

package/lib/interfaces/high5/wave/dependentInputsValidation.d.ts

@@ -0,0 +1,22 @@
+export type ValidationSuccess = {
+    valid: true;
+};
+export type ValidationError = {
+    valid: false;
+    errors: QueryValidationError[];
+};
+export type ValidationResult = ValidationSuccess | ValidationError;
+export type QueryValidationError = {
+    /** JSONPath-style location of the offending node, e.g. "$and[0].age" */
+    path: string;
+    message: string;
+};
+/**
+ * Validates the structure of a query object against the query schema.
+ * Returns a discriminated union: { valid: true } or { valid: false, errors[] }.
+ *
+ * Does NOT validate field names against a specific InputObject — it only
+ * checks that the query itself is structurally sound (correct operator
+ * positions, correct operand types, no unknown operators, etc.).
+ */
+export declare function validateQuery(query: unknown): ValidationResult;

package/lib/interfaces/high5/wave/dependentInputsValidation.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateQuery = validateQuery;
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const LOGICAL_OPERATORS = new Set(["$and", "$or", "$nor", "$not"]);
+const FIELD_OPERATORS = new Set([
+    "$eq",
+    "$ne",
+    "$gt",
+    "$gte",
+    "$lt",
+    "$lte",
+    "$contains",
+    "$startsWith",
+    "$endsWith",
+    "$regex",
+    "$in",
+    "$nin",
+    "$exists",
+    "$type",
+]);
+const VALID_TYPES = new Set(["string", "number", "boolean", "object"]);
+const PRIMITIVE_JS_TYPES = new Set(["string", "number", "boolean"]);
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Validates the structure of a query object against the query schema.
+ * Returns a discriminated union: { valid: true } or { valid: false, errors[] }.
+ *
+ * Does NOT validate field names against a specific InputObject — it only
+ * checks that the query itself is structurally sound (correct operator
+ * positions, correct operand types, no unknown operators, etc.).
+ */
+function validateQuery(query) {
+    const errors = [];
+    validateNode(query, "$", errors);
+    return errors.length === 0 ? { valid: true } : { valid: false, errors };
+}
+// ---------------------------------------------------------------------------
+// Internal recursive validator
+// ---------------------------------------------------------------------------
+function validateNode(node, path, errors) {
+    if (node === null || typeof node !== "object" || Array.isArray(node)) {
+        errors.push({ path, message: `Query node must be a plain object, got ${formatType(node)}` });
+        return;
+    }
+    for (const [key, value] of Object.entries(node)) {
+        const childPath = `${path}.${key}`;
+        if (LOGICAL_OPERATORS.has(key)) {
+            validateLogicalOperator(key, value, childPath, errors);
+        }
+        else if (key.startsWith("$")) {
+            errors.push({ path: childPath, message: `Unknown operator "${key}"` });
+        }
+        else {
+            // Field key — value is either a primitive, an array, a condition object,
+            // or a nested sub-query object.
+            validateFieldValue(value, childPath, errors);
+        }
+    }
+}
+function validateLogicalOperator(op, value, path, errors) {
+    if (op === "$not") {
+        // $not takes a single sub-query object
+        if (value === null || typeof value !== "object" || Array.isArray(value)) {
+            errors.push({ path, message: `"$not" must be a query object, got ${formatType(value)}` });
+            return;
+        }
+        validateNode(value, path, errors);
+        return;
+    }
+    // $and / $or / $nor take a non-empty array of sub-query objects
+    if (!Array.isArray(value)) {
+        errors.push({ path, message: `"${op}" must be an array, got ${formatType(value)}` });
+        return;
+    }
+    if (value.length === 0) {
+        errors.push({ path, message: `"${op}" array must not be empty` });
+        return;
+    }
+    for (let i = 0; i < value.length; i++) {
+        validateNode(value[i], `${path}[${i}]`, errors);
+    }
+}
+function validateFieldValue(value, path, errors) {
+    // Plain primitive — shorthand equality
+    if (isPrimitive(value))
+        return;
+    // Array — must be an array of primitives (shorthand $in-style direct value)
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            if (!isPrimitive(value[i])) {
+                errors.push({
+                    path: `${path}[${i}]`,
+                    message: `Array field values must be primitives, got ${formatType(value[i])}`,
+                });
+            }
+        }
+        return;
+    }
+    if (value === null || typeof value !== "object") {
+        errors.push({ path, message: `Field value must be a primitive, array, or object, got ${formatType(value)}` });
+        return;
+    }
+    const keys = Object.keys(value);
+    const hasOperatorKeys = keys.some(k => k.startsWith("$"));
+    const hasFieldKeys = keys.some(k => !k.startsWith("$"));
+    if (hasOperatorKeys && hasFieldKeys) {
+        errors.push({ path, message: "Field condition must not mix operator keys and plain field keys" });
+        return;
+    }
+    if (hasOperatorKeys) {
+        // Treat as a FieldCondition object
+        validateFieldCondition(value, path, errors);
+    }
+    else {
+        // Treat as a nested sub-query object
+        validateNode(value, path, errors);
+    }
+}
+function validateFieldCondition(condition, path, errors) {
+    for (const [op, operand] of Object.entries(condition)) {
+        const opPath = `${path}.${op}`;
+        if (!FIELD_OPERATORS.has(op)) {
+            errors.push({ path: opPath, message: `Unknown field operator "${op}"` });
+            continue;
+        }
+        switch (op) {
+            // Operand must be a primitive
+            case "$eq":
+            case "$ne":
+            case "$gt":
+            case "$gte":
+            case "$lt":
+            case "$lte":
+                if (!isPrimitive(operand)) {
+                    errors.push({ path: opPath, message: `"${op}" operand must be a primitive, got ${formatType(operand)}` });
+                }
+                break;
+            // Operand must be a string
+            case "$contains":
+            case "$startsWith":
+            case "$endsWith":
+            case "$regex":
+                if (typeof operand !== "string") {
+                    errors.push({ path: opPath, message: `"${op}" operand must be a string, got ${formatType(operand)}` });
+                }
+                // Extra: validate that $regex is a valid regular expression
+                if (op === "$regex") {
+                    try {
+                        new RegExp(operand);
+                    }
+                    catch (_a) {
+                        errors.push({ path: opPath, message: `"$regex" operand is not a valid regular expression` });
+                    }
+                }
+                break;
+            // Operand must be a non-empty array of primitives
+            case "$in":
+            case "$nin":
+                if (!Array.isArray(operand)) {
+                    errors.push({ path: opPath, message: `"${op}" operand must be an array, got ${formatType(operand)}` });
+                }
+                else {
+                    if (operand.length === 0) {
+                        errors.push({ path: opPath, message: `"${op}" operand array must not be empty` });
+                    }
+                    for (let i = 0; i < operand.length; i++) {
+                        if (!isPrimitive(operand[i])) {
+                            errors.push({
+                                path: `${opPath}[${i}]`,
+                                message: `"${op}" array elements must be primitives, got ${formatType(operand[i])}`,
+                            });
+                        }
+                    }
+                }
+                break;
+            // Operand must be a boolean
+            case "$exists":
+                if (typeof operand !== "boolean") {
+                    errors.push({ path: opPath, message: `"$exists" operand must be a boolean, got ${formatType(operand)}` });
+                }
+                break;
+            // Operand must be one of the valid type strings
+            case "$type":
+                if (typeof operand !== "string" || !VALID_TYPES.has(operand)) {
+                    errors.push({
+                        path: opPath,
+                        message: `"$type" operand must be one of: ${[...VALID_TYPES].map(t => `"${t}"`).join(", ")}, got ${formatType(operand)}`,
+                    });
+                }
+                break;
+            default:
+                errors.push({ path: opPath, message: `Unknown field operator "${op}"` });
+                break;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function isPrimitive(value) {
+    if (value === null)
+        return true;
+    if (value instanceof Date)
+        return true;
+    return PRIMITIVE_JS_TYPES.has(typeof value);
+}
+function formatType(value) {
+    if (value === null)
+        return "null";
+    if (value instanceof Date)
+        return "Date";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}

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

@@ -2,17 +2,17 @@ export * from "./oauth";
 export * from "./organization";
 export * from "./organization/member";
 export * from "./organization/member/invitations";
-export * from "./organization/team";
+export * from "./organization/service-accounts";
 export * from "./organization/settings/domain";
 export * from "./organization/settings/domain/saml";
 export * from "./organization/settings/oauthApp";
-export * from "./organization/service-accounts";
+export * from "./organization/team";
+export * from "./user";
 export * from "./user/GeneralSettings";
 export * from "./user/Pat";
 export * from "./user/Scopes";
 export * from "./user/SuccessfulAuth";
 export * from "./user/Totp";
-export * from "./user";
 export declare enum PreLoginPath {
     LOGIN = "LOGIN",
     REGISTER = "REGISTER",

package/lib/interfaces/idp/index.js

@@ -19,17 +19,17 @@ __exportStar(require("./oauth"), exports);
 __exportStar(require("./organization"), exports);
 __exportStar(require("./organization/member"), exports);
 __exportStar(require("./organization/member/invitations"), exports);
-__exportStar(require("./organization/team"), exports);
+__exportStar(require("./organization/service-accounts"), exports);
 __exportStar(require("./organization/settings/domain"), exports);
 __exportStar(require("./organization/settings/domain/saml"), exports);
 __exportStar(require("./organization/settings/oauthApp"), exports);
-__exportStar(require("./organization/service-accounts"), exports);
+__exportStar(require("./organization/team"), exports);
+__exportStar(require("./user"), exports);
 __exportStar(require("./user/GeneralSettings"), exports);
 __exportStar(require("./user/Pat"), exports);
 __exportStar(require("./user/Scopes"), exports);
 __exportStar(require("./user/SuccessfulAuth"), exports);
 __exportStar(require("./user/Totp"), exports);
-__exportStar(require("./user"), exports);
 var PreLoginPath;
 (function (PreLoginPath) {
     PreLoginPath["LOGIN"] = "LOGIN";