@arcforges/api-client 1.0.0-ci.19.1 → 1.0.0-ci.201.1

package/dist/shapes/gen/CatalogRevocations.d.ts

@@ -0,0 +1,46 @@
+export interface CatalogRevocations {
+    schemaVersion: string;
+    realmId: string;
+    channel: string;
+    revision: string;
+    issuedAt: string;
+    expiresAt: string;
+    keyId: string;
+    bodyHash: string;
+    body: RevocationBody;
+    signature: string;
+}
+export type RevocationBody = RevocationEntries | RevocationShards;
+export interface RevocationEntries {
+    entries: RevocationEntry[];
+}
+export interface RevocationEntry {
+    packageId: string;
+    version: string;
+    digest: string;
+    reason: string;
+    revokedAt: string;
+}
+export interface RevocationShards {
+    shards: RevocationShard[];
+}
+export interface RevocationShard {
+    url: string;
+    count: number;
+    sha256: string;
+}
+export declare function isCatalogRevocations(value: unknown): value is CatalogRevocations;
+/** The schema's declared UTF-8 document bound in bytes. */
+export declare const catalogRevocationsJsonMaxBytes = 1048576;
+/** Parses one strict CatalogRevocations document; refusal kinds match the C# codec. */
+export declare function tryParseCatalogRevocationsJson(input: Uint8Array | string): {
+    ok: true;
+    value: CatalogRevocations;
+} | {
+    ok: false;
+    failure: "tooLarge" | "malformed" | "invalid";
+};
+/** Parses one strict CatalogRevocations document or throws an error carrying the refusal kind. */
+export declare function parseCatalogRevocationsJson(input: Uint8Array | string): CatalogRevocations;
+/** Writes compact UTF-8 in schema property order and refuses output the schema rejects. */
+export declare function serializeCatalogRevocationsJson(value: CatalogRevocations): Uint8Array;

package/dist/shapes/gen/CatalogRevocations.js

@@ -0,0 +1,647 @@
+export function isCatalogRevocations(value) { return check0(value); }
+/** The schema's declared UTF-8 document bound in bytes. */
+export const catalogRevocationsJsonMaxBytes = 1048576;
+/** Parses one strict CatalogRevocations document; refusal kinds match the C# codec. */
+export function tryParseCatalogRevocationsJson(input) {
+    const parsed = strictJson(input, 1048576);
+    if (!parsed.ok)
+        return parsed;
+    return isCatalogRevocations(parsed.value) ? { ok: true, value: parsed.value } : { ok: false, failure: "invalid" };
+}
+/** Parses one strict CatalogRevocations document or throws an error carrying the refusal kind. */
+export function parseCatalogRevocationsJson(input) {
+    const result = tryParseCatalogRevocationsJson(input);
+    if (!result.ok)
+        throw Object.assign(new Error(`CatalogRevocations JSON refused: ${result.failure}.`), { failure: result.failure });
+    return result.value;
+}
+/** Writes compact UTF-8 in schema property order and refuses output the schema rejects. */
+export function serializeCatalogRevocationsJson(value) {
+    const bytes = new TextEncoder().encode(JSON.stringify(orderCatalogRevocations(value)));
+    const result = tryParseCatalogRevocationsJson(bytes);
+    if (!result.ok)
+        throw Object.assign(new Error(`CatalogRevocations JSON refused: ${result.failure}.`), { failure: result.failure });
+    return bytes;
+}
+function orderCatalogRevocations(value) {
+    const out = {};
+    out["schemaVersion"] = value["schemaVersion"];
+    out["realmId"] = value["realmId"];
+    out["channel"] = value["channel"];
+    out["revision"] = value["revision"];
+    out["issuedAt"] = value["issuedAt"];
+    out["expiresAt"] = value["expiresAt"];
+    out["keyId"] = value["keyId"];
+    out["bodyHash"] = value["bodyHash"];
+    out["body"] = orderRevocationBody(value["body"]);
+    out["signature"] = value["signature"];
+    return out;
+}
+function orderRevocationBody(value) {
+    if (check10(value))
+        return orderRevocationEntries(value);
+    if (check18(value))
+        return orderRevocationShards(value);
+    throw new TypeError('Invalid closed union');
+}
+function orderRevocationEntries(value) {
+    const out = {};
+    out["entries"] = value["entries"].map(item => orderRevocationEntry(item));
+    return out;
+}
+function orderRevocationEntry(value) {
+    const out = {};
+    out["packageId"] = value["packageId"];
+    out["version"] = value["version"];
+    out["digest"] = value["digest"];
+    out["reason"] = value["reason"];
+    out["revokedAt"] = value["revokedAt"];
+    return out;
+}
+function orderRevocationShard(value) {
+    const out = {};
+    out["url"] = value["url"];
+    out["count"] = value["count"];
+    out["sha256"] = value["sha256"];
+    return out;
+}
+function orderRevocationShards(value) {
+    const out = {};
+    out["shards"] = value["shards"].map(item => orderRevocationShard(item));
+    return out;
+}
+function check0(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "schemaVersion":
+                if (!check1(object[key]))
+                    return false;
+                break;
+            case "realmId":
+                if (!check2(object[key]))
+                    return false;
+                break;
+            case "channel":
+                if (!check3(object[key]))
+                    return false;
+                break;
+            case "revision":
+                if (!check4(object[key]))
+                    return false;
+                break;
+            case "issuedAt":
+                if (!check5(object[key]))
+                    return false;
+                break;
+            case "expiresAt":
+                if (!check6(object[key]))
+                    return false;
+                break;
+            case "keyId":
+                if (!check7(object[key]))
+                    return false;
+                break;
+            case "bodyHash":
+                if (!check8(object[key]))
+                    return false;
+                break;
+            case "body":
+                if (!check9(object[key]))
+                    return false;
+                break;
+            case "signature":
+                if (!check24(object[key]))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "schemaVersion"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "realmId"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "channel"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "revision"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "issuedAt"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "expiresAt"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "keyId"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "bodyHash"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "body"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "signature"))
+        return false;
+    return true;
+}
+function check1(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if (value !== "catalog-revocations.v1")
+        return false;
+    return true;
+}
+function check2(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 36)
+        return false;
+    if ((new RegExp("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    if (value === '00000000-0000-0000-0000-000000000000')
+        return false;
+    return true;
+}
+function check3(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z0-9][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check4(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 20)
+        return false;
+    if ((new RegExp("^(0|[1-9][0-9]*)$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    if (BigInt(value) > 18446744073709551615n)
+        return false;
+    return true;
+}
+function check5(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 32)
+        return false;
+    if ((new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.[0-9]{1,6})?Z$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check6(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 32)
+        return false;
+    if ((new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.[0-9]{1,6})?Z$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check7(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z0-9][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check8(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 64)
+        return false;
+    if ((new RegExp("^[0-9a-f]{64}$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check9(value) {
+    if ((check10(value) ? 1 : 0) + (check18(value) ? 1 : 0) !== 1)
+        return false;
+    return true;
+}
+function check10(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "entries":
+                if (!check11(object[key]))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "entries"))
+        return false;
+    return true;
+}
+function check11(value) {
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 0)
+        return false;
+    if (value.length > 1000)
+        return false;
+    if (!value.every(item => check12(item)))
+        return false;
+    return true;
+}
+function check12(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "packageId":
+                if (!check13(object[key]))
+                    return false;
+                break;
+            case "version":
+                if (!check14(object[key]))
+                    return false;
+                break;
+            case "digest":
+                if (!check15(object[key]))
+                    return false;
+                break;
+            case "reason":
+                if (!check16(object[key]))
+                    return false;
+                break;
+            case "revokedAt":
+                if (!check17(object[key]))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "packageId"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "version"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "digest"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "reason"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "revokedAt"))
+        return false;
+    return true;
+}
+function check13(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^[A-Za-z0-9][A-Za-z0-9._-]*$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check14(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 128)
+        return false;
+    if ((new RegExp("^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(-((0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*)(\\.(0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*))*))?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check15(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 64)
+        return false;
+    if ((new RegExp("^[0-9a-f]{64}$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check16(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 1024)
+        return false;
+    return true;
+}
+function check17(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 32)
+        return false;
+    if ((new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.[0-9]{1,6})?Z$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check18(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "shards":
+                if (!check19(object[key]))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "shards"))
+        return false;
+    return true;
+}
+function check19(value) {
+    if (!Array.isArray(value))
+        return false;
+    if (value.length < 1)
+        return false;
+    if (value.length > 1000)
+        return false;
+    if (!value.every(item => check20(item)))
+        return false;
+    return true;
+}
+function check20(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const object = value;
+    for (const key of Object.keys(object)) {
+        switch (key) {
+            case "url":
+                if (!check21(object[key]))
+                    return false;
+                break;
+            case "count":
+                if (!check22(object[key]))
+                    return false;
+                break;
+            case "sha256":
+                if (!check23(object[key]))
+                    return false;
+                break;
+            default: return false;
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(object, "url"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "count"))
+        return false;
+    if (!Object.prototype.hasOwnProperty.call(object, "sha256"))
+        return false;
+    return true;
+}
+function check21(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 2048)
+        return false;
+    if ((new RegExp("^https://[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*(?::(?:6553[0-5]|655[0-2][0-9]|65[0-4][0-9]{2}|6[0-4][0-9]{3}|[1-5][0-9]{4}|[1-9][0-9]{0,3}))?(/[^\\s#]*)?$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check22(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value))
+        return false;
+    if (value < 0)
+        return false;
+    if (value > 1000)
+        return false;
+    return true;
+}
+function check23(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 64)
+        return false;
+    if ((new RegExp("^[0-9a-f]{64}$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+function check24(value) {
+    if (typeof value !== 'string' || !validText(value))
+        return false;
+    if ([...value].length < 1)
+        return false;
+    if ([...value].length > 86)
+        return false;
+    if ((new RegExp("^[A-Za-z0-9_-]{85}[AQgw]$", 'u')).exec(value)?.[0] !== value)
+        return false;
+    return true;
+}
+/** Strict UTF-8 JSON: no BOM, comments, trailing commas or duplicate properties; depth <= 32; integer lexemes only. */
+function strictJson(input, maxBytes) {
+    let text;
+    if (typeof input === "string") {
+        if (!validText(input))
+            return { ok: false, failure: "malformed" };
+        if (new TextEncoder().encode(input).byteLength > maxBytes)
+            return { ok: false, failure: "tooLarge" };
+        text = input;
+    }
+    else {
+        if (input.byteLength > maxBytes)
+            return { ok: false, failure: "tooLarge" };
+        try {
+            text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(input);
+        }
+        catch {
+            return { ok: false, failure: "malformed" };
+        }
+    }
+    try {
+        return { ok: true, value: new StrictJsonReader(text).document() };
+    }
+    catch {
+        return { ok: false, failure: "malformed" };
+    }
+}
+class StrictJsonReader {
+    text;
+    index = 0;
+    constructor(text) {
+        this.text = text;
+    }
+    document() {
+        this.space();
+        const value = this.value(0);
+        this.space();
+        if (this.index !== this.text.length)
+            throw new SyntaxError("Trailing JSON content");
+        return value;
+    }
+    value(depth) {
+        switch (this.text[this.index]) {
+            case "{": return this.object(depth + 1);
+            case "[": return this.array(depth + 1);
+            case '"': return this.string();
+            case "t": return this.literal("true", true);
+            case "f": return this.literal("false", false);
+            case "n": return this.literal("null", null);
+            default: return this.number();
+        }
+    }
+    object(depth) {
+        if (depth > 32)
+            throw new SyntaxError("JSON depth exceeded");
+        this.index++;
+        const out = {};
+        const keys = new Set();
+        this.space();
+        if (this.text[this.index] === "}") {
+            this.index++;
+            return out;
+        }
+        for (;;) {
+            this.space();
+            if (this.text[this.index] !== '"')
+                throw new SyntaxError("Expected property name");
+            const key = this.string();
+            if (keys.has(key))
+                throw new SyntaxError("Duplicate JSON property");
+            keys.add(key);
+            this.space();
+            if (this.text[this.index++] !== ":")
+                throw new SyntaxError("Expected colon");
+            this.space();
+            // defineProperty keeps names such as __proto__ as ordinary own properties.
+            Object.defineProperty(out, key, { value: this.value(depth), enumerable: true, writable: true, configurable: true });
+            this.space();
+            const next = this.text[this.index++];
+            if (next === "}")
+                return out;
+            if (next !== ",")
+                throw new SyntaxError("Expected comma");
+        }
+    }
+    array(depth) {
+        if (depth > 32)
+            throw new SyntaxError("JSON depth exceeded");
+        this.index++;
+        const out = [];
+        this.space();
+        if (this.text[this.index] === "]") {
+            this.index++;
+            return out;
+        }
+        for (;;) {
+            this.space();
+            out.push(this.value(depth));
+            this.space();
+            const next = this.text[this.index++];
+            if (next === "]")
+                return out;
+            if (next !== ",")
+                throw new SyntaxError("Expected comma");
+        }
+    }
+    string() {
+        this.index++;
+        let out = "";
+        for (;;) {
+            const c = this.text[this.index++];
+            if (c === undefined)
+                throw new SyntaxError("Unterminated string");
+            if (c === '"')
+                break;
+            if (c < " ")
+                throw new SyntaxError("Unescaped control character");
+            if (c !== "\\") {
+                out += c;
+                continue;
+            }
+            const e = this.text[this.index++];
+            const simple = { '"': '"', "\\": "\\", "/": "/", b: "\b", f: "\f", n: "\n", r: "\r", t: "\t" };
+            if (e !== undefined && e in simple) {
+                out += simple[e];
+                continue;
+            }
+            if (e !== "u" || !/^[0-9a-fA-F]{4}$/.test(this.text.slice(this.index, this.index + 4)))
+                throw new SyntaxError("Invalid escape");
+            out += String.fromCharCode(parseInt(this.text.slice(this.index, this.index + 4), 16));
+            this.index += 4;
+        }
+        if (!validText(out))
+            throw new SyntaxError("Lone surrogate escape");
+        return out;
+    }
+    number() {
+        const match = /-?(?:0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/y;
+        match.lastIndex = this.index;
+        const found = match.exec(this.text);
+        if (found === null)
+            throw new SyntaxError("Invalid JSON value");
+        this.index = match.lastIndex;
+        // Selected schemas have no fractional numbers; fraction/exponent lexemes never satisfy an integer.
+        return found[1] !== undefined || found[2] !== undefined ? Number.NaN : Number(found[0]);
+    }
+    literal(word, value) {
+        if (this.text.slice(this.index, this.index + word.length) !== word)
+            throw new SyntaxError("Invalid JSON literal");
+        this.index += word.length;
+        return value;
+    }
+    space() {
+        while (this.text[this.index] === " " || this.text[this.index] === "\t" || this.text[this.index] === "\n" || this.text[this.index] === "\r")
+            this.index++;
+    }
+}
+function validText(value) {
+    for (const scalar of value) {
+        const point = scalar.codePointAt(0);
+        if (point >= 0xd800 && point <= 0xdfff)
+            return false;
+    }
+    return true;
+}
+function inventoryRules(value) {
+    const files = value.files;
+    const seen = new Set();
+    let previous;
+    let total = 0n;
+    for (const file of files) {
+        const path = file.path;
+        const folded = path.toUpperCase();
+        if (path.length === 0 || folded === 'INVENTORY.JSON' || folded === 'SIGNATURE.JSON' || seen.has(folded) || (previous !== undefined && previous >= path))
+            return false;
+        for (const segment of path.split('/')) {
+            if (!/^[A-Za-z0-9_.-]+$/.test(segment) || segment === '.' || segment === '..' || segment.endsWith('.') || /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(segment))
+                return false;
+        }
+        const size = BigInt(file.size);
+        if (size > 134217728n)
+            return false;
+        total += size;
+        if (total > 1073741824n)
+            return false;
+        seen.add(folded);
+        previous = path;
+    }
+    return files.some(file => file.path === 'manifest.json');
+}