@pg-boss/proxy 0.1.0

package/dist/contracts.js

@@ -0,0 +1,424 @@
+import { z } from 'zod';
+// ============== Base Types ==============
+export const jsonRecordSchema = z.record(z.string(), z.unknown());
+export const nullableJsonRecordSchema = jsonRecordSchema.nullable();
+export const dateInputSchema = z.union([z.string(), z.number()]);
+export const queueNameSchema = z.string().min(1);
+export const eventNameSchema = z.string().min(1);
+export const errorResultSchema = z.object({
+    ok: z.literal(false),
+    error: z.object({
+        message: z.string()
+    })
+});
+export const htmlResponseSchema = z.string();
+// ============== pg-boss Types ==============
+export const groupOptionsSchema = z.object({
+    id: z.string(),
+    tier: z.string().optional()
+});
+export const groupConcurrencyConfigSchema = z.object({
+    default: z.number(),
+    tiers: z.record(z.string(), z.number()).optional()
+});
+const sendOptionsSchemaBase = z.object({
+    id: z.string().optional(),
+    priority: z.number().optional(),
+    startAfter: dateInputSchema.optional(),
+    singletonKey: z.string().optional(),
+    singletonSeconds: z.number().optional(),
+    singletonNextSlot: z.boolean().optional(),
+    keepUntil: dateInputSchema.optional(),
+    group: groupOptionsSchema.optional(),
+    deadLetter: z.string().optional(),
+    expireInSeconds: z.number().optional(),
+    retentionSeconds: z.number().optional(),
+    deleteAfterSeconds: z.number().optional(),
+    retryLimit: z.number().optional(),
+    retryDelay: z.number().optional(),
+    retryBackoff: z.boolean().optional(),
+    retryDelayMax: z.number().optional(),
+    heartbeatSeconds: z.number().optional(),
+});
+export const sendOptionsSchema = sendOptionsSchemaBase;
+export const queueOptionsSchema = z.object({
+    expireInSeconds: z.number().optional(),
+    retentionSeconds: z.number().optional(),
+    deleteAfterSeconds: z.number().optional(),
+    retryLimit: z.number().optional(),
+    retryDelay: z.number().optional(),
+    retryBackoff: z.boolean().optional(),
+    retryDelayMax: z.number().optional(),
+    heartbeatSeconds: z.number().optional(),
+});
+export const scheduleOptionsSchema = sendOptionsSchemaBase.extend({
+    tz: z.string().optional(),
+    key: z.string().optional(),
+});
+export const fetchOptionsSchema = z.object({
+    includeMetadata: z.boolean().optional(),
+    priority: z.boolean().optional(),
+    orderByCreatedOn: z.boolean().optional(),
+    batchSize: z.number().optional(),
+    ignoreStartAfter: z.boolean().optional(),
+    groupConcurrency: z.union([z.number(), groupConcurrencyConfigSchema]).optional(),
+    ignoreGroups: z.array(z.string()).nullable().optional(),
+});
+export const findJobsOptionsSchema = z.object({
+    id: z.string().optional(),
+    key: z.string().optional(),
+    data: jsonRecordSchema.optional(),
+    queued: z.boolean().optional(),
+});
+export const insertOptionsSchema = z.object({
+    returnId: z.boolean().optional(),
+});
+export const completeOptionsSchema = z.object({
+    includeQueued: z.boolean().optional(),
+});
+export const jobInsertSchema = z.object({
+    id: z.string().optional(),
+    data: jsonRecordSchema.optional(),
+    priority: z.number().optional(),
+    retryLimit: z.number().optional(),
+    retryDelay: z.number().optional(),
+    retryBackoff: z.boolean().optional(),
+    retryDelayMax: z.number().optional(),
+    startAfter: dateInputSchema.optional(),
+    singletonKey: z.string().optional(),
+    singletonSeconds: z.number().optional(),
+    expireInSeconds: z.number().optional(),
+    deleteAfterSeconds: z.number().optional(),
+    retentionSeconds: z.number().optional(),
+    heartbeatSeconds: z.number().optional(),
+    group: groupOptionsSchema.optional(),
+    deadLetter: z.string().optional(),
+});
+const jobSchemaBase = z.object({
+    id: z.string(),
+    name: z.string(),
+    data: jsonRecordSchema,
+    expireInSeconds: z.number(),
+    heartbeatSeconds: z.number().nullable(),
+    groupId: z.string().optional().nullable(),
+    groupTier: z.string().optional().nullable(),
+});
+export const jobSchema = jobSchemaBase;
+export const jobWithMetadataSchema = jobSchemaBase.extend({
+    priority: z.number(),
+    state: z.enum(['created', 'retry', 'active', 'completed', 'cancelled', 'failed']),
+    retryLimit: z.number(),
+    retryCount: z.number(),
+    retryDelay: z.number(),
+    retryBackoff: z.boolean(),
+    retryDelayMax: z.number().optional(),
+    startAfter: z.iso.datetime().transform((val) => new Date(val)),
+    startedOn: z.iso.datetime().transform((val) => new Date(val)),
+    singletonKey: z.string().nullable(),
+    singletonOn: z.string().nullable(),
+    deleteAfterSeconds: z.number(),
+    createdOn: z.iso.datetime().transform((val) => new Date(val)),
+    completedOn: z.iso.datetime().nullable().transform((val) => val ? new Date(val) : null),
+    keepUntil: z.iso.datetime().transform((val) => new Date(val)),
+    policy: z.string(),
+    deadLetter: z.string(),
+    output: jsonRecordSchema,
+});
+export const commandResponseSchema = z.object({
+    jobs: z.array(z.string()),
+    requested: z.number(),
+    affected: z.number(),
+});
+export const queueResultSchema = z.object({
+    name: z.string(),
+    expireInSeconds: z.number().optional(),
+    retentionSeconds: z.number().optional(),
+    deleteAfterSeconds: z.number().optional(),
+    retryLimit: z.number().optional(),
+    retryDelay: z.number().optional(),
+    retryBackoff: z.boolean().optional(),
+    retryDelayMax: z.number().optional(),
+    policy: z.string().optional(),
+    partition: z.boolean().optional(),
+    deadLetter: z.string().optional(),
+    warningQueueSize: z.number().optional(),
+    heartbeatSeconds: z.number().optional(),
+    deferredCount: z.number(),
+    queuedCount: z.number(),
+    activeCount: z.number(),
+    totalCount: z.number(),
+    table: z.string(),
+    createdOn: z.iso.datetime().transform((val) => new Date(val)),
+    updatedOn: z.iso.datetime().transform((val) => new Date(val)),
+    singletonsActive: z.array(z.string()).nullable(),
+});
+export const scheduleSchema = z.object({
+    name: z.string(),
+    key: z.string(),
+    cron: z.string(),
+    timezone: z.string(),
+    data: jsonRecordSchema.optional(),
+    options: sendOptionsSchema.optional(),
+});
+export const bamStatusSummarySchema = z.object({
+    status: z.enum(['pending', 'in_progress', 'completed', 'failed']),
+    count: z.number(),
+    lastCreatedOn: z.iso.datetime().transform((val) => new Date(val)),
+});
+// ============== Request/Response Types ==============
+export const metaResultSchema = z.object({
+    states: z.record(z.string(), z.string()),
+    policies: z.record(z.string(), z.string()),
+    events: z.record(z.string(), z.string())
+});
+export const metaResponseSchema = z.object({
+    ok: z.literal(true),
+    result: metaResultSchema
+});
+export const sendRequestSchema = z.object({
+    name: queueNameSchema,
+    data: nullableJsonRecordSchema.optional(),
+    options: sendOptionsSchema.optional()
+});
+export const sendResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.string().nullable()
+});
+export const sendAfterRequestSchema = z.object({
+    name: queueNameSchema,
+    data: nullableJsonRecordSchema.optional(),
+    options: sendOptionsSchema.optional().nullable(),
+    after: dateInputSchema
+});
+export const sendAfterResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.string().nullable()
+});
+export const sendThrottledRequestSchema = z.object({
+    name: queueNameSchema,
+    data: nullableJsonRecordSchema.optional(),
+    options: sendOptionsSchema.optional().nullable(),
+    seconds: z.number(),
+    key: z.string().optional()
+});
+export const sendThrottledResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.string().nullable()
+});
+export const sendDebouncedRequestSchema = z.object({
+    name: queueNameSchema,
+    data: nullableJsonRecordSchema.optional(),
+    options: sendOptionsSchema.optional().nullable(),
+    seconds: z.number(),
+    key: z.string().optional()
+});
+export const sendDebouncedResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.string().nullable()
+});
+export const insertRequestSchema = z.object({
+    name: queueNameSchema,
+    jobs: z.array(jobInsertSchema),
+    options: insertOptionsSchema.optional()
+});
+export const insertResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.array(z.string()).nullable()
+});
+export const fetchRequestSchema = z.object({
+    name: queueNameSchema,
+    options: fetchOptionsSchema.optional()
+});
+export const fetchResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.union([z.array(jobWithMetadataSchema), z.array(jobSchema)])
+});
+export const subscribeRequestSchema = z.object({
+    event: eventNameSchema,
+    name: queueNameSchema
+});
+export const subscribeResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const unsubscribeRequestSchema = z.object({
+    event: eventNameSchema,
+    name: queueNameSchema
+});
+export const unsubscribeResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const publishRequestSchema = z.object({
+    event: eventNameSchema,
+    data: nullableJsonRecordSchema.optional(),
+    options: sendOptionsSchema.optional()
+});
+export const publishResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const cancelRequestSchema = z.object({
+    name: queueNameSchema,
+    id: z.union([z.string(), z.array(z.string())])
+});
+export const cancelResponseSchema = z.object({
+    ok: z.literal(true),
+    result: commandResponseSchema
+});
+export const resumeRequestSchema = z.object({
+    name: queueNameSchema,
+    id: z.union([z.string(), z.array(z.string())])
+});
+export const resumeResponseSchema = z.object({
+    ok: z.literal(true),
+    result: commandResponseSchema
+});
+export const retryRequestSchema = z.object({
+    name: queueNameSchema,
+    id: z.union([z.string(), z.array(z.string())])
+});
+export const retryResponseSchema = z.object({
+    ok: z.literal(true),
+    result: commandResponseSchema
+});
+export const deleteJobRequestSchema = z.object({
+    name: queueNameSchema,
+    id: z.union([z.string(), z.array(z.string())])
+});
+export const deleteJobResponseSchema = z.object({
+    ok: z.literal(true),
+    result: commandResponseSchema
+});
+export const deleteQueuedJobsRequestSchema = z.object({
+    name: queueNameSchema
+});
+export const deleteQueuedJobsResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const deleteStoredJobsRequestSchema = z.object({
+    name: queueNameSchema
+});
+export const deleteStoredJobsResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const deleteAllJobsRequestSchema = z.object({
+    name: queueNameSchema.optional()
+});
+export const deleteAllJobsResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const completeRequestSchema = z.object({
+    name: queueNameSchema,
+    id: z.union([z.string(), z.array(z.string())]),
+    data: nullableJsonRecordSchema.optional(),
+    options: completeOptionsSchema.optional()
+});
+export const completeResponseSchema = z.object({
+    ok: z.literal(true),
+    result: commandResponseSchema
+});
+export const failRequestSchema = z.object({
+    name: queueNameSchema,
+    id: z.union([z.string(), z.array(z.string())]),
+    data: nullableJsonRecordSchema.optional()
+});
+export const failResponseSchema = z.object({
+    ok: z.literal(true),
+    result: commandResponseSchema
+});
+export const findJobsResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.array(jobWithMetadataSchema)
+});
+export const createQueueRequestSchema = z.object({
+    name: queueNameSchema,
+    options: queueOptionsSchema.and(z.object({
+        policy: z.string().optional(),
+        partition: z.boolean().optional(),
+        deadLetter: z.string().optional(),
+        warningQueueSize: z.number().optional()
+    })).optional()
+});
+export const createQueueResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const getBlockedKeysResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.array(z.string())
+});
+export const updateQueueRequestSchema = z.object({
+    name: queueNameSchema,
+    options: queueOptionsSchema.and(z.object({
+        deadLetter: z.string().optional(),
+        warningQueueSize: z.number().optional()
+    })).optional()
+});
+export const updateQueueResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const deleteQueueRequestSchema = z.object({
+    name: queueNameSchema
+});
+export const deleteQueueResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const getQueuesResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.array(queueResultSchema)
+});
+export const getQueueResponseSchema = z.object({
+    ok: z.literal(true),
+    result: queueResultSchema.nullable()
+});
+export const getQueueStatsResponseSchema = z.object({
+    ok: z.literal(true),
+    result: queueResultSchema
+});
+export const superviseRequestSchema = z.object({
+    name: queueNameSchema.optional()
+});
+export const superviseResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const isInstalledResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.boolean()
+});
+export const schemaVersionResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.number().nullable()
+});
+export const scheduleRequestSchema = z.object({
+    name: queueNameSchema,
+    cron: z.string(),
+    data: nullableJsonRecordSchema.optional(),
+    options: scheduleOptionsSchema.optional()
+});
+export const scheduleResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const unscheduleRequestSchema = z.object({
+    name: queueNameSchema,
+    key: z.string().optional()
+});
+export const unscheduleResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.null()
+});
+export const getSchedulesResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.array(scheduleSchema)
+});
+export const getBamStatusResponseSchema = z.object({
+    ok: z.literal(true),
+    result: z.array(bamStatusSummarySchema)
+});

package/dist/home.d.ts

@@ -0,0 +1,13 @@
+type MethodInfo = {
+    method: string;
+    httpMethod: 'get' | 'post';
+};
+type HomeParams = {
+    base: string;
+    openapiPath: string;
+    docsPath: string;
+    methods: MethodInfo[];
+};
+export declare const renderHome: ({ base, openapiPath, docsPath, methods }: HomeParams) => import("hono/utils/html").HtmlEscapedString | Promise<import("hono/utils/html").HtmlEscapedString>;
+export {};
+//# sourceMappingURL=home.d.ts.map

package/dist/home.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"home.d.ts","sourceRoot":"","sources":["../src/home.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,KAAK,GAAG,MAAM,CAAA;CAC3B,CAAA;AAED,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,UAAU,EAAE,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,0CAA0C,UAAU,uGAkJ9E,CAAA"}

package/dist/home.js

@@ -0,0 +1,145 @@
+import { html, raw } from 'hono/html';
+export const renderHome = ({ base, openapiPath, docsPath, methods }) => {
+    const methodList = raw(methods.map((m) => `<li><code><span class="http-method ${m.httpMethod}">${m.httpMethod.toUpperCase()}</span> ${base}/${m.method}</code></li>`).join(''));
+    return html `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>pg-boss proxy</title>
+    <style>
+      :root {
+        color-scheme: light;
+        --bg: #f3f0e7;
+        --panel: #ffffff;
+        --ink: #1a1a1a;
+        --muted: #5f5f5f;
+        --accent: #b63b2e;
+        --accent-2: #0e5966;
+      }
+      body {
+        margin: 0;
+        font-family: "IBM Plex Sans", "Segoe UI", sans-serif;
+        color: var(--ink);
+        background: radial-gradient(circle at top left, #fdf7e9 0%, var(--bg) 55%, #efe6d1 100%);
+      }
+      main {
+        max-width: 980px;
+        margin: 0 auto;
+        padding: 56px 24px 80px;
+      }
+      header {
+        display: grid;
+        grid-template-columns: minmax(0, 1fr);
+        gap: 20px;
+        margin-bottom: 32px;
+      }
+      h1 {
+        font-family: "Space Grotesk", "Segoe UI", sans-serif;
+        font-size: clamp(2.4rem, 3vw, 3.4rem);
+        letter-spacing: -0.02em;
+        margin: 0;
+      }
+      p {
+        margin: 0;
+        color: var(--muted);
+        font-size: 1.05rem;
+        line-height: 1.6;
+      }
+      .cards {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+        gap: 16px;
+        margin: 32px 0 40px;
+      }
+      .card {
+        background: var(--panel);
+        border-radius: 16px;
+        padding: 18px;
+        border: 1px solid #e2d8c5;
+        box-shadow: 0 10px 30px rgba(28, 26, 23, 0.08);
+      }
+      .card h3 {
+        margin: 0 0 8px;
+        font-family: "Space Grotesk", "Segoe UI", sans-serif;
+        font-size: 1.1rem;
+      }
+      .card a {
+        color: var(--accent-2);
+        font-weight: 600;
+        text-decoration: none;
+      }
+      .card a:hover {
+        text-decoration: underline;
+      }
+      .panel {
+        background: linear-gradient(135deg, rgba(182, 59, 46, 0.1), rgba(14, 89, 102, 0.08));
+        border-radius: 20px;
+        padding: 24px;
+        border: 1px solid #eadfce;
+      }
+      code {
+        background: rgba(26, 26, 26, 0.08);
+        padding: 2px 6px;
+        border-radius: 4px;
+        font-family: "IBM Plex Mono", "SFMono-Regular", Consolas, monospace;
+      }
+      .http-method {
+        font-weight: 700;
+        font-size: 0.85em;
+        margin-right: 4px;
+      }
+      .http-method.get { color: #0e5966; }
+      .http-method.post { color: #b63b2e; }
+      ul {
+        padding-left: 18px;
+        columns: 2;
+        column-gap: 32px;
+        margin: 12px 0 0;
+      }
+      li {
+        margin-bottom: 6px;
+      }
+      pre {
+        margin: 12px 0 0;
+        background: rgba(255, 255, 255, 0.8);
+        padding: 12px 14px;
+        border-radius: 12px;
+        border: 1px solid #efe4d2;
+        overflow-x: auto;
+      }
+      @media (max-width: 720px) {
+        ul { columns: 1; }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <header>
+        <h1>pg-boss proxy</h1>
+        <p>HTTP proxy for pg-boss methods, with a generated OpenAPI contract.</p>
+      </header>
+
+      <section class="cards">
+        <div class="card">
+          <h3>OpenAPI JSON</h3>
+          <a href="${openapiPath}">${openapiPath}</a>
+        </div>
+        <div class="card">
+          <h3>Interactive docs</h3>
+          <a href="${docsPath}">${docsPath}</a>
+        </div>
+        <div class="card">
+          <h3>Meta payload</h3>
+          <a href="${base}/meta">${base}/meta</a>
+        </div>
+      </section>
+
+      <section>
+        <h2>Methods</h2>
+        <ul>${methodList}</ul>
+      </section>
+    </main>
+  </body>
+</html>`;
+};

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import { PgBoss, type ConstructorOptions } from 'pg-boss';
+import type { MiddlewareHandler } from 'hono';
+type ProxyEnv = Record<string, string | undefined>;
+type ProxyOptions = {
+    options?: ConstructorOptions;
+    bossFactory?: (options: ConstructorOptions) => PgBoss;
+    prefix?: string;
+    env?: ProxyEnv;
+    middleware?: MiddlewareHandler | MiddlewareHandler[];
+    exposeErrors?: boolean;
+    bodyLimit?: number;
+    routes?: {
+        allow?: string[];
+        deny?: string[];
+    };
+    pages?: {
+        root?: boolean;
+        docs?: boolean;
+        openapi?: boolean;
+    };
+};
+type ProxyApp = {
+    app: OpenAPIHono;
+    boss: PgBoss;
+    prefix: string;
+};
+type ProxyService = ProxyApp & {
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+};
+export declare const createProxyApp: (options: ProxyOptions) => ProxyApp;
+export declare const createProxyService: (options: ProxyOptions) => ProxyService;
+export { bossMethodNames, bossMethodInfos } from './routes.js';
+export { configureAuth } from './auth.js';
+export { attachShutdownListeners, nodeShutdownAdapter, bunShutdownAdapter, createDenoShutdownAdapter } from './shutdown.js';
+export type { ProxyApp, ProxyOptions, ProxyService };
+export type { ShutdownHandler, ShutdownAdapter } from './shutdown.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAe,MAAM,mBAAmB,CAAA;AAG5D,OAAO,EACL,MAAM,EAIN,KAAK,kBAAkB,EACxB,MAAM,SAAS,CAAA;AAChB,OAAO,KAAK,EAAW,iBAAiB,EAAE,MAAM,MAAM,CAAA;AAWtD,KAAK,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;AAElD,KAAK,YAAY,GAAG;IAClB,OAAO,CAAC,EAAE,kBAAkB,CAAA;IAC5B,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,MAAM,CAAA;IACrD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,QAAQ,CAAA;IACd,UAAU,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,CAAA;IACpD,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;QAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAChB,CAAA;IACD,KAAK,CAAC,EAAE;QACN,IAAI,CAAC,EAAE,OAAO,CAAA;QACd,IAAI,CAAC,EAAE,OAAO,CAAA;QACd,OAAO,CAAC,EAAE,OAAO,CAAA;KAClB,CAAA;CACF,CAAA;AAED,KAAK,QAAQ,GAAG;IACd,GAAG,EAAE,WAAW,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,KAAK,YAAY,GAAG,QAAQ,GAAG;IAC7B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B,CAAA;AAuBD,eAAO,MAAM,cAAc,GAAI,SAAS,YAAY,KAAG,QAmQtD,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,SAAS,YAAY,KAAG,YAW1D,CAAA;AAED,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,kBAAkB,EAClB,yBAAyB,EAC1B,MAAM,eAAe,CAAA;AAEtB,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAE,CAAA;AACpD,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA"}