const query0 = async ({ table = "events_0", limit = 10, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel0 extends Object {
  static id = 0;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel0.id }; }
  render = (props) => <section className="panel-0" {...props}><h2>{props.title ?? "Panel 0"}</h2></section>;
}

const query1 = async ({ table = "events_1", limit = 11, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel1 extends Object {
  static id = 1;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel1.id }; }
  render = (props) => <section className="panel-1" {...props}><h2>{props.title ?? "Panel 1"}</h2></section>;
}

const query2 = async ({ table = "events_2", limit = 12, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel2 extends Object {
  static id = 2;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel2.id }; }
  render = (props) => <section className="panel-2" {...props}><h2>{props.title ?? "Panel 2"}</h2></section>;
}

const query3 = async ({ table = "events_3", limit = 13, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel3 extends Object {
  static id = 3;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel3.id }; }
  render = (props) => <section className="panel-3" {...props}><h2>{props.title ?? "Panel 3"}</h2></section>;
}

const query4 = async ({ table = "events_4", limit = 14, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel4 extends Object {
  static id = 4;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel4.id }; }
  render = (props) => <section className="panel-4" {...props}><h2>{props.title ?? "Panel 4"}</h2></section>;
}

const query5 = async ({ table = "events_5", limit = 15, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel5 extends Object {
  static id = 5;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel5.id }; }
  render = (props) => <section className="panel-5" {...props}><h2>{props.title ?? "Panel 5"}</h2></section>;
}

const query6 = async ({ table = "events_6", limit = 16, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel6 extends Object {
  static id = 6;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel6.id }; }
  render = (props) => <section className="panel-6" {...props}><h2>{props.title ?? "Panel 6"}</h2></section>;
}

const query7 = async ({ table = "events_7", limit = 17, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel7 extends Object {
  static id = 7;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel7.id }; }
  render = (props) => <section className="panel-7" {...props}><h2>{props.title ?? "Panel 7"}</h2></section>;
}

const query8 = async ({ table = "events_8", limit = 18, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel8 extends Object {
  static id = 8;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel8.id }; }
  render = (props) => <section className="panel-8" {...props}><h2>{props.title ?? "Panel 8"}</h2></section>;
}

const query9 = async ({ table = "events_9", limit = 19, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel9 extends Object {
  static id = 9;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel9.id }; }
  render = (props) => <section className="panel-9" {...props}><h2>{props.title ?? "Panel 9"}</h2></section>;
}

const query10 = async ({ table = "events_10", limit = 20, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel10 extends Object {
  static id = 10;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel10.id }; }
  render = (props) => <section className="panel-10" {...props}><h2>{props.title ?? "Panel 10"}</h2></section>;
}

const query11 = async ({ table = "events_11", limit = 21, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel11 extends Object {
  static id = 11;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel11.id }; }
  render = (props) => <section className="panel-11" {...props}><h2>{props.title ?? "Panel 11"}</h2></section>;
}

const query12 = async ({ table = "events_12", limit = 22, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel12 extends Object {
  static id = 12;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel12.id }; }
  render = (props) => <section className="panel-12" {...props}><h2>{props.title ?? "Panel 12"}</h2></section>;
}

const query13 = async ({ table = "events_13", limit = 23, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel13 extends Object {
  static id = 13;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel13.id }; }
  render = (props) => <section className="panel-13" {...props}><h2>{props.title ?? "Panel 13"}</h2></section>;
}

const query14 = async ({ table = "events_14", limit = 24, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel14 extends Object {
  static id = 14;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel14.id }; }
  render = (props) => <section className="panel-14" {...props}><h2>{props.title ?? "Panel 14"}</h2></section>;
}

const query15 = async ({ table = "events_15", limit = 25, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel15 extends Object {
  static id = 15;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel15.id }; }
  render = (props) => <section className="panel-15" {...props}><h2>{props.title ?? "Panel 15"}</h2></section>;
}

const query16 = async ({ table = "events_16", limit = 26, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel16 extends Object {
  static id = 16;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel16.id }; }
  render = (props) => <section className="panel-16" {...props}><h2>{props.title ?? "Panel 16"}</h2></section>;
}

const query17 = async ({ table = "events_17", limit = 27, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel17 extends Object {
  static id = 17;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel17.id }; }
  render = (props) => <section className="panel-17" {...props}><h2>{props.title ?? "Panel 17"}</h2></section>;
}

const query18 = async ({ table = "events_18", limit = 28, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel18 extends Object {
  static id = 18;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel18.id }; }
  render = (props) => <section className="panel-18" {...props}><h2>{props.title ?? "Panel 18"}</h2></section>;
}

const query19 = async ({ table = "events_19", limit = 29, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel19 extends Object {
  static id = 19;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel19.id }; }
  render = (props) => <section className="panel-19" {...props}><h2>{props.title ?? "Panel 19"}</h2></section>;
}

const query20 = async ({ table = "events_20", limit = 30, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel20 extends Object {
  static id = 20;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel20.id }; }
  render = (props) => <section className="panel-20" {...props}><h2>{props.title ?? "Panel 20"}</h2></section>;
}

const query21 = async ({ table = "events_21", limit = 31, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel21 extends Object {
  static id = 21;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel21.id }; }
  render = (props) => <section className="panel-21" {...props}><h2>{props.title ?? "Panel 21"}</h2></section>;
}

const query22 = async ({ table = "events_22", limit = 32, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel22 extends Object {
  static id = 22;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel22.id }; }
  render = (props) => <section className="panel-22" {...props}><h2>{props.title ?? "Panel 22"}</h2></section>;
}

const query23 = async ({ table = "events_23", limit = 33, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel23 extends Object {
  static id = 23;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel23.id }; }
  render = (props) => <section className="panel-23" {...props}><h2>{props.title ?? "Panel 23"}</h2></section>;
}

const query24 = async ({ table = "events_24", limit = 34, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel24 extends Object {
  static id = 24;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel24.id }; }
  render = (props) => <section className="panel-24" {...props}><h2>{props.title ?? "Panel 24"}</h2></section>;
}

const query25 = async ({ table = "events_25", limit = 35, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel25 extends Object {
  static id = 25;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel25.id }; }
  render = (props) => <section className="panel-25" {...props}><h2>{props.title ?? "Panel 25"}</h2></section>;
}

const query26 = async ({ table = "events_26", limit = 36, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel26 extends Object {
  static id = 26;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel26.id }; }
  render = (props) => <section className="panel-26" {...props}><h2>{props.title ?? "Panel 26"}</h2></section>;
}

const query27 = async ({ table = "events_27", limit = 37, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel27 extends Object {
  static id = 27;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel27.id }; }
  render = (props) => <section className="panel-27" {...props}><h2>{props.title ?? "Panel 27"}</h2></section>;
}

const query28 = async ({ table = "events_28", limit = 38, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel28 extends Object {
  static id = 28;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel28.id }; }
  render = (props) => <section className="panel-28" {...props}><h2>{props.title ?? "Panel 28"}</h2></section>;
}

const query29 = async ({ table = "events_29", limit = 39, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel29 extends Object {
  static id = 29;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel29.id }; }
  render = (props) => <section className="panel-29" {...props}><h2>{props.title ?? "Panel 29"}</h2></section>;
}

const query30 = async ({ table = "events_30", limit = 40, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel30 extends Object {
  static id = 30;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel30.id }; }
  render = (props) => <section className="panel-30" {...props}><h2>{props.title ?? "Panel 30"}</h2></section>;
}

const query31 = async ({ table = "events_31", limit = 41, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel31 extends Object {
  static id = 31;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel31.id }; }
  render = (props) => <section className="panel-31" {...props}><h2>{props.title ?? "Panel 31"}</h2></section>;
}

const query32 = async ({ table = "events_32", limit = 42, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel32 extends Object {
  static id = 32;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel32.id }; }
  render = (props) => <section className="panel-32" {...props}><h2>{props.title ?? "Panel 32"}</h2></section>;
}

const query33 = async ({ table = "events_33", limit = 43, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel33 extends Object {
  static id = 33;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel33.id }; }
  render = (props) => <section className="panel-33" {...props}><h2>{props.title ?? "Panel 33"}</h2></section>;
}

const query34 = async ({ table = "events_34", limit = 44, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel34 extends Object {
  static id = 34;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel34.id }; }
  render = (props) => <section className="panel-34" {...props}><h2>{props.title ?? "Panel 34"}</h2></section>;
}

const query35 = async ({ table = "events_35", limit = 45, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel35 extends Object {
  static id = 35;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel35.id }; }
  render = (props) => <section className="panel-35" {...props}><h2>{props.title ?? "Panel 35"}</h2></section>;
}

const query36 = async ({ table = "events_36", limit = 46, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel36 extends Object {
  static id = 36;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel36.id }; }
  render = (props) => <section className="panel-36" {...props}><h2>{props.title ?? "Panel 36"}</h2></section>;
}

const query37 = async ({ table = "events_37", limit = 47, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel37 extends Object {
  static id = 37;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel37.id }; }
  render = (props) => <section className="panel-37" {...props}><h2>{props.title ?? "Panel 37"}</h2></section>;
}

const query38 = async ({ table = "events_38", limit = 48, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel38 extends Object {
  static id = 38;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel38.id }; }
  render = (props) => <section className="panel-38" {...props}><h2>{props.title ?? "Panel 38"}</h2></section>;
}

const query39 = async ({ table = "events_39", limit = 49, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel39 extends Object {
  static id = 39;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel39.id }; }
  render = (props) => <section className="panel-39" {...props}><h2>{props.title ?? "Panel 39"}</h2></section>;
}

const query40 = async ({ table = "events_40", limit = 50, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel40 extends Object {
  static id = 40;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel40.id }; }
  render = (props) => <section className="panel-40" {...props}><h2>{props.title ?? "Panel 40"}</h2></section>;
}

const query41 = async ({ table = "events_41", limit = 51, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel41 extends Object {
  static id = 41;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel41.id }; }
  render = (props) => <section className="panel-41" {...props}><h2>{props.title ?? "Panel 41"}</h2></section>;
}

const query42 = async ({ table = "events_42", limit = 52, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel42 extends Object {
  static id = 42;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel42.id }; }
  render = (props) => <section className="panel-42" {...props}><h2>{props.title ?? "Panel 42"}</h2></section>;
}

const query43 = async ({ table = "events_43", limit = 53, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel43 extends Object {
  static id = 43;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel43.id }; }
  render = (props) => <section className="panel-43" {...props}><h2>{props.title ?? "Panel 43"}</h2></section>;
}

const query44 = async ({ table = "events_44", limit = 54, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel44 extends Object {
  static id = 44;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel44.id }; }
  render = (props) => <section className="panel-44" {...props}><h2>{props.title ?? "Panel 44"}</h2></section>;
}

const query45 = async ({ table = "events_45", limit = 55, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel45 extends Object {
  static id = 45;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel45.id }; }
  render = (props) => <section className="panel-45" {...props}><h2>{props.title ?? "Panel 45"}</h2></section>;
}

const query46 = async ({ table = "events_46", limit = 56, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel46 extends Object {
  static id = 46;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel46.id }; }
  render = (props) => <section className="panel-46" {...props}><h2>{props.title ?? "Panel 46"}</h2></section>;
}

const query47 = async ({ table = "events_47", limit = 57, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel47 extends Object {
  static id = 47;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel47.id }; }
  render = (props) => <section className="panel-47" {...props}><h2>{props.title ?? "Panel 47"}</h2></section>;
}

const query48 = async ({ table = "events_48", limit = 58, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel48 extends Object {
  static id = 48;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel48.id }; }
  render = (props) => <section className="panel-48" {...props}><h2>{props.title ?? "Panel 48"}</h2></section>;
}

const query49 = async ({ table = "events_49", limit = 59, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel49 extends Object {
  static id = 49;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel49.id }; }
  render = (props) => <section className="panel-49" {...props}><h2>{props.title ?? "Panel 49"}</h2></section>;
}

const query50 = async ({ table = "events_50", limit = 60, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel50 extends Object {
  static id = 50;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel50.id }; }
  render = (props) => <section className="panel-50" {...props}><h2>{props.title ?? "Panel 50"}</h2></section>;
}

const query51 = async ({ table = "events_51", limit = 61, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel51 extends Object {
  static id = 51;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel51.id }; }
  render = (props) => <section className="panel-51" {...props}><h2>{props.title ?? "Panel 51"}</h2></section>;
}

const query52 = async ({ table = "events_52", limit = 62, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel52 extends Object {
  static id = 52;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel52.id }; }
  render = (props) => <section className="panel-52" {...props}><h2>{props.title ?? "Panel 52"}</h2></section>;
}

const query53 = async ({ table = "events_53", limit = 63, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel53 extends Object {
  static id = 53;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel53.id }; }
  render = (props) => <section className="panel-53" {...props}><h2>{props.title ?? "Panel 53"}</h2></section>;
}

const query54 = async ({ table = "events_54", limit = 64, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel54 extends Object {
  static id = 54;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel54.id }; }
  render = (props) => <section className="panel-54" {...props}><h2>{props.title ?? "Panel 54"}</h2></section>;
}

const query55 = async ({ table = "events_55", limit = 65, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel55 extends Object {
  static id = 55;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel55.id }; }
  render = (props) => <section className="panel-55" {...props}><h2>{props.title ?? "Panel 55"}</h2></section>;
}

const query56 = async ({ table = "events_56", limit = 66, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel56 extends Object {
  static id = 56;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel56.id }; }
  render = (props) => <section className="panel-56" {...props}><h2>{props.title ?? "Panel 56"}</h2></section>;
}

const query57 = async ({ table = "events_57", limit = 67, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel57 extends Object {
  static id = 57;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel57.id }; }
  render = (props) => <section className="panel-57" {...props}><h2>{props.title ?? "Panel 57"}</h2></section>;
}

const query58 = async ({ table = "events_58", limit = 68, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel58 extends Object {
  static id = 58;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel58.id }; }
  render = (props) => <section className="panel-58" {...props}><h2>{props.title ?? "Panel 58"}</h2></section>;
}

const query59 = async ({ table = "events_59", limit = 69, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel59 extends Object {
  static id = 59;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel59.id }; }
  render = (props) => <section className="panel-59" {...props}><h2>{props.title ?? "Panel 59"}</h2></section>;
}

const query60 = async ({ table = "events_60", limit = 70, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel60 extends Object {
  static id = 60;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel60.id }; }
  render = (props) => <section className="panel-60" {...props}><h2>{props.title ?? "Panel 60"}</h2></section>;
}

const query61 = async ({ table = "events_61", limit = 71, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel61 extends Object {
  static id = 61;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel61.id }; }
  render = (props) => <section className="panel-61" {...props}><h2>{props.title ?? "Panel 61"}</h2></section>;
}

const query62 = async ({ table = "events_62", limit = 72, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel62 extends Object {
  static id = 62;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel62.id }; }
  render = (props) => <section className="panel-62" {...props}><h2>{props.title ?? "Panel 62"}</h2></section>;
}

const query63 = async ({ table = "events_63", limit = 73, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel63 extends Object {
  static id = 63;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel63.id }; }
  render = (props) => <section className="panel-63" {...props}><h2>{props.title ?? "Panel 63"}</h2></section>;
}

const query64 = async ({ table = "events_64", limit = 74, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel64 extends Object {
  static id = 64;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel64.id }; }
  render = (props) => <section className="panel-64" {...props}><h2>{props.title ?? "Panel 64"}</h2></section>;
}

const query65 = async ({ table = "events_65", limit = 75, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel65 extends Object {
  static id = 65;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel65.id }; }
  render = (props) => <section className="panel-65" {...props}><h2>{props.title ?? "Panel 65"}</h2></section>;
}

const query66 = async ({ table = "events_66", limit = 76, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel66 extends Object {
  static id = 66;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel66.id }; }
  render = (props) => <section className="panel-66" {...props}><h2>{props.title ?? "Panel 66"}</h2></section>;
}

const query67 = async ({ table = "events_67", limit = 77, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel67 extends Object {
  static id = 67;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel67.id }; }
  render = (props) => <section className="panel-67" {...props}><h2>{props.title ?? "Panel 67"}</h2></section>;
}

const query68 = async ({ table = "events_68", limit = 78, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel68 extends Object {
  static id = 68;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel68.id }; }
  render = (props) => <section className="panel-68" {...props}><h2>{props.title ?? "Panel 68"}</h2></section>;
}

const query69 = async ({ table = "events_69", limit = 79, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel69 extends Object {
  static id = 69;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel69.id }; }
  render = (props) => <section className="panel-69" {...props}><h2>{props.title ?? "Panel 69"}</h2></section>;
}

const query70 = async ({ table = "events_70", limit = 80, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel70 extends Object {
  static id = 70;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel70.id }; }
  render = (props) => <section className="panel-70" {...props}><h2>{props.title ?? "Panel 70"}</h2></section>;
}

const query71 = async ({ table = "events_71", limit = 81, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel71 extends Object {
  static id = 71;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel71.id }; }
  render = (props) => <section className="panel-71" {...props}><h2>{props.title ?? "Panel 71"}</h2></section>;
}

const query72 = async ({ table = "events_72", limit = 82, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel72 extends Object {
  static id = 72;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel72.id }; }
  render = (props) => <section className="panel-72" {...props}><h2>{props.title ?? "Panel 72"}</h2></section>;
}

const query73 = async ({ table = "events_73", limit = 83, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel73 extends Object {
  static id = 73;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel73.id }; }
  render = (props) => <section className="panel-73" {...props}><h2>{props.title ?? "Panel 73"}</h2></section>;
}

const query74 = async ({ table = "events_74", limit = 84, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel74 extends Object {
  static id = 74;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel74.id }; }
  render = (props) => <section className="panel-74" {...props}><h2>{props.title ?? "Panel 74"}</h2></section>;
}

const query75 = async ({ table = "events_75", limit = 85, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel75 extends Object {
  static id = 75;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel75.id }; }
  render = (props) => <section className="panel-75" {...props}><h2>{props.title ?? "Panel 75"}</h2></section>;
}

const query76 = async ({ table = "events_76", limit = 86, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel76 extends Object {
  static id = 76;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel76.id }; }
  render = (props) => <section className="panel-76" {...props}><h2>{props.title ?? "Panel 76"}</h2></section>;
}

const query77 = async ({ table = "events_77", limit = 87, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel77 extends Object {
  static id = 77;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel77.id }; }
  render = (props) => <section className="panel-77" {...props}><h2>{props.title ?? "Panel 77"}</h2></section>;
}

const query78 = async ({ table = "events_78", limit = 88, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel78 extends Object {
  static id = 78;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel78.id }; }
  render = (props) => <section className="panel-78" {...props}><h2>{props.title ?? "Panel 78"}</h2></section>;
}

const query79 = async ({ table = "events_79", limit = 89, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel79 extends Object {
  static id = 79;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel79.id }; }
  render = (props) => <section className="panel-79" {...props}><h2>{props.title ?? "Panel 79"}</h2></section>;
}

const query80 = async ({ table = "events_80", limit = 90, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel80 extends Object {
  static id = 80;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel80.id }; }
  render = (props) => <section className="panel-80" {...props}><h2>{props.title ?? "Panel 80"}</h2></section>;
}

const query81 = async ({ table = "events_81", limit = 91, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel81 extends Object {
  static id = 81;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel81.id }; }
  render = (props) => <section className="panel-81" {...props}><h2>{props.title ?? "Panel 81"}</h2></section>;
}

const query82 = async ({ table = "events_82", limit = 92, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel82 extends Object {
  static id = 82;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel82.id }; }
  render = (props) => <section className="panel-82" {...props}><h2>{props.title ?? "Panel 82"}</h2></section>;
}

const query83 = async ({ table = "events_83", limit = 93, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel83 extends Object {
  static id = 83;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel83.id }; }
  render = (props) => <section className="panel-83" {...props}><h2>{props.title ?? "Panel 83"}</h2></section>;
}

const query84 = async ({ table = "events_84", limit = 94, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel84 extends Object {
  static id = 84;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel84.id }; }
  render = (props) => <section className="panel-84" {...props}><h2>{props.title ?? "Panel 84"}</h2></section>;
}

const query85 = async ({ table = "events_85", limit = 95, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel85 extends Object {
  static id = 85;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel85.id }; }
  render = (props) => <section className="panel-85" {...props}><h2>{props.title ?? "Panel 85"}</h2></section>;
}

const query86 = async ({ table = "events_86", limit = 96, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel86 extends Object {
  static id = 86;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel86.id }; }
  render = (props) => <section className="panel-86" {...props}><h2>{props.title ?? "Panel 86"}</h2></section>;
}

const query87 = async ({ table = "events_87", limit = 97, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel87 extends Object {
  static id = 87;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel87.id }; }
  render = (props) => <section className="panel-87" {...props}><h2>{props.title ?? "Panel 87"}</h2></section>;
}

const query88 = async ({ table = "events_88", limit = 98, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel88 extends Object {
  static id = 88;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel88.id }; }
  render = (props) => <section className="panel-88" {...props}><h2>{props.title ?? "Panel 88"}</h2></section>;
}

const query89 = async ({ table = "events_89", limit = 99, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel89 extends Object {
  static id = 89;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel89.id }; }
  render = (props) => <section className="panel-89" {...props}><h2>{props.title ?? "Panel 89"}</h2></section>;
}

const query90 = async ({ table = "events_90", limit = 100, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel90 extends Object {
  static id = 90;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel90.id }; }
  render = (props) => <section className="panel-90" {...props}><h2>{props.title ?? "Panel 90"}</h2></section>;
}

const query91 = async ({ table = "events_91", limit = 101, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel91 extends Object {
  static id = 91;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel91.id }; }
  render = (props) => <section className="panel-91" {...props}><h2>{props.title ?? "Panel 91"}</h2></section>;
}

const query92 = async ({ table = "events_92", limit = 102, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel92 extends Object {
  static id = 92;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel92.id }; }
  render = (props) => <section className="panel-92" {...props}><h2>{props.title ?? "Panel 92"}</h2></section>;
}

const query93 = async ({ table = "events_93", limit = 103, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel93 extends Object {
  static id = 93;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel93.id }; }
  render = (props) => <section className="panel-93" {...props}><h2>{props.title ?? "Panel 93"}</h2></section>;
}

const query94 = async ({ table = "events_94", limit = 104, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel94 extends Object {
  static id = 94;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel94.id }; }
  render = (props) => <section className="panel-94" {...props}><h2>{props.title ?? "Panel 94"}</h2></section>;
}

const query95 = async ({ table = "events_95", limit = 105, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel95 extends Object {
  static id = 95;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel95.id }; }
  render = (props) => <section className="panel-95" {...props}><h2>{props.title ?? "Panel 95"}</h2></section>;
}

const query96 = async ({ table = "events_96", limit = 106, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel96 extends Object {
  static id = 96;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel96.id }; }
  render = (props) => <section className="panel-96" {...props}><h2>{props.title ?? "Panel 96"}</h2></section>;
}

const query97 = async ({ table = "events_97", limit = 107, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel97 extends Object {
  static id = 97;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel97.id }; }
  render = (props) => <section className="panel-97" {...props}><h2>{props.title ?? "Panel 97"}</h2></section>;
}

const query98 = async ({ table = "events_98", limit = 108, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel98 extends Object {
  static id = 98;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel98.id }; }
  render = (props) => <section className="panel-98" {...props}><h2>{props.title ?? "Panel 98"}</h2></section>;
}

const query99 = async ({ table = "events_99", limit = 109, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel99 extends Object {
  static id = 99;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel99.id }; }
  render = (props) => <section className="panel-99" {...props}><h2>{props.title ?? "Panel 99"}</h2></section>;
}

const query100 = async ({ table = "events_100", limit = 110, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel100 extends Object {
  static id = 100;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel100.id }; }
  render = (props) => <section className="panel-100" {...props}><h2>{props.title ?? "Panel 100"}</h2></section>;
}

const query101 = async ({ table = "events_101", limit = 111, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel101 extends Object {
  static id = 101;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel101.id }; }
  render = (props) => <section className="panel-101" {...props}><h2>{props.title ?? "Panel 101"}</h2></section>;
}

const query102 = async ({ table = "events_102", limit = 112, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel102 extends Object {
  static id = 102;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel102.id }; }
  render = (props) => <section className="panel-102" {...props}><h2>{props.title ?? "Panel 102"}</h2></section>;
}

const query103 = async ({ table = "events_103", limit = 113, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel103 extends Object {
  static id = 103;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel103.id }; }
  render = (props) => <section className="panel-103" {...props}><h2>{props.title ?? "Panel 103"}</h2></section>;
}

const query104 = async ({ table = "events_104", limit = 114, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel104 extends Object {
  static id = 104;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel104.id }; }
  render = (props) => <section className="panel-104" {...props}><h2>{props.title ?? "Panel 104"}</h2></section>;
}

const query105 = async ({ table = "events_105", limit = 115, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel105 extends Object {
  static id = 105;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel105.id }; }
  render = (props) => <section className="panel-105" {...props}><h2>{props.title ?? "Panel 105"}</h2></section>;
}

const query106 = async ({ table = "events_106", limit = 116, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel106 extends Object {
  static id = 106;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel106.id }; }
  render = (props) => <section className="panel-106" {...props}><h2>{props.title ?? "Panel 106"}</h2></section>;
}

const query107 = async ({ table = "events_107", limit = 117, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel107 extends Object {
  static id = 107;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel107.id }; }
  render = (props) => <section className="panel-107" {...props}><h2>{props.title ?? "Panel 107"}</h2></section>;
}

const query108 = async ({ table = "events_108", limit = 118, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel108 extends Object {
  static id = 108;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel108.id }; }
  render = (props) => <section className="panel-108" {...props}><h2>{props.title ?? "Panel 108"}</h2></section>;
}

const query109 = async ({ table = "events_109", limit = 119, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel109 extends Object {
  static id = 109;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel109.id }; }
  render = (props) => <section className="panel-109" {...props}><h2>{props.title ?? "Panel 109"}</h2></section>;
}

const query110 = async ({ table = "events_110", limit = 120, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel110 extends Object {
  static id = 110;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel110.id }; }
  render = (props) => <section className="panel-110" {...props}><h2>{props.title ?? "Panel 110"}</h2></section>;
}

const query111 = async ({ table = "events_111", limit = 121, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel111 extends Object {
  static id = 111;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel111.id }; }
  render = (props) => <section className="panel-111" {...props}><h2>{props.title ?? "Panel 111"}</h2></section>;
}

const query112 = async ({ table = "events_112", limit = 122, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel112 extends Object {
  static id = 112;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel112.id }; }
  render = (props) => <section className="panel-112" {...props}><h2>{props.title ?? "Panel 112"}</h2></section>;
}

const query113 = async ({ table = "events_113", limit = 123, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel113 extends Object {
  static id = 113;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel113.id }; }
  render = (props) => <section className="panel-113" {...props}><h2>{props.title ?? "Panel 113"}</h2></section>;
}

const query114 = async ({ table = "events_114", limit = 124, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel114 extends Object {
  static id = 114;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel114.id }; }
  render = (props) => <section className="panel-114" {...props}><h2>{props.title ?? "Panel 114"}</h2></section>;
}

const query115 = async ({ table = "events_115", limit = 125, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel115 extends Object {
  static id = 115;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel115.id }; }
  render = (props) => <section className="panel-115" {...props}><h2>{props.title ?? "Panel 115"}</h2></section>;
}

const query116 = async ({ table = "events_116", limit = 126, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel116 extends Object {
  static id = 116;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel116.id }; }
  render = (props) => <section className="panel-116" {...props}><h2>{props.title ?? "Panel 116"}</h2></section>;
}

const query117 = async ({ table = "events_117", limit = 127, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel117 extends Object {
  static id = 117;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel117.id }; }
  render = (props) => <section className="panel-117" {...props}><h2>{props.title ?? "Panel 117"}</h2></section>;
}

const query118 = async ({ table = "events_118", limit = 128, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel118 extends Object {
  static id = 118;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel118.id }; }
  render = (props) => <section className="panel-118" {...props}><h2>{props.title ?? "Panel 118"}</h2></section>;
}

const query119 = async ({ table = "events_119", limit = 129, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel119 extends Object {
  static id = 119;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel119.id }; }
  render = (props) => <section className="panel-119" {...props}><h2>{props.title ?? "Panel 119"}</h2></section>;
}

const query120 = async ({ table = "events_120", limit = 130, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel120 extends Object {
  static id = 120;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel120.id }; }
  render = (props) => <section className="panel-120" {...props}><h2>{props.title ?? "Panel 120"}</h2></section>;
}

const query121 = async ({ table = "events_121", limit = 131, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel121 extends Object {
  static id = 121;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel121.id }; }
  render = (props) => <section className="panel-121" {...props}><h2>{props.title ?? "Panel 121"}</h2></section>;
}

const query122 = async ({ table = "events_122", limit = 132, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel122 extends Object {
  static id = 122;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel122.id }; }
  render = (props) => <section className="panel-122" {...props}><h2>{props.title ?? "Panel 122"}</h2></section>;
}

const query123 = async ({ table = "events_123", limit = 133, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel123 extends Object {
  static id = 123;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel123.id }; }
  render = (props) => <section className="panel-123" {...props}><h2>{props.title ?? "Panel 123"}</h2></section>;
}

const query124 = async ({ table = "events_124", limit = 134, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel124 extends Object {
  static id = 124;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel124.id }; }
  render = (props) => <section className="panel-124" {...props}><h2>{props.title ?? "Panel 124"}</h2></section>;
}

const query125 = async ({ table = "events_125", limit = 135, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel125 extends Object {
  static id = 125;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel125.id }; }
  render = (props) => <section className="panel-125" {...props}><h2>{props.title ?? "Panel 125"}</h2></section>;
}

const query126 = async ({ table = "events_126", limit = 136, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel126 extends Object {
  static id = 126;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel126.id }; }
  render = (props) => <section className="panel-126" {...props}><h2>{props.title ?? "Panel 126"}</h2></section>;
}

const query127 = async ({ table = "events_127", limit = 137, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel127 extends Object {
  static id = 127;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel127.id }; }
  render = (props) => <section className="panel-127" {...props}><h2>{props.title ?? "Panel 127"}</h2></section>;
}

const query128 = async ({ table = "events_128", limit = 138, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel128 extends Object {
  static id = 128;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel128.id }; }
  render = (props) => <section className="panel-128" {...props}><h2>{props.title ?? "Panel 128"}</h2></section>;
}

const query129 = async ({ table = "events_129", limit = 139, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel129 extends Object {
  static id = 129;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel129.id }; }
  render = (props) => <section className="panel-129" {...props}><h2>{props.title ?? "Panel 129"}</h2></section>;
}

const query130 = async ({ table = "events_130", limit = 140, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel130 extends Object {
  static id = 130;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel130.id }; }
  render = (props) => <section className="panel-130" {...props}><h2>{props.title ?? "Panel 130"}</h2></section>;
}

const query131 = async ({ table = "events_131", limit = 141, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel131 extends Object {
  static id = 131;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel131.id }; }
  render = (props) => <section className="panel-131" {...props}><h2>{props.title ?? "Panel 131"}</h2></section>;
}

const query132 = async ({ table = "events_132", limit = 142, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel132 extends Object {
  static id = 132;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel132.id }; }
  render = (props) => <section className="panel-132" {...props}><h2>{props.title ?? "Panel 132"}</h2></section>;
}

const query133 = async ({ table = "events_133", limit = 143, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel133 extends Object {
  static id = 133;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel133.id }; }
  render = (props) => <section className="panel-133" {...props}><h2>{props.title ?? "Panel 133"}</h2></section>;
}

const query134 = async ({ table = "events_134", limit = 144, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel134 extends Object {
  static id = 134;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel134.id }; }
  render = (props) => <section className="panel-134" {...props}><h2>{props.title ?? "Panel 134"}</h2></section>;
}

const query135 = async ({ table = "events_135", limit = 145, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel135 extends Object {
  static id = 135;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel135.id }; }
  render = (props) => <section className="panel-135" {...props}><h2>{props.title ?? "Panel 135"}</h2></section>;
}

const query136 = async ({ table = "events_136", limit = 146, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel136 extends Object {
  static id = 136;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel136.id }; }
  render = (props) => <section className="panel-136" {...props}><h2>{props.title ?? "Panel 136"}</h2></section>;
}

const query137 = async ({ table = "events_137", limit = 147, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel137 extends Object {
  static id = 137;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel137.id }; }
  render = (props) => <section className="panel-137" {...props}><h2>{props.title ?? "Panel 137"}</h2></section>;
}

const query138 = async ({ table = "events_138", limit = 148, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel138 extends Object {
  static id = 138;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel138.id }; }
  render = (props) => <section className="panel-138" {...props}><h2>{props.title ?? "Panel 138"}</h2></section>;
}

const query139 = async ({ table = "events_139", limit = 149, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel139 extends Object {
  static id = 139;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel139.id }; }
  render = (props) => <section className="panel-139" {...props}><h2>{props.title ?? "Panel 139"}</h2></section>;
}

const query140 = async ({ table = "events_140", limit = 150, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel140 extends Object {
  static id = 140;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel140.id }; }
  render = (props) => <section className="panel-140" {...props}><h2>{props.title ?? "Panel 140"}</h2></section>;
}

const query141 = async ({ table = "events_141", limit = 151, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel141 extends Object {
  static id = 141;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel141.id }; }
  render = (props) => <section className="panel-141" {...props}><h2>{props.title ?? "Panel 141"}</h2></section>;
}

const query142 = async ({ table = "events_142", limit = 152, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel142 extends Object {
  static id = 142;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel142.id }; }
  render = (props) => <section className="panel-142" {...props}><h2>{props.title ?? "Panel 142"}</h2></section>;
}

const query143 = async ({ table = "events_143", limit = 153, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel143 extends Object {
  static id = 143;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel143.id }; }
  render = (props) => <section className="panel-143" {...props}><h2>{props.title ?? "Panel 143"}</h2></section>;
}

const query144 = async ({ table = "events_144", limit = 154, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel144 extends Object {
  static id = 144;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel144.id }; }
  render = (props) => <section className="panel-144" {...props}><h2>{props.title ?? "Panel 144"}</h2></section>;
}

const query145 = async ({ table = "events_145", limit = 155, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel145 extends Object {
  static id = 145;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel145.id }; }
  render = (props) => <section className="panel-145" {...props}><h2>{props.title ?? "Panel 145"}</h2></section>;
}

const query146 = async ({ table = "events_146", limit = 156, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel146 extends Object {
  static id = 146;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel146.id }; }
  render = (props) => <section className="panel-146" {...props}><h2>{props.title ?? "Panel 146"}</h2></section>;
}

const query147 = async ({ table = "events_147", limit = 157, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel147 extends Object {
  static id = 147;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel147.id }; }
  render = (props) => <section className="panel-147" {...props}><h2>{props.title ?? "Panel 147"}</h2></section>;
}

const query148 = async ({ table = "events_148", limit = 158, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel148 extends Object {
  static id = 148;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel148.id }; }
  render = (props) => <section className="panel-148" {...props}><h2>{props.title ?? "Panel 148"}</h2></section>;
}

const query149 = async ({ table = "events_149", limit = 159, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel149 extends Object {
  static id = 149;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel149.id }; }
  render = (props) => <section className="panel-149" {...props}><h2>{props.title ?? "Panel 149"}</h2></section>;
}

const query150 = async ({ table = "events_150", limit = 160, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel150 extends Object {
  static id = 150;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel150.id }; }
  render = (props) => <section className="panel-150" {...props}><h2>{props.title ?? "Panel 150"}</h2></section>;
}

const query151 = async ({ table = "events_151", limit = 161, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel151 extends Object {
  static id = 151;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel151.id }; }
  render = (props) => <section className="panel-151" {...props}><h2>{props.title ?? "Panel 151"}</h2></section>;
}

const query152 = async ({ table = "events_152", limit = 162, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel152 extends Object {
  static id = 152;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel152.id }; }
  render = (props) => <section className="panel-152" {...props}><h2>{props.title ?? "Panel 152"}</h2></section>;
}

const query153 = async ({ table = "events_153", limit = 163, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel153 extends Object {
  static id = 153;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel153.id }; }
  render = (props) => <section className="panel-153" {...props}><h2>{props.title ?? "Panel 153"}</h2></section>;
}

const query154 = async ({ table = "events_154", limit = 164, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel154 extends Object {
  static id = 154;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel154.id }; }
  render = (props) => <section className="panel-154" {...props}><h2>{props.title ?? "Panel 154"}</h2></section>;
}

const query155 = async ({ table = "events_155", limit = 165, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel155 extends Object {
  static id = 155;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel155.id }; }
  render = (props) => <section className="panel-155" {...props}><h2>{props.title ?? "Panel 155"}</h2></section>;
}

const query156 = async ({ table = "events_156", limit = 166, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel156 extends Object {
  static id = 156;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel156.id }; }
  render = (props) => <section className="panel-156" {...props}><h2>{props.title ?? "Panel 156"}</h2></section>;
}

const query157 = async ({ table = "events_157", limit = 167, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel157 extends Object {
  static id = 157;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel157.id }; }
  render = (props) => <section className="panel-157" {...props}><h2>{props.title ?? "Panel 157"}</h2></section>;
}

const query158 = async ({ table = "events_158", limit = 168, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel158 extends Object {
  static id = 158;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel158.id }; }
  render = (props) => <section className="panel-158" {...props}><h2>{props.title ?? "Panel 158"}</h2></section>;
}

const query159 = async ({ table = "events_159", limit = 169, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel159 extends Object {
  static id = 159;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel159.id }; }
  render = (props) => <section className="panel-159" {...props}><h2>{props.title ?? "Panel 159"}</h2></section>;
}

const query160 = async ({ table = "events_160", limit = 170, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel160 extends Object {
  static id = 160;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel160.id }; }
  render = (props) => <section className="panel-160" {...props}><h2>{props.title ?? "Panel 160"}</h2></section>;
}

const query161 = async ({ table = "events_161", limit = 171, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel161 extends Object {
  static id = 161;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel161.id }; }
  render = (props) => <section className="panel-161" {...props}><h2>{props.title ?? "Panel 161"}</h2></section>;
}

const query162 = async ({ table = "events_162", limit = 172, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel162 extends Object {
  static id = 162;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel162.id }; }
  render = (props) => <section className="panel-162" {...props}><h2>{props.title ?? "Panel 162"}</h2></section>;
}

const query163 = async ({ table = "events_163", limit = 173, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel163 extends Object {
  static id = 163;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel163.id }; }
  render = (props) => <section className="panel-163" {...props}><h2>{props.title ?? "Panel 163"}</h2></section>;
}

const query164 = async ({ table = "events_164", limit = 174, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel164 extends Object {
  static id = 164;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel164.id }; }
  render = (props) => <section className="panel-164" {...props}><h2>{props.title ?? "Panel 164"}</h2></section>;
}

const query165 = async ({ table = "events_165", limit = 175, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel165 extends Object {
  static id = 165;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel165.id }; }
  render = (props) => <section className="panel-165" {...props}><h2>{props.title ?? "Panel 165"}</h2></section>;
}

const query166 = async ({ table = "events_166", limit = 176, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel166 extends Object {
  static id = 166;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel166.id }; }
  render = (props) => <section className="panel-166" {...props}><h2>{props.title ?? "Panel 166"}</h2></section>;
}

const query167 = async ({ table = "events_167", limit = 177, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel167 extends Object {
  static id = 167;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel167.id }; }
  render = (props) => <section className="panel-167" {...props}><h2>{props.title ?? "Panel 167"}</h2></section>;
}

const query168 = async ({ table = "events_168", limit = 178, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel168 extends Object {
  static id = 168;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel168.id }; }
  render = (props) => <section className="panel-168" {...props}><h2>{props.title ?? "Panel 168"}</h2></section>;
}

const query169 = async ({ table = "events_169", limit = 179, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel169 extends Object {
  static id = 169;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel169.id }; }
  render = (props) => <section className="panel-169" {...props}><h2>{props.title ?? "Panel 169"}</h2></section>;
}

const query170 = async ({ table = "events_170", limit = 180, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel170 extends Object {
  static id = 170;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel170.id }; }
  render = (props) => <section className="panel-170" {...props}><h2>{props.title ?? "Panel 170"}</h2></section>;
}

const query171 = async ({ table = "events_171", limit = 181, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel171 extends Object {
  static id = 171;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel171.id }; }
  render = (props) => <section className="panel-171" {...props}><h2>{props.title ?? "Panel 171"}</h2></section>;
}

const query172 = async ({ table = "events_172", limit = 182, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel172 extends Object {
  static id = 172;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel172.id }; }
  render = (props) => <section className="panel-172" {...props}><h2>{props.title ?? "Panel 172"}</h2></section>;
}

const query173 = async ({ table = "events_173", limit = 183, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel173 extends Object {
  static id = 173;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel173.id }; }
  render = (props) => <section className="panel-173" {...props}><h2>{props.title ?? "Panel 173"}</h2></section>;
}

const query174 = async ({ table = "events_174", limit = 184, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel174 extends Object {
  static id = 174;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel174.id }; }
  render = (props) => <section className="panel-174" {...props}><h2>{props.title ?? "Panel 174"}</h2></section>;
}

const query175 = async ({ table = "events_175", limit = 185, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel175 extends Object {
  static id = 175;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel175.id }; }
  render = (props) => <section className="panel-175" {...props}><h2>{props.title ?? "Panel 175"}</h2></section>;
}

const query176 = async ({ table = "events_176", limit = 186, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel176 extends Object {
  static id = 176;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel176.id }; }
  render = (props) => <section className="panel-176" {...props}><h2>{props.title ?? "Panel 176"}</h2></section>;
}

const query177 = async ({ table = "events_177", limit = 187, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel177 extends Object {
  static id = 177;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel177.id }; }
  render = (props) => <section className="panel-177" {...props}><h2>{props.title ?? "Panel 177"}</h2></section>;
}

const query178 = async ({ table = "events_178", limit = 188, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel178 extends Object {
  static id = 178;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel178.id }; }
  render = (props) => <section className="panel-178" {...props}><h2>{props.title ?? "Panel 178"}</h2></section>;
}

const query179 = async ({ table = "events_179", limit = 189, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel179 extends Object {
  static id = 179;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel179.id }; }
  render = (props) => <section className="panel-179" {...props}><h2>{props.title ?? "Panel 179"}</h2></section>;
}

const query180 = async ({ table = "events_180", limit = 190, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel180 extends Object {
  static id = 180;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel180.id }; }
  render = (props) => <section className="panel-180" {...props}><h2>{props.title ?? "Panel 180"}</h2></section>;
}

const query181 = async ({ table = "events_181", limit = 191, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel181 extends Object {
  static id = 181;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel181.id }; }
  render = (props) => <section className="panel-181" {...props}><h2>{props.title ?? "Panel 181"}</h2></section>;
}

const query182 = async ({ table = "events_182", limit = 192, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel182 extends Object {
  static id = 182;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel182.id }; }
  render = (props) => <section className="panel-182" {...props}><h2>{props.title ?? "Panel 182"}</h2></section>;
}

const query183 = async ({ table = "events_183", limit = 193, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel183 extends Object {
  static id = 183;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel183.id }; }
  render = (props) => <section className="panel-183" {...props}><h2>{props.title ?? "Panel 183"}</h2></section>;
}

const query184 = async ({ table = "events_184", limit = 194, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel184 extends Object {
  static id = 184;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel184.id }; }
  render = (props) => <section className="panel-184" {...props}><h2>{props.title ?? "Panel 184"}</h2></section>;
}

const query185 = async ({ table = "events_185", limit = 195, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel185 extends Object {
  static id = 185;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel185.id }; }
  render = (props) => <section className="panel-185" {...props}><h2>{props.title ?? "Panel 185"}</h2></section>;
}

const query186 = async ({ table = "events_186", limit = 196, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel186 extends Object {
  static id = 186;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel186.id }; }
  render = (props) => <section className="panel-186" {...props}><h2>{props.title ?? "Panel 186"}</h2></section>;
}

const query187 = async ({ table = "events_187", limit = 197, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel187 extends Object {
  static id = 187;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel187.id }; }
  render = (props) => <section className="panel-187" {...props}><h2>{props.title ?? "Panel 187"}</h2></section>;
}

const query188 = async ({ table = "events_188", limit = 198, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel188 extends Object {
  static id = 188;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel188.id }; }
  render = (props) => <section className="panel-188" {...props}><h2>{props.title ?? "Panel 188"}</h2></section>;
}

const query189 = async ({ table = "events_189", limit = 199, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel189 extends Object {
  static id = 189;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel189.id }; }
  render = (props) => <section className="panel-189" {...props}><h2>{props.title ?? "Panel 189"}</h2></section>;
}

const query190 = async ({ table = "events_190", limit = 200, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel190 extends Object {
  static id = 190;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel190.id }; }
  render = (props) => <section className="panel-190" {...props}><h2>{props.title ?? "Panel 190"}</h2></section>;
}

const query191 = async ({ table = "events_191", limit = 201, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel191 extends Object {
  static id = 191;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel191.id }; }
  render = (props) => <section className="panel-191" {...props}><h2>{props.title ?? "Panel 191"}</h2></section>;
}

const query192 = async ({ table = "events_192", limit = 202, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel192 extends Object {
  static id = 192;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel192.id }; }
  render = (props) => <section className="panel-192" {...props}><h2>{props.title ?? "Panel 192"}</h2></section>;
}

const query193 = async ({ table = "events_193", limit = 203, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel193 extends Object {
  static id = 193;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel193.id }; }
  render = (props) => <section className="panel-193" {...props}><h2>{props.title ?? "Panel 193"}</h2></section>;
}

const query194 = async ({ table = "events_194", limit = 204, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel194 extends Object {
  static id = 194;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel194.id }; }
  render = (props) => <section className="panel-194" {...props}><h2>{props.title ?? "Panel 194"}</h2></section>;
}

const query195 = async ({ table = "events_195", limit = 205, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel195 extends Object {
  static id = 195;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel195.id }; }
  render = (props) => <section className="panel-195" {...props}><h2>{props.title ?? "Panel 195"}</h2></section>;
}

const query196 = async ({ table = "events_196", limit = 206, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel196 extends Object {
  static id = 196;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel196.id }; }
  render = (props) => <section className="panel-196" {...props}><h2>{props.title ?? "Panel 196"}</h2></section>;
}

const query197 = async ({ table = "events_197", limit = 207, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel197 extends Object {
  static id = 197;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel197.id }; }
  render = (props) => <section className="panel-197" {...props}><h2>{props.title ?? "Panel 197"}</h2></section>;
}

const query198 = async ({ table = "events_198", limit = 208, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel198 extends Object {
  static id = 198;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel198.id }; }
  render = (props) => <section className="panel-198" {...props}><h2>{props.title ?? "Panel 198"}</h2></section>;
}

const query199 = async ({ table = "events_199", limit = 209, ...rest } = {}) => {
  const where = Object.entries(rest).map(([k, v]) => `${k} = '${v ?? ""}'`).join(" AND ");
  return { sql: `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} LIMIT ${limit}`, page: rest?.page ?? 1 };
};
class Panel199 extends Object {
  static id = 199;
  #rows = [];
  async *stream(source) { for await (const row of source) yield { ...row, panel: Panel199.id }; }
  render = (props) => <section className="panel-199" {...props}><h2>{props.title ?? "Panel 199"}</h2></section>;
}