@inkeep/agents-manage-api 0.39.5 → 0.40.0

package/dist/routes/agentFull.js

@@ -0,0 +1,188 @@
+import { getLogger as getLogger$1 } from "../logger.js";
+import dbClient_default from "../data/db/dbClient.js";
+import { requirePermission } from "../middleware/require-permission.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { AgentWithinContextOfProjectResponse, AgentWithinContextOfProjectSchema, ErrorResponseSchema, TenantProjectAgentParamsSchema, TenantProjectParamsSchema, commonGetErrorResponses, createApiError, createFullAgentServerSide, deleteFullAgent, getFullAgent, updateFullAgentServerSide } from "@inkeep/agents-core";
+
+//#region src/routes/agentFull.ts
+const logger = getLogger$1("agentFull");
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requirePermission({ agent: ["create"] })(c, next);
+	return next();
+});
+app.use("/:agentId", async (c, next) => {
+	if (c.req.method === "PUT") return requirePermission({ agent: ["update"] })(c, next);
+	if (c.req.method === "DELETE") return requirePermission({ agent: ["delete"] })(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create Full Agent",
+	operationId: "create-full-agent",
+	tags: ["Full Agent"],
+	description: "Create a complete agent with all agents, tools, and relationships from JSON definition",
+	request: {
+		params: TenantProjectParamsSchema,
+		body: { content: { "application/json": { schema: AgentWithinContextOfProjectSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Full agent created successfully",
+			content: { "application/json": { schema: AgentWithinContextOfProjectResponse } }
+		},
+		409: {
+			description: "Agent already exists",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId } = c.req.valid("param");
+	const agentData = c.req.valid("json");
+	const validatedAgentData = AgentWithinContextOfProjectSchema.parse(agentData);
+	const createdAgent = await createFullAgentServerSide(dbClient_default, logger)({
+		tenantId,
+		projectId
+	}, validatedAgentData);
+	return c.json({ data: createdAgent }, 201);
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{agentId}",
+	summary: "Get Full Agent",
+	operationId: "get-full-agent",
+	tags: ["Full Agent"],
+	description: "Retrieve a complete agent definition with all agents, tools, and relationships",
+	request: { params: TenantProjectAgentParamsSchema },
+	responses: {
+		200: {
+			description: "Full agent found",
+			content: { "application/json": { schema: AgentWithinContextOfProjectResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	try {
+		const agent = await getFullAgent(dbClient_default, logger)({ scopes: {
+			tenantId,
+			projectId,
+			agentId
+		} });
+		if (!agent) throw createApiError({
+			code: "not_found",
+			message: "Agent not found"
+		});
+		return c.json({ data: agent });
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("not found")) throw createApiError({
+			code: "not_found",
+			message: "Agent not found"
+		});
+		throw createApiError({
+			code: "internal_server_error",
+			message: error instanceof Error ? error.message : "Failed to retrieve agent"
+		});
+	}
+});
+app.openapi(createRoute({
+	method: "put",
+	path: "/{agentId}",
+	summary: "Update Full Agent",
+	operationId: "update-full-agent",
+	tags: ["Full Agent"],
+	description: "Update or create a complete agent with all agents, tools, and relationships from JSON definition",
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		body: { content: { "application/json": { schema: AgentWithinContextOfProjectSchema } } }
+	},
+	responses: {
+		200: {
+			description: "Full agent updated successfully",
+			content: { "application/json": { schema: AgentWithinContextOfProjectResponse } }
+		},
+		201: {
+			description: "Full agent created successfully",
+			content: { "application/json": { schema: AgentWithinContextOfProjectResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const agentData = c.req.valid("json");
+	try {
+		logger.info({}, "test agent data");
+		const validatedAgentData = AgentWithinContextOfProjectSchema.parse(agentData);
+		if (agentId !== validatedAgentData.id) throw createApiError({
+			code: "bad_request",
+			message: `Agent ID mismatch: expected ${agentId}, got ${validatedAgentData.id}`
+		});
+		const isCreate = !await getFullAgent(dbClient_default, logger)({ scopes: {
+			tenantId,
+			projectId,
+			agentId
+		} });
+		const updatedAgent = isCreate ? await createFullAgentServerSide(dbClient_default, logger)({
+			tenantId,
+			projectId
+		}, validatedAgentData) : await updateFullAgentServerSide(dbClient_default, logger)({
+			tenantId,
+			projectId
+		}, validatedAgentData);
+		return c.json({ data: updatedAgent }, isCreate ? 201 : 200);
+	} catch (error) {
+		if (error instanceof z.ZodError) throw createApiError({
+			code: "bad_request",
+			message: "Invalid agent definition"
+		});
+		if (error instanceof Error && error.message.includes("ID mismatch")) throw createApiError({
+			code: "bad_request",
+			message: error.message
+		});
+		throw createApiError({
+			code: "internal_server_error",
+			message: error instanceof Error ? error.message : "Failed to update agent"
+		});
+	}
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{agentId}",
+	summary: "Delete Full Agent",
+	operationId: "delete-full-agent",
+	tags: ["Full Agent"],
+	description: "Delete a complete agent and cascade to all related entities (relationships, not other agents/tools)",
+	request: { params: TenantProjectAgentParamsSchema },
+	responses: {
+		204: { description: "Agent deleted successfully" },
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	try {
+		if (!await deleteFullAgent(dbClient_default, logger)({ scopes: {
+			tenantId,
+			projectId,
+			agentId
+		} })) throw createApiError({
+			code: "not_found",
+			message: "Agent not found"
+		});
+		return c.body(null, 204);
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("not found")) throw createApiError({
+			code: "not_found",
+			message: "Agent not found"
+		});
+		throw createApiError({
+			code: "internal_server_error",
+			message: error instanceof Error ? error.message : "Failed to delete agent"
+		});
+	}
+});
+var agentFull_default = app;
+
+//#endregion
+export { agentFull_default as default };

package/dist/routes/agentToolRelations.d.ts

@@ -0,0 +1,9 @@
+import { BaseAppVariables } from "../types/app.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/routes/agentToolRelations.d.ts
+declare const app: OpenAPIHono<{
+  Variables: BaseAppVariables;
+}, {}, "/">;
+//#endregion
+export { app as default };

package/dist/routes/agentToolRelations.js

@@ -0,0 +1,284 @@
+import dbClient_default from "../data/db/dbClient.js";
+import { requirePermission } from "../middleware/require-permission.js";
+import { speakeasyOffsetLimitPagination } from "./shared.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { ErrorResponseSchema, PaginationQueryParamsSchema, SubAgentToolRelationApiInsertSchema, SubAgentToolRelationApiUpdateSchema, SubAgentToolRelationListResponse, SubAgentToolRelationResponse, TenantProjectAgentIdParamsSchema, TenantProjectAgentParamsSchema, commonGetErrorResponses, createAgentToolRelation, createApiError, deleteAgentToolRelation, getAgentToolRelationByAgent, getAgentToolRelationById, getAgentToolRelationByTool, getAgentsForTool, listAgentToolRelations, updateAgentToolRelation } from "@inkeep/agents-core";
+
+//#region src/routes/agentToolRelations.ts
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requirePermission({ agent: ["create"] })(c, next);
+	return next();
+});
+app.use("/:id", async (c, next) => {
+	if (c.req.method === "PUT") return requirePermission({ agent: ["update"] })(c, next);
+	if (c.req.method === "DELETE") return requirePermission({ agent: ["delete"] })(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/",
+	summary: "List Agent Tool Relations",
+	operationId: "list-agent-tool-relations",
+	tags: ["Agent Tool Relations"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		query: PaginationQueryParamsSchema.extend({
+			subAgentId: z.string().optional(),
+			toolId: z.string().optional()
+		})
+	},
+	responses: {
+		200: {
+			description: "List of agent tool relations retrieved successfully",
+			content: { "application/json": { schema: SubAgentToolRelationListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const { page, limit, subAgentId, toolId } = c.req.valid("query");
+	let result;
+	if (subAgentId) {
+		const dbResult = await getAgentToolRelationByAgent(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId,
+				subAgentId
+			},
+			pagination: {
+				page,
+				limit
+			}
+		});
+		result = {
+			data: dbResult.data,
+			pagination: dbResult.pagination
+		};
+	} else if (toolId) {
+		const dbResult = await getAgentToolRelationByTool(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			toolId,
+			pagination: {
+				page,
+				limit
+			}
+		});
+		result = {
+			data: dbResult.data,
+			pagination: dbResult.pagination
+		};
+	} else {
+		const dbResult = await listAgentToolRelations(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			pagination: {
+				page,
+				limit
+			}
+		});
+		result = {
+			data: dbResult.data,
+			pagination: dbResult.pagination
+		};
+	}
+	return c.json(result);
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get Agent Tool Relation",
+	operationId: "get-agent-tool-relation",
+	tags: ["Agent Tool Relations"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		200: {
+			description: "Agent tool relation found",
+			content: { "application/json": { schema: SubAgentToolRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	const agentToolRelation = await getAgentToolRelationById(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId: id
+		},
+		relationId: id
+	});
+	if (!agentToolRelation) throw createApiError({
+		code: "not_found",
+		message: "Agent tool relation not found"
+	});
+	return c.json({ data: agentToolRelation });
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/tool/{toolId}/agents",
+	summary: "Get Agents for Tool",
+	operationId: "get-agents-for-tool",
+	tags: ["Agent Tool Relations"],
+	request: {
+		params: TenantProjectAgentParamsSchema.extend({ toolId: z.string() }),
+		query: PaginationQueryParamsSchema
+	},
+	responses: {
+		200: {
+			description: "Agents for tool retrieved successfully",
+			content: { "application/json": { schema: SubAgentToolRelationListResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId, toolId } = c.req.valid("param");
+	const { page, limit } = c.req.valid("query");
+	const dbResult = await getAgentsForTool(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		toolId,
+		pagination: {
+			page,
+			limit
+		}
+	});
+	return c.json(dbResult);
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create Agent Tool Relation",
+	operationId: "create-agent-tool-relation",
+	tags: ["Agent Tool Relations"],
+	request: {
+		params: TenantProjectAgentParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentToolRelationApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Agent tool relation created successfully",
+			content: { "application/json": { schema: SubAgentToolRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId } = c.req.valid("param");
+	const body = c.req.valid("json");
+	if ((await listAgentToolRelations(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		pagination: { limit: 1e3 }
+	})).data.some((relation) => {
+		const typedRelation = relation;
+		return typedRelation.subAgentId === body.subAgentId && typedRelation.toolId === body.toolId;
+	})) throw createApiError({
+		code: "unprocessable_entity",
+		message: "Agent tool relation already exists"
+	});
+	try {
+		const agentToolRelation = await createAgentToolRelation(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId,
+				agentId
+			},
+			data: body
+		});
+		return c.json({ data: agentToolRelation }, 201);
+	} catch (error) {
+		if (error?.cause?.code === "23503") throw createApiError({
+			code: "bad_request",
+			message: "Invalid agent ID or tool ID - referenced entity does not exist"
+		});
+		throw error;
+	}
+});
+app.openapi(createRoute({
+	method: "put",
+	path: "/{id}",
+	summary: "Update Agent Tool Relation",
+	operationId: "update-agent-tool-relation",
+	tags: ["Agent Tool Relations"],
+	request: {
+		params: TenantProjectAgentIdParamsSchema,
+		body: { content: { "application/json": { schema: SubAgentToolRelationApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "Agent tool relation updated successfully",
+			content: { "application/json": { schema: SubAgentToolRelationResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	const body = await c.req.valid("json");
+	if (Object.keys(body).length === 0) throw createApiError({
+		code: "bad_request",
+		message: "No fields to update"
+	});
+	const updatedSubAgentToolRelation = await updateAgentToolRelation(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		relationId: id,
+		data: body
+	});
+	if (!updatedSubAgentToolRelation) throw createApiError({
+		code: "not_found",
+		message: "Agent tool relation not found"
+	});
+	return c.json({ data: updatedSubAgentToolRelation });
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete Agent Tool Relation",
+	operationId: "delete-agent-tool-relation",
+	tags: ["Agent Tool Relations"],
+	request: { params: TenantProjectAgentIdParamsSchema },
+	responses: {
+		204: { description: "Agent tool relation deleted successfully" },
+		404: {
+			description: "Agent tool relation not found",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		}
+	}
+}), async (c) => {
+	const { tenantId, projectId, agentId, id } = c.req.valid("param");
+	if (!await deleteAgentToolRelation(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		relationId: id
+	})) throw createApiError({
+		code: "not_found",
+		message: "Agent tool relation not found"
+	});
+	return c.body(null, 204);
+});
+var agentToolRelations_default = app;
+
+//#endregion
+export { agentToolRelations_default as default };

package/dist/routes/apiKeys.d.ts

@@ -0,0 +1,9 @@
+import { BaseAppVariables } from "../types/app.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/routes/apiKeys.d.ts
+declare const app: OpenAPIHono<{
+  Variables: BaseAppVariables;
+}, {}, "/">;
+//#endregion
+export { app as default };

package/dist/routes/apiKeys.js

@@ -0,0 +1,217 @@
+import dbClient_default from "../data/db/dbClient.js";
+import { requirePermission } from "../middleware/require-permission.js";
+import { speakeasyOffsetLimitPagination } from "./shared.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { ApiKeyApiCreationResponseSchema, ApiKeyApiInsertSchema, ApiKeyApiUpdateSchema, ApiKeyListResponse, ApiKeyResponse, ErrorResponseSchema, PaginationQueryParamsSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, commonGetErrorResponses, createApiError, createApiKey, deleteApiKey, generateApiKey, getApiKeyById, listApiKeysPaginated, updateApiKey } from "@inkeep/agents-core";
+
+//#region src/routes/apiKeys.ts
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requirePermission({ api_key: ["create"] })(c, next);
+	return next();
+});
+app.use("/:id", async (c, next) => {
+	if (c.req.method === "PATCH") return requirePermission({ api_key: ["update"] })(c, next);
+	if (c.req.method === "DELETE") return requirePermission({ api_key: ["delete"] })(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/",
+	summary: "List API Keys",
+	description: "List all API keys for a tenant with optional pagination",
+	operationId: "list-api-keys",
+	tags: ["API Keys"],
+	request: {
+		params: TenantProjectParamsSchema,
+		query: PaginationQueryParamsSchema.extend({ agentId: z.string().optional().describe("Filter by agent ID") })
+	},
+	responses: {
+		200: {
+			description: "List of API keys retrieved successfully",
+			content: { "application/json": { schema: ApiKeyListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const { tenantId, projectId } = c.req.valid("param");
+	const page = Number(c.req.query("page")) || 1;
+	const limit = Math.min(Number(c.req.query("limit")) || 10, 100);
+	const agentId = c.req.query("agentId");
+	const result = await listApiKeysPaginated(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		pagination: {
+			page,
+			limit
+		},
+		agentId
+	});
+	const sanitizedData = result.data.map(({ keyHash, tenantId: tenantId$1, projectId: projectId$1, ...apiKey }) => apiKey);
+	return c.json({
+		data: sanitizedData,
+		pagination: result.pagination
+	});
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get API Key",
+	description: "Get a specific API key by ID (does not return the actual key)",
+	operationId: "get-api-key-by-id",
+	tags: ["API Keys"],
+	request: { params: TenantProjectIdParamsSchema },
+	responses: {
+		200: {
+			description: "API key found",
+			content: { "application/json": { schema: ApiKeyResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, id } = c.req.valid("param");
+	const apiKey = await getApiKeyById(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		id
+	});
+	if (!apiKey || apiKey === void 0) throw createApiError({
+		code: "not_found",
+		message: "API key not found"
+	});
+	const { keyHash: _, tenantId: __, projectId: ___, ...sanitizedApiKey } = apiKey;
+	return c.json({ data: {
+		...sanitizedApiKey,
+		lastUsedAt: sanitizedApiKey.lastUsedAt ?? null,
+		expiresAt: sanitizedApiKey.expiresAt ?? null
+	} });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create API Key",
+	description: "Create a new API key for an agent. Returns the full key (shown only once).",
+	operationId: "create-api-key",
+	tags: ["API Keys"],
+	request: {
+		params: TenantProjectParamsSchema,
+		body: { content: { "application/json": { schema: ApiKeyApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "API key created successfully",
+			content: { "application/json": { schema: ApiKeyApiCreationResponseSchema } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId } = c.req.valid("param");
+	const body = c.req.valid("json");
+	const { key, ...keyDataWithoutKey } = await generateApiKey();
+	const insertData = {
+		tenantId,
+		projectId,
+		name: body.name,
+		agentId: body.agentId,
+		...keyDataWithoutKey,
+		expiresAt: body.expiresAt || void 0
+	};
+	try {
+		const { keyHash: _, tenantId: __, projectId: ___, ...sanitizedApiKey } = await createApiKey(dbClient_default)(insertData);
+		return c.json({ data: {
+			apiKey: {
+				...sanitizedApiKey,
+				lastUsedAt: sanitizedApiKey.lastUsedAt ?? null,
+				expiresAt: sanitizedApiKey.expiresAt ?? null
+			},
+			key
+		} }, 201);
+	} catch (error) {
+		if (error?.cause?.code === "23503") throw createApiError({
+			code: "bad_request",
+			message: "Invalid agentId - agent does not exist"
+		});
+		throw error;
+	}
+});
+app.openapi(createRoute({
+	method: "put",
+	path: "/{id}",
+	summary: "Update API Key",
+	description: "Update an API key (currently only expiration date can be changed)",
+	operationId: "update-api-key",
+	tags: ["API Keys"],
+	request: {
+		params: TenantProjectIdParamsSchema,
+		body: { content: { "application/json": { schema: ApiKeyApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "API key updated successfully",
+			content: { "application/json": { schema: ApiKeyResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const { tenantId, projectId, id } = c.req.valid("param");
+	const body = c.req.valid("json");
+	const updatedApiKey = await updateApiKey(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		id,
+		data: {
+			expiresAt: body.expiresAt,
+			name: body.name
+		}
+	});
+	if (!updatedApiKey) throw createApiError({
+		code: "not_found",
+		message: "API key not found"
+	});
+	const { keyHash: _, tenantId: __, projectId: ___, ...sanitizedApiKey } = updatedApiKey;
+	return c.json({ data: {
+		...sanitizedApiKey,
+		lastUsedAt: sanitizedApiKey.lastUsedAt ?? null,
+		expiresAt: sanitizedApiKey.expiresAt ?? null
+	} });
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete API Key",
+	description: "Delete an API key permanently",
+	operationId: "delete-api-key",
+	tags: ["API Keys"],
+	request: { params: TenantProjectIdParamsSchema },
+	responses: {
+		204: { description: "API key deleted successfully" },
+		404: {
+			description: "API key not found",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		}
+	}
+}), async (c) => {
+	const { tenantId, projectId, id } = c.req.valid("param");
+	if (!await deleteApiKey(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		id
+	})) throw createApiError({
+		code: "not_found",
+		message: "API key not found"
+	});
+	return c.body(null, 204);
+});
+var apiKeys_default = app;
+
+//#endregion
+export { apiKeys_default as default };