samiandClaude Sonnet 5
60363a7142
Minor bump on 1.0.0, per core/docs/buffer-sizing.md. B4 — bufferBytes bounds corrected in all four locations (DownloadSpec, TaskDetail, download.update's patch, Settings.connection.bufferBytes): was 4 KiB-8 MiB with no stated default, now 64 KiB-16 MiB with a 1 MiB default. 64 KiB because 4 KiB is smaller than one libcurl HTTP/2 write-callback delivery; 16 MiB because throughput from write size is flat past ~1-4 MiB and past 16 MiB there is stall-cover left to buy but no memory left to spend it on; 1 MiB default because it is the only candidate for which docs/04's 60 MB RSS target actually holds once buffers are counted per segment, not per download. Two new settings keys: connection.maxTotalBufferBytes (128 MiB default) and connection.maxActiveSegments (32 default). Without them CORE's clamp — reduce every live segment's buffer to fit the global cap — has no wire configuration surface, and "20 active downloads" has no meaning distinct from 160 live TLS connections. B2a — TaskDetail.effectiveBufferBytes: what a segment is actually using right now, after the clamp. Placed on TaskDetail next to bufferBytes, following the requested/effective pattern ADR 0010 already established for segments. The download.get fixture now demonstrates a real clamp (16 MiB requested, 4 MiB effective) rather than a case where the cap happens not to bind. docs/04-engine-design.md §4 and §8 updated in the same change per CORE's request and CLAUDE.md rule 5: the RSS target is now stated as conditional on maxActiveSegments = 32, and the old 4 MiB/64 MiB/256 MiB numbers are corrected to match the schema. ADR 0012 records the reasoning and explicitly keeps the 60 MB target over CORE's offered 120 MB alternative, with the arithmetic that makes 60 MB achievable with margin. Numbered 0012 rather than 0011: DAEMON is independently drafting ADR 0011 (admission control / segment budget split) in a peer session at time of writing, so 0011 was reserved to avoid a collision. Co-Authored-By: Claude Sonnet 5 <[email protected]> Claude-Session: https://claude.ai/code/session_012fgjnqFCS5h5L7gZTZo3rV
2175 lines
90 KiB
TypeScript
2175 lines
90 KiB
TypeScript
// ---------------------------------------------------------------------------
|
|
// GENERATED FILE — DO NOT EDIT.
|
|
//
|
|
// Source: contracts/schema/**
|
|
// Generator: contracts/codegen/gen_ts.py
|
|
// Contract: v1.1.0
|
|
//
|
|
// Hand-editing this file is a merge blocker. Fix the schema and regenerate:
|
|
// python3 contracts/codegen/gen_ts.py
|
|
// Only lane PROTO commits to contracts/.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
import type {
|
|
AuthRequiredEvent,
|
|
AuthRequiredEventScheme,
|
|
BulkTaskResult,
|
|
BulkTaskResultFailedItem,
|
|
BulkTaskResultUpdatedItem,
|
|
BypassModifier,
|
|
CaptureGetRulesParams,
|
|
CaptureOfferParams,
|
|
CaptureOfferParamsMethod,
|
|
CaptureOfferResult,
|
|
CaptureOfferResultAction,
|
|
CaptureOfferResultReason,
|
|
CaptureRules,
|
|
Category,
|
|
CategoryListParams,
|
|
CategoryListResult,
|
|
CategoryRemoveParams,
|
|
CategoryRemoveResult,
|
|
CategoryUpsertParams,
|
|
CategoryUpsertResult,
|
|
Checksum,
|
|
ChecksumAlgorithm,
|
|
Cookie,
|
|
DownloadAddBatchParams,
|
|
DownloadAddBatchResult,
|
|
DownloadAddBatchResultFailedItem,
|
|
DownloadAddResult,
|
|
DownloadCancelParams,
|
|
DownloadGetParams,
|
|
DownloadListParams,
|
|
DownloadListResult,
|
|
DownloadPauseParams,
|
|
DownloadProbeParams,
|
|
DownloadProbeResult,
|
|
DownloadRefreshUrlParams,
|
|
DownloadRefreshUrlResult,
|
|
DownloadRemoveParams,
|
|
DownloadRemoveResult,
|
|
DownloadRemoveResultFailedItem,
|
|
DownloadResumeParams,
|
|
DownloadSpec,
|
|
DownloadStartParams,
|
|
DownloadUpdateParams,
|
|
DownloadUpdateParamsPatch,
|
|
GrabberFile,
|
|
GrabberHarvestParams,
|
|
GrabberHarvestResult,
|
|
GrabberHarvestResultFailedItem,
|
|
GrabberProgressEvent,
|
|
GrabberStartParams,
|
|
GrabberStartResult,
|
|
GrabberStatusParams,
|
|
GrabberStatusResult,
|
|
GrabberStatusResultState,
|
|
Headers,
|
|
Limiter,
|
|
LimiterGetParams,
|
|
MediaAddVariantParams,
|
|
MediaAddVariantResult,
|
|
MediaListVariantsParams,
|
|
MediaListVariantsResult,
|
|
MediaListVariantsResultManifestType,
|
|
MediaVariant,
|
|
MediaVariantContainer,
|
|
MediaVariantKind,
|
|
NotifyEvent,
|
|
NotifyEventLevel,
|
|
NotifyEventSound,
|
|
Queue,
|
|
QueueListParams,
|
|
QueueListResult,
|
|
QueueOnComplete,
|
|
QueueReorderParams,
|
|
QueueReorderResult,
|
|
QueueStartParams,
|
|
QueueStartResult,
|
|
QueueState,
|
|
QueueStopParams,
|
|
QueueStopResult,
|
|
QueueUpsertParams,
|
|
QueueUpsertResult,
|
|
Rule,
|
|
RuleAction,
|
|
RuleActionCapture,
|
|
RuleMatch,
|
|
RulesListParams,
|
|
RulesListResult,
|
|
RulesUpsertParams,
|
|
RulesUpsertResult,
|
|
Schedule,
|
|
ScheduleGetParams,
|
|
ScheduleGetResult,
|
|
ScheduleGetResultItemsItem,
|
|
ScheduleMode,
|
|
ScheduleSetParams,
|
|
ScheduleSetResult,
|
|
Segment,
|
|
SegmentState,
|
|
SessionHelloParams,
|
|
SessionHelloParamsClientType,
|
|
SessionHelloResult,
|
|
SessionHelloResultTransport,
|
|
SessionPairParams,
|
|
SessionPairResult,
|
|
SessionSubscribeParams,
|
|
SessionSubscribeParamsEventsItem,
|
|
SessionSubscribeResult,
|
|
SettingKey,
|
|
Settings,
|
|
SettingsChangedEvent,
|
|
SettingsConnectionPreset,
|
|
SettingsDownloadsDuplicatePolicy,
|
|
SettingsGetParams,
|
|
SettingsGetResult,
|
|
SettingsProxyMode,
|
|
SettingsSaveToFileExistsPolicy,
|
|
SettingsSetParams,
|
|
SettingsSetResult,
|
|
SpeedGlobalEvent,
|
|
StartMode,
|
|
TaskAddedEvent,
|
|
TaskDetail,
|
|
TaskError,
|
|
TaskErrorCode,
|
|
TaskFilter,
|
|
TaskProgressEvent,
|
|
TaskProgressEventTasksItem,
|
|
TaskProgressEventTasksItemSegmentsItem,
|
|
TaskRemovedEvent,
|
|
TaskSort,
|
|
TaskSortDirection,
|
|
TaskSortField,
|
|
TaskState,
|
|
TaskStateEvent,
|
|
TaskSummary,
|
|
} from './types.js';
|
|
import {
|
|
AUTH_REQUIRED_EVENT_SCHEME_VALUES,
|
|
BYPASS_MODIFIER_VALUES,
|
|
CAPTURE_OFFER_PARAMS_METHOD_VALUES,
|
|
CAPTURE_OFFER_RESULT_ACTION_VALUES,
|
|
CAPTURE_OFFER_RESULT_REASON_VALUES,
|
|
CHECKSUM_ALGORITHM_VALUES,
|
|
ErrorCode,
|
|
GRABBER_STATUS_RESULT_STATE_VALUES,
|
|
MEDIA_LIST_VARIANTS_RESULT_MANIFEST_TYPE_VALUES,
|
|
MEDIA_VARIANT_CONTAINER_VALUES,
|
|
MEDIA_VARIANT_KIND_VALUES,
|
|
NOTIFY_EVENT_LEVEL_VALUES,
|
|
NOTIFY_EVENT_SOUND_VALUES,
|
|
QUEUE_ON_COMPLETE_VALUES,
|
|
QUEUE_STATE_VALUES,
|
|
RULE_ACTION_CAPTURE_VALUES,
|
|
SCHEDULE_MODE_VALUES,
|
|
SEGMENT_STATE_VALUES,
|
|
SESSION_HELLO_PARAMS_CLIENT_TYPE_VALUES,
|
|
SESSION_HELLO_RESULT_TRANSPORT_VALUES,
|
|
SESSION_SUBSCRIBE_PARAMS_EVENTS_ITEM_VALUES,
|
|
SETTING_KEY_VALUES,
|
|
SETTINGS_CONNECTION_PRESET_VALUES,
|
|
SETTINGS_DOWNLOADS_DUPLICATE_POLICY_VALUES,
|
|
SETTINGS_PROXY_MODE_VALUES,
|
|
SETTINGS_SAVE_TO_FILE_EXISTS_POLICY_VALUES,
|
|
START_MODE_VALUES,
|
|
TASK_ERROR_CODE_VALUES,
|
|
TASK_SORT_DIRECTION_VALUES,
|
|
TASK_SORT_FIELD_VALUES,
|
|
TASK_STATE_VALUES,
|
|
} from './types.js';
|
|
import { isEventName, type EventMap, type EventName } from './events.js';
|
|
import { isMethodName, type MethodMap, type MethodName } from './methods.js';
|
|
|
|
/**
|
|
* Runtime validation for everything that crosses the wire.
|
|
*
|
|
* The daemon does not trust the extension and the extension does not trust the daemon:
|
|
* `ws://127.0.0.1` is reachable by any local process, so a TypeScript type proves nothing
|
|
* at runtime. Every inbound payload goes through one of these before it is used.
|
|
*
|
|
* Validators mirror the C++ side exactly, including the rule that an absent field and an
|
|
* explicit null mean the same thing.
|
|
*/
|
|
|
|
export type Validated<T> =
|
|
| { ok: true; value: T }
|
|
| { ok: false; path: string; message: string };
|
|
|
|
export type Validator<T> = (v: unknown, path: string) => Validated<T>;
|
|
|
|
function fail(path: string, message: string): Validated<never> {
|
|
return { ok: false, path, message };
|
|
}
|
|
|
|
function join(path: string, key: string): string {
|
|
return path ? `${path}/${key}` : `/${key}`;
|
|
}
|
|
|
|
function isPlainObject(v: unknown): v is Record<string, unknown> {
|
|
return typeof v === 'object' && v !== null && !Array.isArray(v);
|
|
}
|
|
|
|
export const vString: Validator<string> = (v, p) =>
|
|
typeof v === 'string' ? { ok: true, value: v } : fail(p, 'expected a string');
|
|
|
|
export const vNumber: Validator<number> = (v, p) =>
|
|
typeof v === 'number' && Number.isFinite(v) ? { ok: true, value: v } : fail(p, 'expected a number');
|
|
|
|
export const vInteger: Validator<number> = (v, p) =>
|
|
typeof v === 'number' && Number.isInteger(v) ? { ok: true, value: v } : fail(p, 'expected an integer');
|
|
|
|
export const vBoolean: Validator<boolean> = (v, p) =>
|
|
typeof v === 'boolean' ? { ok: true, value: v } : fail(p, 'expected a boolean');
|
|
|
|
export const vUnknown: Validator<unknown> = (v) => ({ ok: true, value: v });
|
|
|
|
function vArray<T>(inner: Validator<T>): Validator<T[]> {
|
|
return (v, p) => {
|
|
if (!Array.isArray(v)) return fail(p, 'expected an array');
|
|
const out: T[] = [];
|
|
for (let i = 0; i < v.length; i += 1) {
|
|
const r = inner(v[i], join(p, String(i)));
|
|
if (!r.ok) return r;
|
|
out.push(r.value);
|
|
}
|
|
return { ok: true, value: out };
|
|
};
|
|
}
|
|
|
|
function vRecord<T>(inner: Validator<T>): Validator<Record<string, T>> {
|
|
return (v, p) => {
|
|
if (!isPlainObject(v)) return fail(p, 'expected an object');
|
|
const out: Record<string, T> = {};
|
|
for (const [k, raw] of Object.entries(v)) {
|
|
const r = inner(raw, join(p, k));
|
|
if (!r.ok) return r;
|
|
out[k] = r.value;
|
|
}
|
|
return { ok: true, value: out };
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Range, length and pattern checks. The wire is untrusted, so a `maximum` in the schema
|
|
* has to be a check at runtime — a TypeScript type cannot enforce one.
|
|
*/
|
|
interface Limits {
|
|
readonly minimum?: number;
|
|
readonly maximum?: number;
|
|
readonly minLength?: number;
|
|
readonly maxLength?: number;
|
|
readonly pattern?: RegExp;
|
|
readonly minItems?: number;
|
|
readonly maxItems?: number;
|
|
}
|
|
|
|
function vLimited<T>(inner: Validator<T>, limits: Limits): Validator<T> {
|
|
return (v, p) => {
|
|
const r = inner(v, p);
|
|
if (!r.ok) return r;
|
|
const value = r.value;
|
|
if (typeof value === 'number') {
|
|
if (limits.minimum !== undefined && value < limits.minimum)
|
|
return fail(p, `value is below the minimum of ${limits.minimum}`);
|
|
if (limits.maximum !== undefined && value > limits.maximum)
|
|
return fail(p, `value is above the maximum of ${limits.maximum}`);
|
|
} else if (typeof value === 'string') {
|
|
if (limits.minLength !== undefined && value.length < limits.minLength)
|
|
return fail(p, `value is shorter than ${limits.minLength} characters`);
|
|
if (limits.maxLength !== undefined && value.length > limits.maxLength)
|
|
return fail(p, `value is longer than ${limits.maxLength} characters`);
|
|
if (limits.pattern !== undefined && !limits.pattern.test(value))
|
|
return fail(p, 'value does not match the required pattern');
|
|
} else if (Array.isArray(value)) {
|
|
if (limits.minItems !== undefined && value.length < limits.minItems)
|
|
return fail(p, `fewer than ${limits.minItems} items`);
|
|
if (limits.maxItems !== undefined && value.length > limits.maxItems)
|
|
return fail(p, `more than ${limits.maxItems} items`);
|
|
}
|
|
return r;
|
|
};
|
|
}
|
|
|
|
function vEnum<T extends string>(values: readonly T[], name: string): Validator<T> {
|
|
return (v, p) =>
|
|
typeof v === 'string' && (values as readonly string[]).includes(v)
|
|
? { ok: true, value: v as T }
|
|
: fail(p, `not a valid ${name}`);
|
|
}
|
|
|
|
function vIntEnum<T extends number>(values: readonly T[], name: string): Validator<T> {
|
|
return (v, p) =>
|
|
typeof v === 'number' && (values as readonly number[]).includes(v)
|
|
? { ok: true, value: v as T }
|
|
: fail(p, `not a valid ${name}`);
|
|
}
|
|
|
|
/** Required: must be present and non-null. */
|
|
function req<T>(
|
|
obj: Record<string, unknown>,
|
|
key: string,
|
|
path: string,
|
|
inner: Validator<T>,
|
|
out: Record<string, unknown>,
|
|
): Validated<null> {
|
|
const raw = obj[key];
|
|
if (raw === undefined || raw === null) return fail(join(path, key), 'required field is missing');
|
|
const r = inner(raw, join(path, key));
|
|
if (!r.ok) return r;
|
|
out[key] = r.value;
|
|
return { ok: true, value: null };
|
|
}
|
|
|
|
/** Optional: absent and null are the same thing, exactly as on the C++ side. */
|
|
function opt<T>(
|
|
obj: Record<string, unknown>,
|
|
key: string,
|
|
path: string,
|
|
inner: Validator<T>,
|
|
out: Record<string, unknown>,
|
|
): Validated<null> {
|
|
const raw = obj[key];
|
|
if (raw === undefined || raw === null) return { ok: true, value: null };
|
|
const r = inner(raw, join(path, key));
|
|
if (!r.ok) return r;
|
|
out[key] = r.value;
|
|
return { ok: true, value: null };
|
|
}
|
|
|
|
/** Validate an untrusted value as BulkTaskResult. */
|
|
export function validateBulkTaskResult(v: unknown, path = ''): Validated<BulkTaskResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "updated", path, vArray(validateBulkTaskResultUpdatedItem), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "failed", path, vArray(validateBulkTaskResultFailedItem), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as BulkTaskResult };
|
|
}
|
|
|
|
export const validateTaskState: Validator<TaskState> = vEnum(TASK_STATE_VALUES, 'TaskState');
|
|
|
|
/** Validate an untrusted value as BulkTaskResultUpdatedItem. */
|
|
export function validateBulkTaskResultUpdatedItem(v: unknown, path = ''): Validated<BulkTaskResultUpdatedItem> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "state", path, validateTaskState, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "changed", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as BulkTaskResultUpdatedItem };
|
|
}
|
|
|
|
const ERROR_CODE_VALUES = Object.values(ErrorCode) as ErrorCode[];
|
|
export const validateErrorCode: Validator<ErrorCode> = vIntEnum(ERROR_CODE_VALUES, 'ErrorCode');
|
|
|
|
/** Validate an untrusted value as BulkTaskResultFailedItem. */
|
|
export function validateBulkTaskResultFailedItem(v: unknown, path = ''): Validated<BulkTaskResultFailedItem> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "code", path, validateErrorCode, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "message", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as BulkTaskResultFailedItem };
|
|
}
|
|
|
|
export const validateBypassModifier: Validator<BypassModifier> = vEnum(BYPASS_MODIFIER_VALUES, 'BypassModifier');
|
|
|
|
/** Validate an untrusted value as CaptureRules. */
|
|
export function validateCaptureRules(v: unknown, path = ''): Validated<CaptureRules> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "enabled", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "monitoredExtensions", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "monitoredMimeTypes", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "minSizeBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "excludedHosts", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "bypassModifier", path, validateBypassModifier, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "rulesVersion", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as CaptureRules };
|
|
}
|
|
|
|
/** Validate an untrusted value as Category. */
|
|
export function validateCategory(v: unknown, path = ''): Validated<Category> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "categoryId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "name", path, vLimited(vString, { maxLength: 64 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "saveDir", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "extensions", path, vArray(vLimited(vString, { pattern: /^[A-Za-z0-9][A-Za-z0-9+._-]*$/ })), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "mimeTypes", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "builtin", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sortOrder", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as Category };
|
|
}
|
|
|
|
/** Validate an untrusted value as Checksum. */
|
|
export function validateChecksum(v: unknown, path = ''): Validated<Checksum> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "algorithm", path, validateChecksumAlgorithm, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "value", path, vLimited(vString, { pattern: /^[0-9a-fA-F]{32,128}$/ }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as Checksum };
|
|
}
|
|
|
|
export const validateChecksumAlgorithm: Validator<ChecksumAlgorithm> = vEnum(CHECKSUM_ALGORITHM_VALUES, 'ChecksumAlgorithm');
|
|
|
|
/** Validate an untrusted value as Cookie. */
|
|
export function validateCookie(v: unknown, path = ''): Validated<Cookie> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "name", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "value", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "domain", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "path", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "secure", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "httpOnly", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as Cookie };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadSpec. */
|
|
export function validateDownloadSpec(v: unknown, path = ''): Validated<DownloadSpec> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "url", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "headers", path, validateHeaders, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "cookies", path, vArray(validateCookie), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "referrer", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "userAgent", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "filename", path, vLimited(vString, { maxLength: 255 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "saveDir", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "categoryId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "segments", path, vLimited(vInteger, { minimum: 1, maximum: 32 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "bufferBytes", path, vLimited(vInteger, { minimum: 65536, maximum: 16777216 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "startMode", path, validateStartMode, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "description", path, vLimited(vString, { maxLength: 1024 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "checksum", path, validateChecksum, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadSpec };
|
|
}
|
|
|
|
export const validateHeaders: Validator<Headers> = vRecord(vString);
|
|
|
|
export const validateStartMode: Validator<StartMode> = vEnum(START_MODE_VALUES, 'StartMode');
|
|
|
|
/** Validate an untrusted value as GrabberFile. */
|
|
export function validateGrabberFile(v: unknown, path = ''): Validated<GrabberFile> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "fileId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "url", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "filename", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sizeBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "contentType", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "depth", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "foundOn", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as GrabberFile };
|
|
}
|
|
|
|
/** Validate an untrusted value as Limiter. */
|
|
export function validateLimiter(v: unknown, path = ''): Validated<Limiter> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "enabled", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "globalBps", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "applyToRunning", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as Limiter };
|
|
}
|
|
|
|
/** Validate an untrusted value as MediaVariant. */
|
|
export function validateMediaVariant(v: unknown, path = ''): Validated<MediaVariant> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "variantId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "kind", path, validateMediaVariantKind, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "resolution", path, vLimited(vString, { pattern: /^[0-9]{2,5}x[0-9]{2,5}$/ }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "bitrateBps", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "codec", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "container", path, validateMediaVariantContainer, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "frameRate", path, vLimited(vNumber, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "language", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sizeEstimate", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "drm", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as MediaVariant };
|
|
}
|
|
|
|
export const validateMediaVariantKind: Validator<MediaVariantKind> = vEnum(MEDIA_VARIANT_KIND_VALUES, 'MediaVariantKind');
|
|
|
|
export const validateMediaVariantContainer: Validator<MediaVariantContainer> = vEnum(MEDIA_VARIANT_CONTAINER_VALUES, 'MediaVariantContainer');
|
|
|
|
/** Validate an untrusted value as Queue. */
|
|
export function validateQueue(v: unknown, path = ''): Validated<Queue> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "name", path, vLimited(vString, { maxLength: 64 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "state", path, validateQueueState, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "maxConcurrent", path, vLimited(vInteger, { minimum: 1, maximum: 32 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "taskIds", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "schedule", path, validateSchedule, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "onComplete", path, validateQueueOnComplete, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as Queue };
|
|
}
|
|
|
|
export const validateQueueState: Validator<QueueState> = vEnum(QUEUE_STATE_VALUES, 'QueueState');
|
|
|
|
/** Validate an untrusted value as Schedule. */
|
|
export function validateSchedule(v: unknown, path = ''): Validated<Schedule> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "enabled", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "mode", path, validateScheduleMode, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "startTime", path, vLimited(vString, { pattern: /^([01][0-9]|2[0-3]):[0-5][0-9]$/ }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "stopTime", path, vLimited(vString, { pattern: /^([01][0-9]|2[0-3]):[0-5][0-9]$/ }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "daysOfWeek", path, vArray(vLimited(vInteger, { minimum: 0, maximum: 6 })), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "onceDate", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as Schedule };
|
|
}
|
|
|
|
export const validateScheduleMode: Validator<ScheduleMode> = vEnum(SCHEDULE_MODE_VALUES, 'ScheduleMode');
|
|
|
|
export const validateQueueOnComplete: Validator<QueueOnComplete> = vEnum(QUEUE_ON_COMPLETE_VALUES, 'QueueOnComplete');
|
|
|
|
/** Validate an untrusted value as Rule. */
|
|
export function validateRule(v: unknown, path = ''): Validated<Rule> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "ruleId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "name", path, vLimited(vString, { maxLength: 64 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "enabled", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "priority", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "match", path, validateRuleMatch, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "action", path, validateRuleAction, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as Rule };
|
|
}
|
|
|
|
/** Validate an untrusted value as RuleMatch. */
|
|
export function validateRuleMatch(v: unknown, path = ''): Validated<RuleMatch> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = opt(v, "extensions", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "mimeTypes", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "hostPattern", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "urlPattern", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "minSizeBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "maxSizeBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as RuleMatch };
|
|
}
|
|
|
|
export const validateRuleActionCapture: Validator<RuleActionCapture> = vEnum(RULE_ACTION_CAPTURE_VALUES, 'RuleActionCapture');
|
|
|
|
/** Validate an untrusted value as RuleAction. */
|
|
export function validateRuleAction(v: unknown, path = ''): Validated<RuleAction> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = opt(v, "categoryId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "saveDir", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "segments", path, vLimited(vInteger, { minimum: 1, maximum: 32 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "startMode", path, validateStartMode, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "capture", path, validateRuleActionCapture, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as RuleAction };
|
|
}
|
|
|
|
/** Validate an untrusted value as Segment. */
|
|
export function validateSegment(v: unknown, path = ''): Validated<Segment> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "index", path, vLimited(vInteger, { minimum: 0, maximum: 31 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "startByte", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "endByte", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "downloadedBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "speedBps", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "state", path, validateSegmentState, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "httpStatus", path, vLimited(vInteger, { minimum: 100, maximum: 599 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as Segment };
|
|
}
|
|
|
|
export const validateSegmentState: Validator<SegmentState> = vEnum(SEGMENT_STATE_VALUES, 'SegmentState');
|
|
|
|
export const validateSettingKey: Validator<SettingKey> = vEnum(SETTING_KEY_VALUES, 'SettingKey');
|
|
|
|
/** Validate an untrusted value as Settings. */
|
|
export function validateSettings(v: unknown, path = ''): Validated<Settings> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = opt(v, "general.launchOnLogin", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "general.minimizeToTray", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "general.showDropTarget", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "general.confirmOnExit", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "general.language", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "general.checkForUpdates", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "capture.enabled", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "capture.monitoredExtensions", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "capture.monitoredMimeTypes", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "capture.minSizeBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "capture.excludedHosts", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "capture.bypassModifier", path, validateBypassModifier, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "capture.autoStartTypes", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "saveTo.defaultDir", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "saveTo.tempDir", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "saveTo.allowedRoots", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "saveTo.fileExistsPolicy", path, validateSettingsSaveToFileExistsPolicy, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "saveTo.createSubfolderPerSite", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "connection.preset", path, validateSettingsConnectionPreset, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "connection.maxSegmentsPerDownload", path, vLimited(vInteger, { minimum: 1, maximum: 32 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "connection.bufferBytes", path, vLimited(vInteger, { minimum: 65536, maximum: 16777216 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "connection.maxConcurrentDownloads", path, vLimited(vInteger, { minimum: 1, maximum: 64 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "connection.timeoutSec", path, vLimited(vInteger, { minimum: 1, maximum: 3600 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "connection.maxRetries", path, vLimited(vInteger, { minimum: 0, maximum: 100 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "connection.retryBackoffSec", path, vLimited(vInteger, { minimum: 0, maximum: 3600 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "downloads.speedLimitBps", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "downloads.speedLimitEnabled", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "downloads.virusScanCommand", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "downloads.postDownloadCommand", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "downloads.duplicatePolicy", path, validateSettingsDownloadsDuplicatePolicy, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "downloads.verifyChecksums", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "proxy.mode", path, validateSettingsProxyMode, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "proxy.host", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "proxy.port", path, vLimited(vInteger, { minimum: 1, maximum: 65535 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "proxy.username", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "proxy.bypassHosts", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "proxy.pacUrl", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sounds.enabled", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sounds.onComplete", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sounds.onQueueComplete", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sounds.onError", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "connection.maxTotalBufferBytes", path, vLimited(vInteger, { minimum: 16777216, maximum: 2147483648 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "connection.maxActiveSegments", path, vLimited(vInteger, { minimum: 1, maximum: 256 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as Settings };
|
|
}
|
|
|
|
export const validateSettingsSaveToFileExistsPolicy: Validator<SettingsSaveToFileExistsPolicy> = vEnum(SETTINGS_SAVE_TO_FILE_EXISTS_POLICY_VALUES, 'SettingsSaveToFileExistsPolicy');
|
|
|
|
export const validateSettingsConnectionPreset: Validator<SettingsConnectionPreset> = vEnum(SETTINGS_CONNECTION_PRESET_VALUES, 'SettingsConnectionPreset');
|
|
|
|
export const validateSettingsDownloadsDuplicatePolicy: Validator<SettingsDownloadsDuplicatePolicy> = vEnum(SETTINGS_DOWNLOADS_DUPLICATE_POLICY_VALUES, 'SettingsDownloadsDuplicatePolicy');
|
|
|
|
export const validateSettingsProxyMode: Validator<SettingsProxyMode> = vEnum(SETTINGS_PROXY_MODE_VALUES, 'SettingsProxyMode');
|
|
|
|
/** Validate an untrusted value as TaskDetail. */
|
|
export function validateTaskDetail(v: unknown, path = ''): Validated<TaskDetail> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "summary", path, validateTaskSummary, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "segmentDetail", path, vLimited(vArray(validateSegment), { maxItems: 32 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "headers", path, validateHeaders, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "referrer", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "userAgent", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "mime", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "bufferBytes", path, vLimited(vInteger, { minimum: 65536, maximum: 16777216 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "effectiveBufferBytes", path, vLimited(vInteger, { minimum: 65536, maximum: 16777216 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "partPath", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "checksum", path, validateChecksum, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "checksumVerified", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "averageSpeedBps", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "retryCount", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as TaskDetail };
|
|
}
|
|
|
|
/** Validate an untrusted value as TaskSummary. */
|
|
export function validateTaskSummary(v: unknown, path = ''): Validated<TaskSummary> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "filename", path, vLimited(vString, { maxLength: 255 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "saveDir", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "url", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "effectiveUrl", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sizeBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "downloadedBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "state", path, validateTaskState, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "speedBps", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "etaSeconds", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "resumable", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "segments", path, vLimited(vInteger, { minimum: 1, maximum: 32 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "categoryId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "queuePosition", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "description", path, vLimited(vString, { maxLength: 1024 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "createdAt", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "lastTryAt", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "completedAt", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "error", path, validateTaskError, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as TaskSummary };
|
|
}
|
|
|
|
/** Validate an untrusted value as TaskError. */
|
|
export function validateTaskError(v: unknown, path = ''): Validated<TaskError> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "code", path, validateTaskErrorCode, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "message", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "httpStatus", path, vLimited(vInteger, { minimum: 100, maximum: 599 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "retryable", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "cause", path, validateTaskErrorCode, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "attempt", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "nextRetryAt", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as TaskError };
|
|
}
|
|
|
|
export const validateTaskErrorCode: Validator<TaskErrorCode> = vEnum(TASK_ERROR_CODE_VALUES, 'TaskErrorCode');
|
|
|
|
/** Validate an untrusted value as TaskFilter. */
|
|
export function validateTaskFilter(v: unknown, path = ''): Validated<TaskFilter> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = opt(v, "states", path, vArray(validateTaskState), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "categoryId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "query", path, vLimited(vString, { maxLength: 256 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "addedAfter", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "addedBefore", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as TaskFilter };
|
|
}
|
|
|
|
/** Validate an untrusted value as TaskSort. */
|
|
export function validateTaskSort(v: unknown, path = ''): Validated<TaskSort> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "field", path, validateTaskSortField, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "direction", path, validateTaskSortDirection, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as TaskSort };
|
|
}
|
|
|
|
export const validateTaskSortField: Validator<TaskSortField> = vEnum(TASK_SORT_FIELD_VALUES, 'TaskSortField');
|
|
|
|
export const validateTaskSortDirection: Validator<TaskSortDirection> = vEnum(TASK_SORT_DIRECTION_VALUES, 'TaskSortDirection');
|
|
|
|
/** Validate an untrusted value as CaptureGetRulesParams. */
|
|
export function validateCaptureGetRulesParams(v: unknown, path = ''): Validated<CaptureGetRulesParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
return { ok: true, value: {} as CaptureGetRulesParams };
|
|
}
|
|
|
|
export const validateCaptureOfferParamsMethod: Validator<CaptureOfferParamsMethod> = vEnum(CAPTURE_OFFER_PARAMS_METHOD_VALUES, 'CaptureOfferParamsMethod');
|
|
|
|
/** Validate an untrusted value as CaptureOfferParams. */
|
|
export function validateCaptureOfferParams(v: unknown, path = ''): Validated<CaptureOfferParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "url", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "method", path, validateCaptureOfferParamsMethod, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "tabUrl", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "headers", path, validateHeaders, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "cookies", path, vArray(validateCookie), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "contentType", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "contentLength", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "contentDisposition", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "filename", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "userAgent", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "referrer", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "origin", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "requestId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as CaptureOfferParams };
|
|
}
|
|
|
|
export const validateCaptureOfferResultAction: Validator<CaptureOfferResultAction> = vEnum(CAPTURE_OFFER_RESULT_ACTION_VALUES, 'CaptureOfferResultAction');
|
|
|
|
export const validateCaptureOfferResultReason: Validator<CaptureOfferResultReason> = vEnum(CAPTURE_OFFER_RESULT_REASON_VALUES, 'CaptureOfferResultReason');
|
|
|
|
/** Validate an untrusted value as CaptureOfferResult. */
|
|
export function validateCaptureOfferResult(v: unknown, path = ''): Validated<CaptureOfferResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "action", path, validateCaptureOfferResultAction, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "reason", path, validateCaptureOfferResultReason, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as CaptureOfferResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as CategoryListParams. */
|
|
export function validateCategoryListParams(v: unknown, path = ''): Validated<CategoryListParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
return { ok: true, value: {} as CategoryListParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as CategoryListResult. */
|
|
export function validateCategoryListResult(v: unknown, path = ''): Validated<CategoryListResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "items", path, vArray(validateCategory), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as CategoryListResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as CategoryRemoveParams. */
|
|
export function validateCategoryRemoveParams(v: unknown, path = ''): Validated<CategoryRemoveParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "categoryId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "reassignTo", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as CategoryRemoveParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as CategoryRemoveResult. */
|
|
export function validateCategoryRemoveResult(v: unknown, path = ''): Validated<CategoryRemoveResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "removed", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "reassignedTaskIds", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as CategoryRemoveResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as CategoryUpsertParams. */
|
|
export function validateCategoryUpsertParams(v: unknown, path = ''): Validated<CategoryUpsertParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "category", path, validateCategory, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as CategoryUpsertParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as CategoryUpsertResult. */
|
|
export function validateCategoryUpsertResult(v: unknown, path = ''): Validated<CategoryUpsertResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "category", path, validateCategory, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as CategoryUpsertResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadAddResult. */
|
|
export function validateDownloadAddResult(v: unknown, path = ''): Validated<DownloadAddResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "state", path, validateTaskState, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "duplicate", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadAddResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadAddBatchParams. */
|
|
export function validateDownloadAddBatchParams(v: unknown, path = ''): Validated<DownloadAddBatchParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "items", path, vLimited(vArray(validateDownloadSpec), { minItems: 1, maxItems: 5000 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "defaults", path, validateDownloadSpec, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadAddBatchParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadAddBatchResultFailedItem. */
|
|
export function validateDownloadAddBatchResultFailedItem(v: unknown, path = ''): Validated<DownloadAddBatchResultFailedItem> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "index", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "code", path, validateErrorCode, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "message", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadAddBatchResultFailedItem };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadAddBatchResult. */
|
|
export function validateDownloadAddBatchResult(v: unknown, path = ''): Validated<DownloadAddBatchResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskIds", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "failed", path, vArray(validateDownloadAddBatchResultFailedItem), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadAddBatchResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadCancelParams. */
|
|
export function validateDownloadCancelParams(v: unknown, path = ''): Validated<DownloadCancelParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskIds", path, vLimited(vArray(vString), { minItems: 1, maxItems: 5000 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadCancelParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadGetParams. */
|
|
export function validateDownloadGetParams(v: unknown, path = ''): Validated<DownloadGetParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadGetParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadListParams. */
|
|
export function validateDownloadListParams(v: unknown, path = ''): Validated<DownloadListParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = opt(v, "filter", path, validateTaskFilter, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sort", path, validateTaskSort, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "offset", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "limit", path, vLimited(vInteger, { minimum: 1, maximum: 5000 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadListParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadListResult. */
|
|
export function validateDownloadListResult(v: unknown, path = ''): Validated<DownloadListResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "total", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "items", path, vArray(validateTaskSummary), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadListResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadPauseParams. */
|
|
export function validateDownloadPauseParams(v: unknown, path = ''): Validated<DownloadPauseParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskIds", path, vLimited(vArray(vString), { minItems: 1, maxItems: 5000 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadPauseParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadProbeParams. */
|
|
export function validateDownloadProbeParams(v: unknown, path = ''): Validated<DownloadProbeParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "url", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "headers", path, validateHeaders, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "cookies", path, vArray(validateCookie), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "referrer", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "userAgent", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadProbeParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadProbeResult. */
|
|
export function validateDownloadProbeResult(v: unknown, path = ''): Validated<DownloadProbeResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "filename", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sizeBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "mime", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "resumable", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "effectiveUrl", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "suggestedCategoryId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "suggestedSaveDir", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "etag", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "lastModified", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "acceptRanges", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "redirectChain", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "requiresAuth", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadProbeResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadRefreshUrlParams. */
|
|
export function validateDownloadRefreshUrlParams(v: unknown, path = ''): Validated<DownloadRefreshUrlParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "url", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "headers", path, validateHeaders, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "cookies", path, vArray(validateCookie), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadRefreshUrlParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadRefreshUrlResult. */
|
|
export function validateDownloadRefreshUrlResult(v: unknown, path = ''): Validated<DownloadRefreshUrlResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "ok", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "resumable", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "contentChanged", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sizeBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "effectiveUrl", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadRefreshUrlResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadRemoveParams. */
|
|
export function validateDownloadRemoveParams(v: unknown, path = ''): Validated<DownloadRemoveParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskIds", path, vLimited(vArray(vString), { minItems: 1, maxItems: 5000 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "deleteFile", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadRemoveParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadRemoveResultFailedItem. */
|
|
export function validateDownloadRemoveResultFailedItem(v: unknown, path = ''): Validated<DownloadRemoveResultFailedItem> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "code", path, validateErrorCode, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "message", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadRemoveResultFailedItem };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadRemoveResult. */
|
|
export function validateDownloadRemoveResult(v: unknown, path = ''): Validated<DownloadRemoveResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "removed", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "failed", path, vArray(validateDownloadRemoveResultFailedItem), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadRemoveResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadResumeParams. */
|
|
export function validateDownloadResumeParams(v: unknown, path = ''): Validated<DownloadResumeParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskIds", path, vLimited(vArray(vString), { minItems: 1, maxItems: 5000 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadResumeParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadStartParams. */
|
|
export function validateDownloadStartParams(v: unknown, path = ''): Validated<DownloadStartParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskIds", path, vLimited(vArray(vString), { minItems: 1, maxItems: 5000 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadStartParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadUpdateParamsPatch. */
|
|
export function validateDownloadUpdateParamsPatch(v: unknown, path = ''): Validated<DownloadUpdateParamsPatch> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = opt(v, "filename", path, vLimited(vString, { maxLength: 255 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "saveDir", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "categoryId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "description", path, vLimited(vString, { maxLength: 1024 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "segments", path, vLimited(vInteger, { minimum: 1, maximum: 32 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "bufferBytes", path, vLimited(vInteger, { minimum: 65536, maximum: 16777216 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "checksum", path, validateChecksum, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadUpdateParamsPatch };
|
|
}
|
|
|
|
/** Validate an untrusted value as DownloadUpdateParams. */
|
|
export function validateDownloadUpdateParams(v: unknown, path = ''): Validated<DownloadUpdateParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "patch", path, validateDownloadUpdateParamsPatch, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as DownloadUpdateParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as GrabberHarvestParams. */
|
|
export function validateGrabberHarvestParams(v: unknown, path = ''): Validated<GrabberHarvestParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "jobId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "select", path, vLimited(vArray(vString), { minItems: 1 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "defaults", path, validateDownloadSpec, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as GrabberHarvestParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as GrabberHarvestResultFailedItem. */
|
|
export function validateGrabberHarvestResultFailedItem(v: unknown, path = ''): Validated<GrabberHarvestResultFailedItem> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "fileId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "code", path, validateErrorCode, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "message", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as GrabberHarvestResultFailedItem };
|
|
}
|
|
|
|
/** Validate an untrusted value as GrabberHarvestResult. */
|
|
export function validateGrabberHarvestResult(v: unknown, path = ''): Validated<GrabberHarvestResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskIds", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "failed", path, vArray(validateGrabberHarvestResultFailedItem), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as GrabberHarvestResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as GrabberStartParams. */
|
|
export function validateGrabberStartParams(v: unknown, path = ''): Validated<GrabberStartParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "startUrl", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "depth", path, vLimited(vInteger, { minimum: 0, maximum: 10 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "includePatterns", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "excludePatterns", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "fileTypes", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sameHostOnly", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "maxFiles", path, vLimited(vInteger, { minimum: 1, maximum: 10000 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "headers", path, validateHeaders, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "cookies", path, vArray(validateCookie), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as GrabberStartParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as GrabberStartResult. */
|
|
export function validateGrabberStartResult(v: unknown, path = ''): Validated<GrabberStartResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "jobId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as GrabberStartResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as GrabberStatusParams. */
|
|
export function validateGrabberStatusParams(v: unknown, path = ''): Validated<GrabberStatusParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "jobId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as GrabberStatusParams };
|
|
}
|
|
|
|
export const validateGrabberStatusResultState: Validator<GrabberStatusResultState> = vEnum(GRABBER_STATUS_RESULT_STATE_VALUES, 'GrabberStatusResultState');
|
|
|
|
/** Validate an untrusted value as GrabberStatusResult. */
|
|
export function validateGrabberStatusResult(v: unknown, path = ''): Validated<GrabberStatusResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "jobId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "state", path, validateGrabberStatusResultState, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "crawled", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "found", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "files", path, vArray(validateGrabberFile), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "error", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as GrabberStatusResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as LimiterGetParams. */
|
|
export function validateLimiterGetParams(v: unknown, path = ''): Validated<LimiterGetParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
return { ok: true, value: {} as LimiterGetParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as MediaAddVariantParams. */
|
|
export function validateMediaAddVariantParams(v: unknown, path = ''): Validated<MediaAddVariantParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "manifestUrl", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "variantId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "audioVariantId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "spec", path, validateDownloadSpec, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as MediaAddVariantParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as MediaAddVariantResult. */
|
|
export function validateMediaAddVariantResult(v: unknown, path = ''): Validated<MediaAddVariantResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "state", path, validateTaskState, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "estimatedBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as MediaAddVariantResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as MediaListVariantsParams. */
|
|
export function validateMediaListVariantsParams(v: unknown, path = ''): Validated<MediaListVariantsParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "manifestUrl", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "headers", path, validateHeaders, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "cookies", path, vArray(validateCookie), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "referrer", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as MediaListVariantsParams };
|
|
}
|
|
|
|
export const validateMediaListVariantsResultManifestType: Validator<MediaListVariantsResultManifestType> = vEnum(MEDIA_LIST_VARIANTS_RESULT_MANIFEST_TYPE_VALUES, 'MediaListVariantsResultManifestType');
|
|
|
|
/** Validate an untrusted value as MediaListVariantsResult. */
|
|
export function validateMediaListVariantsResult(v: unknown, path = ''): Validated<MediaListVariantsResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "variants", path, vArray(validateMediaVariant), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "manifestType", path, validateMediaListVariantsResultManifestType, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "durationSec", path, vLimited(vNumber, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "title", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "drmProtected", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as MediaListVariantsResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as QueueListParams. */
|
|
export function validateQueueListParams(v: unknown, path = ''): Validated<QueueListParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
return { ok: true, value: {} as QueueListParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as QueueListResult. */
|
|
export function validateQueueListResult(v: unknown, path = ''): Validated<QueueListResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "items", path, vArray(validateQueue), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as QueueListResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as QueueReorderParams. */
|
|
export function validateQueueReorderParams(v: unknown, path = ''): Validated<QueueReorderParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "taskIds", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as QueueReorderParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as QueueReorderResult. */
|
|
export function validateQueueReorderResult(v: unknown, path = ''): Validated<QueueReorderResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queue", path, validateQueue, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as QueueReorderResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as QueueStartParams. */
|
|
export function validateQueueStartParams(v: unknown, path = ''): Validated<QueueStartParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as QueueStartParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as QueueStartResult. */
|
|
export function validateQueueStartResult(v: unknown, path = ''): Validated<QueueStartResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queue", path, validateQueue, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "startedTaskIds", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as QueueStartResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as QueueStopParams. */
|
|
export function validateQueueStopParams(v: unknown, path = ''): Validated<QueueStopParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "pauseRunning", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as QueueStopParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as QueueStopResult. */
|
|
export function validateQueueStopResult(v: unknown, path = ''): Validated<QueueStopResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queue", path, validateQueue, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "pausedTaskIds", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as QueueStopResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as QueueUpsertParams. */
|
|
export function validateQueueUpsertParams(v: unknown, path = ''): Validated<QueueUpsertParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queue", path, validateQueue, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as QueueUpsertParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as QueueUpsertResult. */
|
|
export function validateQueueUpsertResult(v: unknown, path = ''): Validated<QueueUpsertResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queue", path, validateQueue, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as QueueUpsertResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as RulesListParams. */
|
|
export function validateRulesListParams(v: unknown, path = ''): Validated<RulesListParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
return { ok: true, value: {} as RulesListParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as RulesListResult. */
|
|
export function validateRulesListResult(v: unknown, path = ''): Validated<RulesListResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "items", path, vArray(validateRule), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as RulesListResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as RulesUpsertParams. */
|
|
export function validateRulesUpsertParams(v: unknown, path = ''): Validated<RulesUpsertParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "upsert", path, vArray(validateRule), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "remove", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as RulesUpsertParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as RulesUpsertResult. */
|
|
export function validateRulesUpsertResult(v: unknown, path = ''): Validated<RulesUpsertResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "items", path, vArray(validateRule), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as RulesUpsertResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as ScheduleGetParams. */
|
|
export function validateScheduleGetParams(v: unknown, path = ''): Validated<ScheduleGetParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = opt(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as ScheduleGetParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as ScheduleGetResultItemsItem. */
|
|
export function validateScheduleGetResultItemsItem(v: unknown, path = ''): Validated<ScheduleGetResultItemsItem> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "schedule", path, validateSchedule, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as ScheduleGetResultItemsItem };
|
|
}
|
|
|
|
/** Validate an untrusted value as ScheduleGetResult. */
|
|
export function validateScheduleGetResult(v: unknown, path = ''): Validated<ScheduleGetResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "items", path, vArray(validateScheduleGetResultItemsItem), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as ScheduleGetResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as ScheduleSetParams. */
|
|
export function validateScheduleSetParams(v: unknown, path = ''): Validated<ScheduleSetParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "schedule", path, validateSchedule, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as ScheduleSetParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as ScheduleSetResult. */
|
|
export function validateScheduleSetResult(v: unknown, path = ''): Validated<ScheduleSetResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "queueId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "schedule", path, validateSchedule, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "nextRunAt", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as ScheduleSetResult };
|
|
}
|
|
|
|
export const validateSessionHelloParamsClientType: Validator<SessionHelloParamsClientType> = vEnum(SESSION_HELLO_PARAMS_CLIENT_TYPE_VALUES, 'SessionHelloParamsClientType');
|
|
|
|
/** Validate an untrusted value as SessionHelloParams. */
|
|
export function validateSessionHelloParams(v: unknown, path = ''): Validated<SessionHelloParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "clientType", path, validateSessionHelloParamsClientType, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "clientName", path, vLimited(vString, { maxLength: 64 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "protocolVersion", path, vLimited(vString, { pattern: /^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?$/ }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "token", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SessionHelloParams };
|
|
}
|
|
|
|
export const validateSessionHelloResultTransport: Validator<SessionHelloResultTransport> = vEnum(SESSION_HELLO_RESULT_TRANSPORT_VALUES, 'SessionHelloResultTransport');
|
|
|
|
/** Validate an untrusted value as SessionHelloResult. */
|
|
export function validateSessionHelloResult(v: unknown, path = ''): Validated<SessionHelloResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "daemonVersion", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "protocolVersion", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "capabilities", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "sessionId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "transport", path, validateSessionHelloResultTransport, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SessionHelloResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as SessionPairParams. */
|
|
export function validateSessionPairParams(v: unknown, path = ''): Validated<SessionPairParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "clientName", path, vLimited(vString, { maxLength: 64 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "extensionId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "code", path, vLimited(vString, { pattern: /^[0-9]{4}$/ }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SessionPairParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as SessionPairResult. */
|
|
export function validateSessionPairResult(v: unknown, path = ''): Validated<SessionPairResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "token", path, vLimited(vString, { minLength: 43 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "expiresAt", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SessionPairResult };
|
|
}
|
|
|
|
export const validateSessionSubscribeParamsEventsItem: Validator<SessionSubscribeParamsEventsItem> = vEnum(SESSION_SUBSCRIBE_PARAMS_EVENTS_ITEM_VALUES, 'SessionSubscribeParamsEventsItem');
|
|
|
|
/** Validate an untrusted value as SessionSubscribeParams. */
|
|
export function validateSessionSubscribeParams(v: unknown, path = ''): Validated<SessionSubscribeParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "events", path, vArray(validateSessionSubscribeParamsEventsItem), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "taskIds", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SessionSubscribeParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as SessionSubscribeResult. */
|
|
export function validateSessionSubscribeResult(v: unknown, path = ''): Validated<SessionSubscribeResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "ok", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "events", path, vArray(vString), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SessionSubscribeResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as SettingsGetParams. */
|
|
export function validateSettingsGetParams(v: unknown, path = ''): Validated<SettingsGetParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = opt(v, "keys", path, vArray(validateSettingKey), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SettingsGetParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as SettingsGetResult. */
|
|
export function validateSettingsGetResult(v: unknown, path = ''): Validated<SettingsGetResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "values", path, validateSettings, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SettingsGetResult };
|
|
}
|
|
|
|
/** Validate an untrusted value as SettingsSetParams. */
|
|
export function validateSettingsSetParams(v: unknown, path = ''): Validated<SettingsSetParams> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "values", path, validateSettings, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SettingsSetParams };
|
|
}
|
|
|
|
/** Validate an untrusted value as SettingsSetResult. */
|
|
export function validateSettingsSetResult(v: unknown, path = ''): Validated<SettingsSetResult> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "values", path, validateSettings, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "changed", path, vArray(validateSettingKey), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SettingsSetResult };
|
|
}
|
|
|
|
export const validateAuthRequiredEventScheme: Validator<AuthRequiredEventScheme> = vEnum(AUTH_REQUIRED_EVENT_SCHEME_VALUES, 'AuthRequiredEventScheme');
|
|
|
|
/** Validate an untrusted value as AuthRequiredEvent. */
|
|
export function validateAuthRequiredEvent(v: unknown, path = ''): Validated<AuthRequiredEvent> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "host", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "realm", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "scheme", path, validateAuthRequiredEventScheme, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as AuthRequiredEvent };
|
|
}
|
|
|
|
/** Validate an untrusted value as GrabberProgressEvent. */
|
|
export function validateGrabberProgressEvent(v: unknown, path = ''): Validated<GrabberProgressEvent> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "jobId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "found", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "crawled", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "done", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "currentUrl", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as GrabberProgressEvent };
|
|
}
|
|
|
|
export const validateNotifyEventLevel: Validator<NotifyEventLevel> = vEnum(NOTIFY_EVENT_LEVEL_VALUES, 'NotifyEventLevel');
|
|
|
|
export const validateNotifyEventSound: Validator<NotifyEventSound> = vEnum(NOTIFY_EVENT_SOUND_VALUES, 'NotifyEventSound');
|
|
|
|
/** Validate an untrusted value as NotifyEvent. */
|
|
export function validateNotifyEvent(v: unknown, path = ''): Validated<NotifyEvent> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "level", path, validateNotifyEventLevel, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "title", path, vLimited(vString, { maxLength: 128 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "body", path, vLimited(vString, { maxLength: 1024 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "sound", path, validateNotifyEventSound, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as NotifyEvent };
|
|
}
|
|
|
|
/** Validate an untrusted value as SettingsChangedEvent. */
|
|
export function validateSettingsChangedEvent(v: unknown, path = ''): Validated<SettingsChangedEvent> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "keys", path, vArray(validateSettingKey), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SettingsChangedEvent };
|
|
}
|
|
|
|
/** Validate an untrusted value as SpeedGlobalEvent. */
|
|
export function validateSpeedGlobalEvent(v: unknown, path = ''): Validated<SpeedGlobalEvent> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "downBps", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "activeCount", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "queuedCount", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "limitBps", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as SpeedGlobalEvent };
|
|
}
|
|
|
|
/** Validate an untrusted value as TaskAddedEvent. */
|
|
export function validateTaskAddedEvent(v: unknown, path = ''): Validated<TaskAddedEvent> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "summary", path, validateTaskSummary, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as TaskAddedEvent };
|
|
}
|
|
|
|
/** Validate an untrusted value as TaskProgressEventTasksItemSegmentsItem. */
|
|
export function validateTaskProgressEventTasksItemSegmentsItem(v: unknown, path = ''): Validated<TaskProgressEventTasksItemSegmentsItem> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "index", path, vLimited(vInteger, { minimum: 0, maximum: 31 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "downloadedBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "speedBps", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as TaskProgressEventTasksItemSegmentsItem };
|
|
}
|
|
|
|
/** Validate an untrusted value as TaskProgressEventTasksItem. */
|
|
export function validateTaskProgressEventTasksItem(v: unknown, path = ''): Validated<TaskProgressEventTasksItem> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "downloadedBytes", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "speedBps", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "etaSeconds", path, vLimited(vInteger, { minimum: 0 }), out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "segments", path, vLimited(vArray(validateTaskProgressEventTasksItemSegmentsItem), { maxItems: 32 }), out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as TaskProgressEventTasksItem };
|
|
}
|
|
|
|
/** Validate an untrusted value as TaskProgressEvent. */
|
|
export function validateTaskProgressEvent(v: unknown, path = ''): Validated<TaskProgressEvent> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "tasks", path, vArray(validateTaskProgressEventTasksItem), out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "at", path, vString, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as TaskProgressEvent };
|
|
}
|
|
|
|
/** Validate an untrusted value as TaskRemovedEvent. */
|
|
export function validateTaskRemovedEvent(v: unknown, path = ''): Validated<TaskRemovedEvent> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "deletedFile", path, vBoolean, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as TaskRemovedEvent };
|
|
}
|
|
|
|
/** Validate an untrusted value as TaskStateEvent. */
|
|
export function validateTaskStateEvent(v: unknown, path = ''): Validated<TaskStateEvent> {
|
|
if (!isPlainObject(v)) return fail(path, 'expected an object');
|
|
const out: Record<string, unknown> = {};
|
|
let r: Validated<null>;
|
|
r = req(v, "taskId", path, vString, out);
|
|
if (!r.ok) return r;
|
|
r = req(v, "state", path, validateTaskState, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "previousState", path, validateTaskState, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "summary", path, validateTaskSummary, out);
|
|
if (!r.ok) return r;
|
|
r = opt(v, "error", path, validateTaskError, out);
|
|
if (!r.ok) return r;
|
|
return { ok: true, value: out as unknown as TaskStateEvent };
|
|
}
|
|
|
|
// --- by-name entry points --------------------------------------------------
|
|
|
|
const PARAMS_VALIDATORS: { [M in MethodName]: Validator<MethodMap[M]['params']> } = {
|
|
"capture.getRules": validateCaptureGetRulesParams,
|
|
"capture.offer": validateCaptureOfferParams,
|
|
"category.list": validateCategoryListParams,
|
|
"category.remove": validateCategoryRemoveParams,
|
|
"category.upsert": validateCategoryUpsertParams,
|
|
"download.add": validateDownloadSpec,
|
|
"download.addBatch": validateDownloadAddBatchParams,
|
|
"download.cancel": validateDownloadCancelParams,
|
|
"download.get": validateDownloadGetParams,
|
|
"download.list": validateDownloadListParams,
|
|
"download.pause": validateDownloadPauseParams,
|
|
"download.probe": validateDownloadProbeParams,
|
|
"download.refreshUrl": validateDownloadRefreshUrlParams,
|
|
"download.remove": validateDownloadRemoveParams,
|
|
"download.resume": validateDownloadResumeParams,
|
|
"download.start": validateDownloadStartParams,
|
|
"download.update": validateDownloadUpdateParams,
|
|
"grabber.harvest": validateGrabberHarvestParams,
|
|
"grabber.start": validateGrabberStartParams,
|
|
"grabber.status": validateGrabberStatusParams,
|
|
"limiter.get": validateLimiterGetParams,
|
|
"limiter.set": validateLimiter,
|
|
"media.addVariant": validateMediaAddVariantParams,
|
|
"media.listVariants": validateMediaListVariantsParams,
|
|
"queue.list": validateQueueListParams,
|
|
"queue.reorder": validateQueueReorderParams,
|
|
"queue.start": validateQueueStartParams,
|
|
"queue.stop": validateQueueStopParams,
|
|
"queue.upsert": validateQueueUpsertParams,
|
|
"rules.list": validateRulesListParams,
|
|
"rules.upsert": validateRulesUpsertParams,
|
|
"schedule.get": validateScheduleGetParams,
|
|
"schedule.set": validateScheduleSetParams,
|
|
"session.hello": validateSessionHelloParams,
|
|
"session.pair": validateSessionPairParams,
|
|
"session.subscribe": validateSessionSubscribeParams,
|
|
"settings.get": validateSettingsGetParams,
|
|
"settings.set": validateSettingsSetParams,
|
|
};
|
|
|
|
const RESULT_VALIDATORS: { [M in MethodName]: Validator<MethodMap[M]['result']> } = {
|
|
"capture.getRules": validateCaptureRules,
|
|
"capture.offer": validateCaptureOfferResult,
|
|
"category.list": validateCategoryListResult,
|
|
"category.remove": validateCategoryRemoveResult,
|
|
"category.upsert": validateCategoryUpsertResult,
|
|
"download.add": validateDownloadAddResult,
|
|
"download.addBatch": validateDownloadAddBatchResult,
|
|
"download.cancel": validateBulkTaskResult,
|
|
"download.get": validateTaskDetail,
|
|
"download.list": validateDownloadListResult,
|
|
"download.pause": validateBulkTaskResult,
|
|
"download.probe": validateDownloadProbeResult,
|
|
"download.refreshUrl": validateDownloadRefreshUrlResult,
|
|
"download.remove": validateDownloadRemoveResult,
|
|
"download.resume": validateBulkTaskResult,
|
|
"download.start": validateBulkTaskResult,
|
|
"download.update": validateTaskSummary,
|
|
"grabber.harvest": validateGrabberHarvestResult,
|
|
"grabber.start": validateGrabberStartResult,
|
|
"grabber.status": validateGrabberStatusResult,
|
|
"limiter.get": validateLimiter,
|
|
"limiter.set": validateLimiter,
|
|
"media.addVariant": validateMediaAddVariantResult,
|
|
"media.listVariants": validateMediaListVariantsResult,
|
|
"queue.list": validateQueueListResult,
|
|
"queue.reorder": validateQueueReorderResult,
|
|
"queue.start": validateQueueStartResult,
|
|
"queue.stop": validateQueueStopResult,
|
|
"queue.upsert": validateQueueUpsertResult,
|
|
"rules.list": validateRulesListResult,
|
|
"rules.upsert": validateRulesUpsertResult,
|
|
"schedule.get": validateScheduleGetResult,
|
|
"schedule.set": validateScheduleSetResult,
|
|
"session.hello": validateSessionHelloResult,
|
|
"session.pair": validateSessionPairResult,
|
|
"session.subscribe": validateSessionSubscribeResult,
|
|
"settings.get": validateSettingsGetResult,
|
|
"settings.set": validateSettingsSetResult,
|
|
};
|
|
|
|
const EVENT_VALIDATORS: { [E in EventName]: Validator<EventMap[E]> } = {
|
|
"event.auth.required": validateAuthRequiredEvent,
|
|
"event.grabber.progress": validateGrabberProgressEvent,
|
|
"event.notify": validateNotifyEvent,
|
|
"event.settings.changed": validateSettingsChangedEvent,
|
|
"event.speed.global": validateSpeedGlobalEvent,
|
|
"event.task.added": validateTaskAddedEvent,
|
|
"event.task.progress": validateTaskProgressEvent,
|
|
"event.task.removed": validateTaskRemovedEvent,
|
|
"event.task.state": validateTaskStateEvent,
|
|
};
|
|
|
|
/** Validate params the daemon is about to receive for `method`. */
|
|
export function validateParams<M extends MethodName>(method: M, v: unknown): Validated<MethodMap[M]['params']> {
|
|
return PARAMS_VALIDATORS[method](v, 'params');
|
|
}
|
|
|
|
/** Validate a result the client just received for `method`. */
|
|
export function validateResult<M extends MethodName>(method: M, v: unknown): Validated<MethodMap[M]['result']> {
|
|
return RESULT_VALIDATORS[method](v, 'result');
|
|
}
|
|
|
|
/** Validate a notification payload. */
|
|
export function validateEventParams<E extends EventName>(event: E, v: unknown): Validated<EventMap[E]> {
|
|
return EVENT_VALIDATORS[event](v, 'params');
|
|
}
|
|
|
|
/**
|
|
* Validate a whole inbound notification frame, including its method name.
|
|
* Anything unrecognised is rejected rather than passed on: an unknown method on a
|
|
* loopback socket is either a version skew or another local process probing us.
|
|
*/
|
|
export function validateNotification(
|
|
frame: unknown,
|
|
): Validated<{ method: EventName; params: EventMap[EventName] }> {
|
|
if (!isPlainObject(frame)) return fail('', 'expected an object');
|
|
if (frame['jsonrpc'] !== '2.0') return fail('/jsonrpc', "expected '2.0'");
|
|
const method = frame['method'];
|
|
if (!isEventName(method)) return fail('/method', 'unknown event');
|
|
const params = validateEventParams(method, frame['params']);
|
|
if (!params.ok) return params;
|
|
return { ok: true, value: { method, params: params.value } };
|
|
}
|
|
|
|
export { isEventName, isMethodName };
|