// ---------------------------------------------------------------------------
// 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 };