@superinterface/server 1.0.25 → 1.0.26

package/dist/app/api/api-keys/route.js

@@ -1,109 +1,9 @@
-import { headers } from 'next/headers';
-import { ApiKeyType } from '@prisma/client';
-import { NextResponse } from 'next/server';
-import { z } from 'zod';
-import { cacheHeaders } from '../../../lib/cache/cacheHeaders';
-import { resolvePrisma } from '../../../lib/prisma';
-import { serializeApiKey } from '../../../lib/apiKeys/serializeApiKey';
-import { getApiKey } from '../../../lib/apiKeys/getApiKey';
-import { getOrganizationApiKey } from '../../../lib/organizationApiKeys/getOrganizationApiKey';
-export const buildGET = ({ prisma: providedPrisma } = {}) => async () => {
-    const prisma = resolvePrisma(providedPrisma);
-    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 apiKeys = await prisma.apiKey.findMany({
-        where: {
-            type: ApiKeyType.PUBLIC,
-            workspaceId: privateApiKey.workspaceId,
-        },
-    });
-    return NextResponse.json({
-        apiKeys: apiKeys.map((apiKey) => serializeApiKey({ apiKey })),
-    }, { headers: cacheHeaders });
-};
-export const GET = ((...args) => buildGET()(...args));
-export const buildPOST = ({ prisma: providedPrisma } = {}) => async (request) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const headersList = await headers();
-    const authorization = headersList.get('authorization');
-    if (!authorization) {
-        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
-    }
-    const body = await request.json().catch(() => null);
-    const organizationApiKey = await getOrganizationApiKey({
-        authorization,
-        prisma,
-    });
-    if (organizationApiKey) {
-        const createSchemaOrganizationApiKey = z.object({
-            name: z.string().min(1).optional(),
-            type: z.nativeEnum(ApiKeyType),
-            workspaceId: z.string().min(1).optional(),
-        });
-        const parsedOrganizationApiKey = createSchemaOrganizationApiKey.safeParse(body);
-        if (!parsedOrganizationApiKey.success) {
-            return NextResponse.json({ error: 'Invalid body' }, { status: 400 });
-        }
-        const workspace = await prisma.workspace.findUnique({
-            where: {
-                id: parsedOrganizationApiKey.data.workspaceId,
-                organizationId: organizationApiKey.organizationId,
-            },
-        });
-        if (!workspace) {
-            return NextResponse.json({ error: 'Invalid workspace' }, { status: 400 });
-        }
-        const apiKey = await prisma.apiKey.create({
-            data: {
-                type: parsedOrganizationApiKey.data.type,
-                name: parsedOrganizationApiKey.data.name,
-                workspaceId: workspace.id,
-            },
-        });
-        return NextResponse.json({
-            apiKey: serializeApiKey({ apiKey }),
-        }, { headers: cacheHeaders });
-    }
-    const privateApiKey = await getApiKey({
-        type: ApiKeyType.PRIVATE,
-        authorization,
-        prisma,
-    });
-    if (!privateApiKey) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    const createSchema = z.object({
-        name: z.string().min(1).optional(),
-    });
-    const parsed = createSchema.safeParse(body);
-    if (!parsed.success) {
-        return NextResponse.json({ error: 'Invalid body' }, { status: 400 });
-    }
-    const { name } = parsed.data;
-    const workspaceId = privateApiKey.workspaceId;
-    const apiKey = await prisma.apiKey.create({
-        data: {
-            type: ApiKeyType.PUBLIC,
-            name,
-            workspaceId,
-        },
-    });
-    return NextResponse.json({
-        apiKey: serializeApiKey({ apiKey }),
-    }, { headers: cacheHeaders });
-};
-export const POST = ((...args) => buildPOST()(...args));
-export const OPTIONS = () => NextResponse.json({}, {
-    headers: cacheHeaders,
+import { prisma } from '../../../lib/prisma';
+import { buildGET, buildPOST, buildOPTIONS } from './buildRoute';
+export const GET = buildGET({
+    prisma,
 });
+export const POST = buildPOST({
+    prisma,
+});
+export const OPTIONS = buildOPTIONS();

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

@@ -0,0 +1,120 @@
+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<{
+    assistant: {
+        id: string;
+        storageProviderType: import("@prisma/client").$Enums.StorageProviderType;
+        storageProviderAssistantId: string | null;
+        modelProviderId: string;
+        model: string;
+        name: string;
+        description: string;
+        instructions: string;
+        codeInterpreterEnabled: boolean;
+        fileSearchEnabled: boolean;
+        createdAt: string;
+        updatedAt: string;
+        avatar: {
+            type: import("@prisma/client").$Enums.AvatarType;
+            imageAvatar: {
+                url: string;
+            } | null;
+            iconAvatar: {
+                name: import("@prisma/client").$Enums.IconAvatarName;
+            } | null;
+        };
+    };
+}> | NextResponse<{
+    assistant: {
+        id: string;
+        name: string;
+        description: string;
+        theme: {
+            accentColor: "gray" | "gold" | "bronze" | "brown" | "yellow" | "amber" | "orange" | "tomato" | "red" | "ruby" | "crimson" | "pink" | "plum" | "purple" | "violet" | "iris" | "indigo" | "blue" | "cyan" | "teal" | "jade" | "green" | "grass" | "lime" | "mint" | "sky";
+            grayColor: "auto" | "gray" | "mauve" | "slate" | "sage" | "olive" | "sand";
+            appearance: "inherit" | "light" | "dark";
+            radius: "small" | "none" | "medium" | "large" | "full";
+            scaling: "90%" | "95%" | "100%" | "105%" | "110%";
+            panelBackground: "solid";
+        };
+        avatar: {
+            type: import("@prisma/client").$Enums.AvatarType;
+            imageAvatar: {
+                url: string;
+            } | null;
+            iconAvatar: {
+                name: import("@prisma/client").$Enums.IconAvatarName;
+            } | null;
+        };
+    };
+}>>;
+export declare const buildPATCH: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (request: NextRequest, props: RouteProps) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    assistant: {
+        id: string;
+        storageProviderType: import("@prisma/client").$Enums.StorageProviderType;
+        storageProviderAssistantId: string | null;
+        modelProviderId: string;
+        model: string;
+        name: string;
+        description: string;
+        instructions: string;
+        codeInterpreterEnabled: boolean;
+        fileSearchEnabled: boolean;
+        createdAt: string;
+        updatedAt: string;
+        avatar: {
+            type: import("@prisma/client").$Enums.AvatarType;
+            imageAvatar: {
+                url: string;
+            } | null;
+            iconAvatar: {
+                name: import("@prisma/client").$Enums.IconAvatarName;
+            } | null;
+        };
+    };
+}>>;
+export declare const buildDELETE: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (_request: NextRequest, props: RouteProps) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    assistant: {
+        id: string;
+        storageProviderType: import("@prisma/client").$Enums.StorageProviderType;
+        storageProviderAssistantId: string | null;
+        modelProviderId: string;
+        model: string;
+        name: string;
+        description: string;
+        instructions: string;
+        codeInterpreterEnabled: boolean;
+        fileSearchEnabled: boolean;
+        createdAt: string;
+        updatedAt: string;
+        avatar: {
+            type: import("@prisma/client").$Enums.AvatarType;
+            imageAvatar: {
+                url: string;
+            } | null;
+            iconAvatar: {
+                name: import("@prisma/client").$Enums.IconAvatarName;
+            } | null;
+        };
+    };
+}>>;
+export declare const buildOPTIONS: () => () => NextResponse<{}>;
+export {};
+//# sourceMappingURL=buildRoute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildRoute.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/assistants/[assistantId]/buildRoute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,EAKL,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAA;AASvB,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,OAAO,CAAC;QACd,WAAW,EAAE,MAAM,CAAA;KACpB,CAAC,CAAA;CACH,CAAA;AAED,eAAO,MAAM,QAAQ,GAClB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,SAAS,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2F7C,CAAA;AAEH,eAAO,MAAM,UAAU,GACpB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,SAAS,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;GAqJ7C,CAAA;AAEH,eAAO,MAAM,WAAW,GACrB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,UAAU,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;GAuD9C,CAAA;AAEH,eAAO,MAAM,YAAY,8BAMtB,CAAA"}

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

@@ -0,0 +1,226 @@
+import { NextResponse } from 'next/server';
+import { StorageProviderType, ApiKeyType, ToolType, } from '@prisma/client';
+import { cacheHeaders } from '../../../../lib/cache/cacheHeaders';
+import { workspaceAccessWhere as getWorkspaceAccessWhere } from '../../../../lib/apiKeys/workspaceAccessWhere';
+import { serializeAssistant } from '../../../../lib/assistants/serializeAssistant';
+import { serializeApiAssistant } from '../../../../lib/assistants/serializeApiAssistant';
+import { headers } from 'next/headers';
+import { z } from 'zod';
+import { getApiKey } from '../../../../lib/apiKeys/getApiKey';
+export const buildGET = ({ prisma }) => async (request, props) => {
+    const params = await props.params;
+    const { assistantId } = params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (authorization) {
+        const privateApiKey = await getApiKey({
+            authorization,
+            type: ApiKeyType.PRIVATE,
+            prisma,
+        });
+        if (!privateApiKey) {
+            return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+        }
+        const assistant = await prisma.assistant.findUnique({
+            where: {
+                id: assistantId,
+                workspaceId: privateApiKey.workspaceId,
+            },
+            include: {
+                tools: true,
+                avatar: {
+                    include: {
+                        imageAvatar: true,
+                        iconAvatar: true,
+                    },
+                },
+            },
+        });
+        if (!assistant) {
+            return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
+        }
+        return NextResponse.json({
+            assistant: serializeApiAssistant({ assistant }),
+        }, { headers: cacheHeaders });
+    }
+    const workspaceAccessWhere = await getWorkspaceAccessWhere({
+        publicApiKey: request.nextUrl.searchParams.get('publicApiKey'),
+        prisma,
+    });
+    if (!workspaceAccessWhere) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    if (!assistantId) {
+        return NextResponse.json({ error: 'No assistant id found' }, { status: 400 });
+    }
+    const assistant = await prisma.assistant.findFirst({
+        where: {
+            id: assistantId,
+            workspace: workspaceAccessWhere,
+        },
+        include: {
+            avatar: {
+                include: {
+                    imageAvatar: true,
+                    iconAvatar: true,
+                },
+            },
+        },
+    });
+    if (!assistant) {
+        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
+    }
+    return NextResponse.json({
+        assistant: serializeAssistant({ assistant }),
+    }, { headers: cacheHeaders });
+};
+export const buildPATCH = ({ prisma }) => async (request, props) => {
+    const params = await props.params;
+    const { assistantId } = 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 updateSchema = z
+        .object({
+        storageProviderType: z.nativeEnum(StorageProviderType).optional(),
+        storageProviderAssistantId: z.string().nullable().optional(),
+        modelProviderId: z.string().optional(),
+        model: z.string().optional(),
+        name: z.string().optional(),
+        description: z.string().optional(),
+        instructions: z.string().optional(),
+        codeInterpreterEnabled: z.boolean().optional(),
+        fileSearchEnabled: z.boolean().optional(),
+    })
+        .superRefine((data, ctx) => {
+        if (!data.storageProviderType)
+            return;
+        if (data.storageProviderType ===
+            StorageProviderType.SUPERINTERFACE_CLOUD &&
+            data.storageProviderAssistantId) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'storageProviderAssistantId should not be provided for SUPERINTERFACE_CLOUD',
+                path: ['storageProviderAssistantId'],
+            });
+        }
+        if (data.storageProviderType !==
+            StorageProviderType.SUPERINTERFACE_CLOUD &&
+            !data.storageProviderAssistantId) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'storageProviderAssistantId is required for this storage provider',
+                path: ['storageProviderAssistantId'],
+            });
+        }
+    });
+    const parseResult = updateSchema.safeParse(await request.json());
+    if (!parseResult.success) {
+        return NextResponse.json({
+            error: 'Invalid body: ' + parseResult.error.message,
+        }, { status: 400 });
+    }
+    const { storageProviderType, storageProviderAssistantId, modelProviderId, model, name, description, instructions, codeInterpreterEnabled, fileSearchEnabled, } = parseResult.data;
+    const data = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (storageProviderType !== undefined && { storageProviderType })), (storageProviderAssistantId !== undefined && {
+        openaiAssistantId: storageProviderAssistantId,
+    })), (modelProviderId !== undefined && {
+        modelProvider: { connect: { id: modelProviderId } },
+    })), (model !== undefined && { modelSlug: model })), (name !== undefined && { name })), (description !== undefined && { description })), (instructions !== undefined && { instructions })), { tools: {
+            create: [
+                ...(codeInterpreterEnabled === true
+                    ? [
+                        {
+                            type: ToolType.CODE_INTERPRETER,
+                            codeInterpreterTool: { create: {} },
+                        },
+                    ]
+                    : []),
+                ...(fileSearchEnabled === true
+                    ? [{ type: ToolType.FILE_SEARCH, fileSearchTool: { create: {} } }]
+                    : []),
+            ],
+            deleteMany: [
+                ...(codeInterpreterEnabled === false
+                    ? [{ assistantId, type: ToolType.CODE_INTERPRETER }]
+                    : []),
+                ...(fileSearchEnabled === false
+                    ? [{ assistantId, type: ToolType.FILE_SEARCH }]
+                    : []),
+            ],
+        } });
+    const assistant = await prisma.assistant.update({
+        where: {
+            id: assistantId,
+            workspaceId: privateApiKey.workspaceId,
+        },
+        data,
+        include: {
+            tools: true,
+            avatar: {
+                include: {
+                    imageAvatar: true,
+                    iconAvatar: true,
+                },
+            },
+        },
+    });
+    return NextResponse.json({
+        assistant: serializeApiAssistant({ assistant }),
+    }, { headers: cacheHeaders });
+};
+export const buildDELETE = ({ prisma }) => async (_request, props) => {
+    const params = await props.params;
+    const { assistantId } = 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 assistant = await prisma.assistant.findFirst({
+        where: {
+            id: assistantId,
+            workspaceId: privateApiKey.workspaceId,
+        },
+        include: {
+            tools: true,
+            avatar: {
+                include: {
+                    imageAvatar: true,
+                    iconAvatar: true,
+                },
+            },
+        },
+    });
+    if (!assistant) {
+        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
+    }
+    await prisma.assistant.delete({
+        where: {
+            id: assistant.id,
+        },
+    });
+    return NextResponse.json({
+        assistant: serializeApiAssistant({ assistant }),
+    }, { headers: cacheHeaders });
+};
+export const buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});

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

@@ -0,0 +1,167 @@
+import { type PrismaClient } from '@prisma/client';
+import { NextResponse, type NextRequest } from 'next/server';
+type RouteProps = {
+    params: Promise<{
+        assistantId: string;
+        functionId: string;
+    }>;
+};
+export declare const buildGET: ({ 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 buildPATCH: ({ 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 buildDELETE: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (_request: NextRequest, props: RouteProps) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    mcpServer: {
+        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/[functionId]/buildRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRoute.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/api/assistants/[assistantId]/functions/[functionId]/buildRoute.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAQ5D,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC7D,CAAA;AA0BD,eAAO,MAAM,QAAQ,GAClB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,UAAU,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4D9C,CAAA;AAEH,eAAO,MAAM,UAAU,GACpB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,SAAS,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6E7C,CAAA;AAEH,eAAO,MAAM,WAAW,GACrB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,UAAU,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgE9C,CAAA;AAEH,eAAO,MAAM,YAAY,8BAMtB,CAAA"}