@superinterface/server 1.0.25 → 1.0.26

package/dist/app/api/assistants/[assistantId]/functions/[functionId]/buildRoute.js

@@ -0,0 +1,184 @@
+import { headers } from 'next/headers';
+import { ApiKeyType } from '@prisma/client';
+import { NextResponse } from 'next/server';
+import { cacheHeaders } from '../../../../../../lib/cache/cacheHeaders';
+import { getApiKey } from '../../../../../../lib/apiKeys/getApiKey';
+import { validate } from 'uuid';
+import { serializeApiFunction } from '../../../../../../lib/functions/serializeApiFunction';
+import { functionSchema } from '../../../../../../lib/functions/functionSchema';
+import { updateFunction } from '../../../../../../lib/functions/updateFunction';
+const ensureIdsValid = ({ assistantId, functionId, }) => {
+    if (!validate(assistantId)) {
+        return NextResponse.json({ error: 'Invalid assistant id' }, { status: 400 });
+    }
+    if (!validate(functionId)) {
+        return NextResponse.json({ error: 'Invalid function id' }, { status: 400 });
+    }
+    return null;
+};
+export const buildGET = ({ prisma }) => async (_request, props) => {
+    const { assistantId, functionId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        type: ApiKeyType.PRIVATE,
+        authorization,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const validationError = ensureIdsValid({ assistantId, functionId });
+    if (validationError)
+        return validationError;
+    const fn = await prisma.function.findFirst({
+        where: {
+            id: functionId,
+            assistant: {
+                id: assistantId,
+                workspaceId: privateApiKey.workspaceId,
+            },
+        },
+        include: {
+            handler: {
+                include: {
+                    requestHandler: true,
+                    firecrawlHandler: true,
+                    replicateHandler: true,
+                    clientToolHandler: true,
+                    assistantHandler: true,
+                    createTaskHandler: true,
+                    listTasksHandler: true,
+                    updateTaskHandler: true,
+                    deleteTaskHandler: true,
+                },
+            },
+        },
+    });
+    if (!fn) {
+        return NextResponse.json({ error: 'No function found' }, { status: 400 });
+    }
+    return NextResponse.json({
+        function: serializeApiFunction({ fn }),
+    }, { headers: cacheHeaders });
+};
+export const buildPATCH = ({ prisma }) => async (request, props) => {
+    const { assistantId, functionId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        authorization,
+        type: ApiKeyType.PRIVATE,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const validationError = ensureIdsValid({ assistantId, functionId });
+    if (validationError)
+        return validationError;
+    const body = await request.json();
+    const parsed = functionSchema.safeParse(body);
+    if (!parsed.success) {
+        return NextResponse.json({ error: 'Invalid payload' }, { status: 400 });
+    }
+    const fn = await prisma.function.findFirst({
+        where: {
+            id: functionId,
+            assistant: {
+                id: assistantId,
+                workspaceId: privateApiKey.workspaceId,
+            },
+        },
+        include: {
+            assistant: true,
+        },
+    });
+    if (!fn) {
+        return NextResponse.json({ error: 'No function found' }, { status: 400 });
+    }
+    const updatedFunction = await updateFunction({
+        fn,
+        parsedInput: parsed.data,
+        include: {
+            handler: {
+                include: {
+                    requestHandler: true,
+                    firecrawlHandler: true,
+                    replicateHandler: true,
+                    clientToolHandler: true,
+                    assistantHandler: true,
+                    createTaskHandler: true,
+                    listTasksHandler: true,
+                    updateTaskHandler: true,
+                    deleteTaskHandler: true,
+                },
+            },
+        },
+        prisma,
+    });
+    return NextResponse.json({
+        function: serializeApiFunction({ fn: updatedFunction }),
+    }, { headers: cacheHeaders });
+};
+export const buildDELETE = ({ prisma }) => async (_request, props) => {
+    const { assistantId, functionId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        authorization,
+        type: ApiKeyType.PRIVATE,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const validationError = ensureIdsValid({ assistantId, functionId });
+    if (validationError)
+        return validationError;
+    const fn = await prisma.function.findFirst({
+        where: {
+            id: functionId,
+            assistant: {
+                id: assistantId,
+                workspaceId: privateApiKey.workspaceId,
+            },
+        },
+    });
+    if (!fn) {
+        return NextResponse.json({ error: 'No function found' }, { status: 400 });
+    }
+    const deletedFunction = await prisma.function.delete({
+        where: { id: fn.id },
+        include: {
+            handler: {
+                include: {
+                    requestHandler: true,
+                    firecrawlHandler: true,
+                    replicateHandler: true,
+                    clientToolHandler: true,
+                    assistantHandler: true,
+                    createTaskHandler: true,
+                    listTasksHandler: true,
+                    updateTaskHandler: true,
+                    deleteTaskHandler: true,
+                },
+            },
+        },
+    });
+    return NextResponse.json({
+        mcpServer: serializeApiFunction({ fn: deletedFunction }),
+    }, { headers: cacheHeaders });
+};
+export const buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});

package/dist/app/api/assistants/[assistantId]/functions/[functionId]/route.d.ts

@@ -1,15 +1,11 @@
-import { type PrismaClient } from '@prisma/client';
-import { NextResponse, type NextRequest } from 'next/server';
-export declare const buildGET: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (_request: NextRequest, props: {
+export declare const GET: (_request: import("next/server").NextRequest, props: {
     params: Promise<{
         assistantId: string;
         functionId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     function: {
         id: string;
         openapiSpec: PrismaJson.OpenapiSpec;
@@ -57,17 +53,14 @@ export declare const buildGET: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     };
 }>>;
-export declare const GET: ReturnType<typeof buildGET>;
-export declare const buildPATCH: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (request: NextRequest, props: {
+export declare const PATCH: (request: import("next/server").NextRequest, props: {
     params: Promise<{
         assistantId: string;
         functionId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     function: {
         id: string;
         openapiSpec: PrismaJson.OpenapiSpec;
@@ -115,17 +108,14 @@ export declare const buildPATCH: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     };
 }>>;
-export declare const PATCH: ReturnType<typeof buildPATCH>;
-export declare const buildDELETE: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (_request: NextRequest, props: {
+export declare const DELETE: (_request: import("next/server").NextRequest, props: {
     params: Promise<{
         assistantId: string;
         functionId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     mcpServer: {
         id: string;
         openapiSpec: PrismaJson.OpenapiSpec;
@@ -173,6 +163,5 @@ export declare const buildDELETE: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     };
 }>>;
-export declare const DELETE: ReturnType<typeof buildDELETE>;
-export declare const OPTIONS: () => NextResponse<{}>;
+export declare const OPTIONS: () => import("next/server").NextResponse<{}>;
 //# sourceMappingURL=route.d.ts.map

package/dist/app/api/assistants/[assistantId]/functions/[functionId]/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/api/assistants/[assistantId]/functions/[functionId]/route.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAS5D,eAAO,MAAM,QAAQ,GAClB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,UAAU,WAAW,EACrB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEF,CAAA;AAEH,eAAO,MAAM,GAAG,EACU,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAA;AAErD,eAAO,MAAM,UAAU,GACpB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,SAAS,WAAW,EACpB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FF,CAAA;AAEH,eAAO,MAAM,KAAK,EACU,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;AAEzD,eAAO,MAAM,WAAW,GACrB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,UAAU,WAAW,EACrB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EF,CAAA;AAEH,eAAO,MAAM,MAAM,EACU,UAAU,CAAC,OAAO,WAAW,CAAC,CAAA;AAE3D,eAAO,MAAM,OAAO,wBAMjB,CAAA"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/api/assistants/[assistantId]/functions/[functionId]/route.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuB,CAAA;AAEvC,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyB,CAAA;AAE3C,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0B,CAAA;AAE7C,eAAO,MAAM,OAAO,8CAAiB,CAAA"}

package/dist/app/api/assistants/[assistantId]/functions/[functionId]/route.js

@@ -1,191 +1,6 @@
-import { headers } from 'next/headers';
-import { ApiKeyType } from '@prisma/client';
-import { NextResponse } from 'next/server';
-import { cacheHeaders } from '../../../../../../lib/cache/cacheHeaders';
-import { resolvePrisma } from '../../../../../../lib/prisma';
-import { getApiKey } from '../../../../../../lib/apiKeys/getApiKey';
-import { validate } from 'uuid';
-import { serializeApiFunction } from '../../../../../../lib/functions/serializeApiFunction';
-import { functionSchema } from '../../../../../../lib/functions/functionSchema';
-import { updateFunction } from '../../../../../../lib/functions/updateFunction';
-export const buildGET = ({ prisma: providedPrisma } = {}) => async (_request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const { assistantId, functionId } = await props.params;
-    const headersList = await headers();
-    const authorization = headersList.get('authorization');
-    if (!authorization) {
-        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
-    }
-    const privateApiKey = await getApiKey({
-        type: ApiKeyType.PRIVATE,
-        authorization,
-        prisma,
-    });
-    if (!privateApiKey) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    if (!validate(assistantId)) {
-        return NextResponse.json({ error: 'Invalid assistant id' }, { status: 400 });
-    }
-    if (!validate(functionId)) {
-        return NextResponse.json({ error: 'Invalid function id' }, { status: 400 });
-    }
-    const fn = await prisma.function.findFirst({
-        where: {
-            id: functionId,
-            assistant: {
-                id: assistantId,
-                workspaceId: privateApiKey.workspaceId,
-            },
-        },
-        include: {
-            handler: {
-                include: {
-                    requestHandler: true,
-                    firecrawlHandler: true,
-                    replicateHandler: true,
-                    clientToolHandler: true,
-                    assistantHandler: true,
-                    createTaskHandler: true,
-                    listTasksHandler: true,
-                    updateTaskHandler: true,
-                    deleteTaskHandler: true,
-                },
-            },
-        },
-    });
-    if (!fn) {
-        return NextResponse.json({ error: 'No function found' }, { status: 400 });
-    }
-    return NextResponse.json({
-        function: serializeApiFunction({ fn }),
-    }, { headers: cacheHeaders });
-};
-export const GET = ((...args) => buildGET()(...args));
-export const buildPATCH = ({ prisma: providedPrisma } = {}) => async (request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const { assistantId, functionId } = await props.params;
-    const headersList = await headers();
-    const authorization = headersList.get('authorization');
-    if (!authorization) {
-        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
-    }
-    const privateApiKey = await getApiKey({
-        authorization,
-        type: ApiKeyType.PRIVATE,
-        prisma,
-    });
-    if (!privateApiKey) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    if (!validate(assistantId)) {
-        return NextResponse.json({ error: 'Invalid assistant id' }, { status: 400 });
-    }
-    if (!validate(functionId)) {
-        return NextResponse.json({ error: 'Invalid function id' }, { status: 400 });
-    }
-    const body = await request.json();
-    const parsed = functionSchema.safeParse(body);
-    if (!parsed.success) {
-        return NextResponse.json({ error: 'Invalid payload' }, { status: 400 });
-    }
-    const fn = await prisma.function.findFirst({
-        where: {
-            id: functionId,
-            assistant: {
-                id: assistantId,
-                workspaceId: privateApiKey.workspaceId,
-            },
-        },
-        include: {
-            assistant: true,
-        },
-    });
-    if (!fn) {
-        return NextResponse.json({ error: 'No function found' }, { status: 400 });
-    }
-    const updatedFunction = await updateFunction({
-        fn,
-        parsedInput: parsed.data,
-        include: {
-            handler: {
-                include: {
-                    requestHandler: true,
-                    firecrawlHandler: true,
-                    replicateHandler: true,
-                    clientToolHandler: true,
-                    assistantHandler: true,
-                    createTaskHandler: true,
-                    listTasksHandler: true,
-                    updateTaskHandler: true,
-                    deleteTaskHandler: true,
-                },
-            },
-        },
-        prisma,
-    });
-    return NextResponse.json({
-        function: serializeApiFunction({ fn: updatedFunction }),
-    }, { headers: cacheHeaders });
-};
-export const PATCH = ((...args) => buildPATCH()(...args));
-export const buildDELETE = ({ prisma: providedPrisma } = {}) => async (_request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const { assistantId, functionId } = await props.params;
-    const headersList = await headers();
-    const authorization = headersList.get('authorization');
-    if (!authorization) {
-        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
-    }
-    const privateApiKey = await getApiKey({
-        authorization,
-        type: ApiKeyType.PRIVATE,
-        prisma,
-    });
-    if (!privateApiKey) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    if (!validate(assistantId)) {
-        return NextResponse.json({ error: 'Invalid assistant id' }, { status: 400 });
-    }
-    if (!validate(functionId)) {
-        return NextResponse.json({ error: 'Invalid function id' }, { status: 400 });
-    }
-    const fn = await prisma.function.findFirst({
-        where: {
-            id: functionId,
-            assistant: {
-                id: assistantId,
-                workspaceId: privateApiKey.workspaceId,
-            },
-        },
-    });
-    if (!fn) {
-        return NextResponse.json({ error: 'No function found' }, { status: 400 });
-    }
-    const deletedFunction = await prisma.function.delete({
-        where: { id: fn.id },
-        include: {
-            handler: {
-                include: {
-                    requestHandler: true,
-                    firecrawlHandler: true,
-                    replicateHandler: true,
-                    clientToolHandler: true,
-                    assistantHandler: true,
-                    createTaskHandler: true,
-                    listTasksHandler: true,
-                    updateTaskHandler: true,
-                    deleteTaskHandler: true,
-                },
-            },
-        },
-    });
-    return NextResponse.json({
-        mcpServer: serializeApiFunction({ fn: deletedFunction }),
-    }, { headers: cacheHeaders });
-};
-export const DELETE = ((...args) => buildDELETE()(...args));
-export const OPTIONS = () => NextResponse.json({}, {
-    headers: cacheHeaders,
-});
+import { prisma } from '../../../../../../lib/prisma';
+import { buildDELETE, buildGET, buildOPTIONS, buildPATCH, } from './buildRoute';
+export const GET = buildGET({ prisma });
+export const PATCH = buildPATCH({ prisma });
+export const DELETE = buildDELETE({ prisma });
+export const OPTIONS = buildOPTIONS();

package/dist/app/api/assistants/[assistantId]/functions/buildRoute.d.ts

@@ -0,0 +1,114 @@
+import { type NextRequest, NextResponse } from 'next/server';
+import { type PrismaClient } from '@prisma/client';
+type RouteProps = {
+    params: Promise<{
+        assistantId: string;
+    }>;
+};
+export declare const buildGET: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (_request: NextRequest, props: RouteProps) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    functions: {
+        id: string;
+        openapiSpec: PrismaJson.OpenapiSpec;
+        handler: {
+            deleteTaskHandler?: {
+                keyTemplate: string;
+            } | undefined;
+            updateTaskHandler?: {
+                keyTemplate: string;
+            } | undefined;
+            createTaskHandler?: {
+                keyTemplate: string;
+            } | undefined;
+            listTasksHandler?: {
+                keyTemplate: string;
+            } | undefined;
+            assistantHandler?: {
+                assistantId: string;
+            } | undefined;
+            clientToolHandler?: {
+                type: "FUNCTION";
+                name: string;
+                arguments: PrismaJson.ClientToolHandlerArguments;
+            } | undefined;
+            replicateHandler?: {
+                type: "RUN";
+                apiKey: string;
+                identifier: string;
+                body: PrismaJson.ReplicateHandlerBody;
+            } | undefined;
+            firecrawlHandler?: {
+                type: import("@prisma/client").$Enums.FirecrawlHandlerType;
+                apiKey: string;
+                body: PrismaJson.FirecrawlHandlerBody;
+            } | undefined;
+            requestHandler?: {
+                url: string;
+                method: import("@prisma/client").$Enums.MethodType;
+                headers: PrismaJson.RequestHandlerHeaders;
+                body: PrismaJson.RequestHandlerBody;
+            } | undefined;
+            type: import("@prisma/client").$Enums.HandlerType;
+        };
+        createdAt: string;
+        updatedAt: string;
+    }[];
+}>>;
+export declare const buildPOST: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (request: NextRequest, props: RouteProps) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    function: {
+        id: string;
+        openapiSpec: PrismaJson.OpenapiSpec;
+        handler: {
+            deleteTaskHandler?: {
+                keyTemplate: string;
+            } | undefined;
+            updateTaskHandler?: {
+                keyTemplate: string;
+            } | undefined;
+            createTaskHandler?: {
+                keyTemplate: string;
+            } | undefined;
+            listTasksHandler?: {
+                keyTemplate: string;
+            } | undefined;
+            assistantHandler?: {
+                assistantId: string;
+            } | undefined;
+            clientToolHandler?: {
+                type: "FUNCTION";
+                name: string;
+                arguments: PrismaJson.ClientToolHandlerArguments;
+            } | undefined;
+            replicateHandler?: {
+                type: "RUN";
+                apiKey: string;
+                identifier: string;
+                body: PrismaJson.ReplicateHandlerBody;
+            } | undefined;
+            firecrawlHandler?: {
+                type: import("@prisma/client").$Enums.FirecrawlHandlerType;
+                apiKey: string;
+                body: PrismaJson.FirecrawlHandlerBody;
+            } | undefined;
+            requestHandler?: {
+                url: string;
+                method: import("@prisma/client").$Enums.MethodType;
+                headers: PrismaJson.RequestHandlerHeaders;
+                body: PrismaJson.RequestHandlerBody;
+            } | undefined;
+            type: import("@prisma/client").$Enums.HandlerType;
+        };
+        createdAt: string;
+        updatedAt: string;
+    };
+}>>;
+export declare const buildOPTIONS: () => () => NextResponse<{}>;
+export {};
+//# sourceMappingURL=buildRoute.d.ts.map

package/dist/app/api/assistants/[assistantId]/functions/buildRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRoute.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/assistants/[assistantId]/functions/buildRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAQ9D,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACzC,CAAA;AAED,eAAO,MAAM,QAAQ,GAClB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,UAAU,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiE9C,CAAA;AAEH,eAAO,MAAM,SAAS,GACnB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,SAAS,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoE7C,CAAA;AAEH,eAAO,MAAM,YAAY,8BAMtB,CAAA"}