@everysk/apps-sdk 0.1.0-beta.0

package/src/api/profile.ts

@@ -0,0 +1,80 @@
+import { isAxiosError, type AxiosInstance, type AxiosResponse } from "axios";
+
+import type { AnyRecord } from "@/types/anyRecord";
+import type { Profile, ProfileResponse } from "@/types/profile";
+
+const baseUrl = "profile";
+
+/**
+ * DEV_PROFILE — the profile served while running the dev server.
+ *
+ * `GET /api/profile` only works in production: it resolves the user from the session, and in dev
+ * the Vite proxy authenticates with OAuth2 client credentials (a machine token, no logged user),
+ * so the endpoint has no session to read and the request fails. This stands in for it and covers
+ * every field the API returns, so a screen renders with realistic values in dev.
+ *
+ * The values are deliberately obvious placeholders — see `docs/development.md`.
+ */
+export const DEV_PROFILE: Profile = {
+    email: "dev@everysk.com",
+    user_type: "USER",
+    region: "BR",
+    company_name: "Everysk (dev)",
+    first_name: "Dev",
+    last_name: "User",
+    phone: "+55 11 0000-0000",
+    address: "Dev address, 0",
+    billing_email: "dev@everysk.com",
+    time_zone: "America/Sao_Paulo",
+    company_logo: "",
+    user_role: "ADMIN",
+    skin_theme: "light",
+    account_deletion_requested: false,
+    asset: "",
+    owner: true,
+    auto_refresh: false,
+};
+
+/**
+ * getProfile
+ *
+ * Fetches the profile of the logged user. The endpoint takes no parameters — the API resolves the
+ * user from the session — so an app always gets whoever is using it.
+ *
+ * When `fallback` is given it is returned as-is and the network is never touched. That is how an
+ * app serves `DEV_PROFILE` while running the dev server, where the endpoint cannot resolve.
+ *
+ * The template decided this itself with `if (import.meta.env.DEV) return DEV_PROFILE`. That
+ * cannot live in a published package: Vite replaces `import.meta.env.DEV` with a literal at the
+ * build of whoever compiles the file, so the branch would freeze to whatever the SDK's own build
+ * was and stop tracking the consuming app entirely. Which environment counts as "dev" is the
+ * app's question, so the app answers it:
+ *
+ * ```ts
+ * useFetchProfile({ fallback: import.meta.env.DEV ? DEV_PROFILE : undefined });
+ * ```
+ *
+ * @param {AxiosInstance} api - Axios instance.
+ * @param {Profile} [fallback] - Returned instead of calling the API, when present.
+ * @returns {Promise<Profile>} The logged user's profile.
+ *
+ * @throws {Error} If the request fails.
+ */
+export const getProfile = async (api: AxiosInstance, fallback?: Profile): Promise<Profile> => {
+    if (fallback) return fallback;
+
+    try {
+        const response: AxiosResponse<ProfileResponse> = await api.get(baseUrl);
+        return response.data.profile;
+    } catch (error: unknown) {
+        if (isAxiosError<AnyRecord>(error)) {
+            throw new Error(error.message || "Error while fetching profile");
+        }
+
+        if (error instanceof Error) {
+            throw error;
+        }
+
+        throw new Error("Error while fetching profile");
+    }
+};

package/src/api/websocketsConfig.ts

@@ -0,0 +1,32 @@
+import { isAxiosError, type AxiosInstance, type AxiosResponse } from "axios";
+
+import type { AnyRecord } from "@/types/anyRecord";
+import type { WebsocketsConfig } from "@/contexts/webSocketContext/types";
+
+const baseUrl = "websockets_config";
+
+/**
+ * getWebsocketsConfig
+ *
+ * Fetches the Socket.IO connection config for the current user/app.
+ *
+ * @param {AxiosInstance} api - Axios instance (from `useAxios`).
+ * @returns {Promise<WebsocketsConfig>} Connection URL, channel id, and session uid.
+ * @throws {Error} If the request fails.
+ */
+export const getWebsocketsConfig = async (api: AxiosInstance): Promise<WebsocketsConfig> => {
+    try {
+        const response: AxiosResponse<WebsocketsConfig> = await api.get(baseUrl);
+        return response.data;
+    } catch (error: unknown) {
+        if (isAxiosError<AnyRecord>(error)) {
+            throw new Error(error.message || "Error fetching websockets config");
+        }
+
+        if (error instanceof Error) {
+            throw error;
+        }
+
+        throw new Error("Error fetching websockets config");
+    }
+};

package/src/api/workflow.ts

@@ -0,0 +1,427 @@
+import { isAxiosError, type AxiosInstance, type AxiosResponse } from "axios";
+
+import type { AnyRecord } from "@/types/anyRecord";
+import type { FilterExpression, QueryObject } from "@/types/entityQuery";
+import type { WorkerExecution, WorkerExecutionListResponse, WorkerExecutionSingleResponse, Workflow, WorkflowExecution, WorkflowExecutionListResponse, WorkflowExecutionSingleResponse, WorkflowListResponse, WorkflowSingleResponse } from "@/types/workflow";
+
+const baseUrl = "workflows";
+
+/**
+ * Runs a workflow asynchronously.
+ *
+ * Starts the workflow in a non-blocking way: the response carries a workflow execution
+ * with a non-terminal status (e.g. "RUNNING"). Use polling to wait for the terminal state.
+ *
+ * @param api - Axios instance used to make the HTTP request.
+ * @param id - The unique identifier of the workflow to run.
+ * @param workspace - The workspace in which the workflow will be executed.
+ * @param parameters - Key-value parameters to pass to the workflow.
+ * @returns A promise that resolves with the workflow execution response data.
+ * @throws {Error} If `workspace` is not provided.
+ * @throws {Error} If the request fails.
+ */
+export const runWorkflow = async (api: AxiosInstance, id: string, workspace: string, parameters: AnyRecord): Promise<AnyRecord> => {
+  
+  if (!workspace) {
+    throw new Error("Workspace is required to run workflow");
+  } 
+
+  try {
+    const body: AnyRecord = {
+      workspace,
+      parameters,
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const response: AxiosResponse<any> = await api.post(`${baseUrl}/${id}/run`, body);
+
+    return response.data;
+  } catch (error: unknown) {
+    if (isAxiosError<AnyRecord>(error)) {
+      throw new Error(error.message || "");
+    }
+
+    if (error instanceof Error) {
+      throw error;
+    }
+
+    throw new Error("Error while running workflow");
+  }
+};
+
+/**
+ * Run statuses that indicate a workflow execution has reached a terminal state
+ * (i.e. it is no longer running and will not change again).
+ *
+ * Union of the backend's `WORKFLOW_EXECUTION_STATUS_FINISHED` set and the API's documented
+ * terminal `run_status` values (`SUCCEEDED`/`FAILED`/`KILLED`). `KILLED` is included so a
+ * killed execution is detected as terminal instead of polling until timeout.
+ */
+export const TERMINAL_RUN_STATUSES = ["CANCELED", "COMPLETED", "SUCCEEDED", "FAILED", "KILLED"] as const;
+
+const isTerminalRunStatus = (runStatus: unknown): boolean =>
+  TERMINAL_RUN_STATUSES.includes(String(runStatus ?? "").toUpperCase() as (typeof TERMINAL_RUN_STATUSES)[number]);
+
+const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+
+export type PollWorkflowExecutionOptions = {
+  /** Delay between status checks, in milliseconds. Defaults to 2000ms. */
+  intervalMs?: number;
+  /** Maximum time to wait for a terminal status before giving up, in milliseconds. Defaults to 5 minutes. */
+  timeoutMs?: number;
+  /** Optional abort signal to cancel polling (e.g. on unmount). */
+  signal?: AbortSignal;
+};
+
+/**
+ * Polls a workflow execution until it reaches a terminal run status (see {@link TERMINAL_RUN_STATUSES}).
+ *
+ * This is the interim, non-blocking replacement for synchronous (`synchronous: true`) execution:
+ * the workflow is started asynchronously and its status is checked periodically until it completes.
+ *
+ * @param api - Axios instance used to make the HTTP request.
+ * @param workflowId - The unique identifier of the workflow.
+ * @param executionId - The unique identifier of the workflow execution to poll.
+ * @param workspace - The workspace in which the workflow execution resides.
+ * @param options - Polling configuration (interval, timeout, abort signal).
+ * @returns A promise that resolves with the terminal {@link WorkflowExecution}.
+ * @throws {Error} If `workspace` is not provided.
+ * @throws {Error} If polling is aborted via `options.signal`.
+ * @throws {Error} If a terminal status is not reached before `options.timeoutMs` elapses.
+ */
+export const pollWorkflowExecution = async (
+  api: AxiosInstance,
+  workflowId: string,
+  executionId: string,
+  workspace: string,
+  options: PollWorkflowExecutionOptions = {}
+): Promise<WorkflowExecution> => {
+  if (!workspace) {
+    throw new Error("Workspace is required to poll a workflow execution");
+  }
+
+  const { intervalMs = 2000, timeoutMs = 5 * 60 * 1000, signal } = options;
+  const startedAt = Date.now();
+
+  while (true) {
+    if (signal?.aborted) {
+      throw new Error("Workflow execution polling was aborted");
+    }
+
+    const execution = await getWorkflowExecution(api, workflowId, executionId, workspace);
+
+    if (isTerminalRunStatus(execution.run_status)) {
+      return execution;
+    }
+
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw new Error("Timed out while waiting for the workflow execution to complete");
+    }
+
+    await sleep(intervalMs);
+  }
+};
+
+/**
+ * Starts a workflow asynchronously and polls its execution until completion.
+ *
+ * Interim replacement for synchronous execution: instead of holding the request open with
+ * `synchronous: true`, the workflow is started in a non-blocking way and its status is polled
+ * until it reaches a terminal state, at which point the final execution (with its result) is returned.
+ *
+ * @param api - Axios instance used to make the HTTP request.
+ * @param id - The unique identifier of the workflow to run.
+ * @param workspace - The workspace in which the workflow will be executed.
+ * @param parameters - Key-value parameters to pass to the workflow.
+ * @param options - Polling configuration (interval, timeout, abort signal).
+ * @returns A promise that resolves with the terminal {@link WorkflowExecution}.
+ * @throws {Error} If `workspace` is not provided.
+ * @throws {Error} If the run response does not contain a workflow execution id.
+ * @throws {Error} If the workflow execution ends in a "FAILED" run status.
+ * @throws {Error} If polling times out or is aborted.
+ */
+const runWorkflowAndPoll = async (
+  api: AxiosInstance,
+  id: string,
+  workspace: string,
+  parameters: AnyRecord,
+  options: PollWorkflowExecutionOptions = {}
+): Promise<WorkflowExecution> => {
+  if (!workspace) {
+    throw new Error("Workspace is required to run workflow");
+  }
+
+  // Start the workflow asynchronously (non-blocking).
+  const startResponse = await runWorkflow(api, id, workspace, parameters);
+  const executionId = (startResponse.workflow_execution as WorkflowExecution | undefined)?.id;
+
+  if (!executionId) {
+    throw new Error("Workflow run did not return an execution id to poll");
+  }
+
+  // Poll the execution status until it completes, then consume the result.
+  const execution = await pollWorkflowExecution(api, id, executionId, workspace, options);
+
+  if (String(execution.run_status ?? "").toUpperCase() === "FAILED") {
+    throw new Error("Workflow execution failed");
+  }
+
+  return execution;
+};
+
+/**
+ * The terminal workflow execution together with the output produced by its final (ender) worker.
+ */
+export type WorkflowResult = {
+  /** The terminal workflow execution. */
+  execution: WorkflowExecution;
+  /** The ender worker execution, or `null` if the execution did not reference one. */
+  workerExecution: WorkerExecution | null;
+  /** The output data produced by the ender worker (`workerExecution.result`), or `null`. */
+  result: Record<string, unknown> | null;
+};
+
+/**
+ * Starts a workflow, polls it to completion, then fetches the output produced by its final worker.
+ *
+ * A workflow execution does not carry the output payload itself — it references the final worker via
+ * `ender_worker_execution_id`, and that worker execution's `result` field holds the actual data.
+ * This helper performs the full flow: start (async) → poll → fetch ender worker → return its `result`.
+ *
+ * @param api - Axios instance used to make the HTTP request.
+ * @param id - The unique identifier of the workflow to run.
+ * @param workspace - The workspace in which the workflow will be executed.
+ * @param parameters - Key-value parameters to pass to the workflow.
+ * @param options - Polling configuration (interval, timeout, abort signal).
+ * @returns A promise that resolves with the {@link WorkflowResult} (execution, ender worker execution, and its result).
+ * @throws {Error} If `workspace` is not provided.
+ * @throws {Error} If the workflow execution ends in a "FAILED" run status.
+ * @throws {Error} If polling times out or is aborted.
+ */
+export const runWorkflowAndGetResult = async (
+  api: AxiosInstance,
+  id: string,
+  workspace: string,
+  parameters: AnyRecord,
+  options: PollWorkflowExecutionOptions = {}
+): Promise<WorkflowResult> => {
+  const execution = await runWorkflowAndPoll(api, id, workspace, parameters, options);
+
+  const enderWorkerExecutionId = execution.ender_worker_execution_id;
+  if (!enderWorkerExecutionId) {
+    return { execution, workerExecution: null, result: null };
+  }
+
+  const workerExecution = await getWorkerExecution(api, id, enderWorkerExecutionId, workspace);
+
+  return { execution, workerExecution, result: workerExecution.result ?? null };
+};
+
+/**
+ * Fetches a single workflow by ID.
+ *
+ * @param api - Axios instance used to make the HTTP request.
+ * @param id - The unique identifier of the workflow to fetch.
+ * @param workspace - The workspace in which the workflow resides.
+ * @returns A promise that resolves with the {@link Workflow} object.
+ * @throws {Error} If `workspace` is not provided.
+ * @throws {Error} If the request fails.
+ */
+export const getWorkflow = async (api: AxiosInstance, id: string, workspace: string): Promise<Workflow> => {
+  if (!workspace) {
+    throw new Error("Workspace is required to fetch a workflow");
+  }
+  
+  try {
+    const params: AnyRecord = { workspace };
+    const response: AxiosResponse<WorkflowSingleResponse> = await api.get(`${baseUrl}/${id}`, { params });
+
+    return response.data.workflow;
+  } catch (error: unknown) {
+    if (isAxiosError<AnyRecord>(error)) {
+      throw new Error(error.message || "Error while fetching workflow");
+    } 
+    if (error instanceof Error) {
+      throw error;
+    }
+
+    throw new Error("Error while fetching workflow");
+  }
+};
+
+/**
+ * Fetches a paginated list of workflows using the legacy method (workspace as query param).
+ *
+ * @param api - Axios instance used to make the HTTP request.
+ * @param workspace - Current workspace name. Sent as a query param via the legacy method, required by some API configurations.
+ * @param pageSize - Number of items per page.
+ * @param pageToken - Cursor token for the next page.
+ * @returns A promise that resolves with a {@link WorkflowListResponse} containing the matched workflows.
+ * @throws {Error} If the request fails.
+ */
+export const listWorkflows = async (api: AxiosInstance, workspace?: string, pageSize?: number, pageToken?: string): Promise<WorkflowListResponse> => {
+  const params: AnyRecord = {};
+
+  if (workspace) params.workspace = workspace;
+  if (pageSize) params.page_size = pageSize;
+  if (pageToken) params.page_token = pageToken;
+
+  try {
+    const response: AxiosResponse<WorkflowListResponse> = await api.get(baseUrl, { params });
+    return response.data;
+  } catch (error: unknown) {
+    if (isAxiosError<AnyRecord>(error)) {
+      throw new Error(error.message || "Error listing workflows");
+    }
+
+    if (error instanceof Error) {
+      throw error;
+    }
+
+    throw new Error("Error listing workflows");
+  }
+};
+
+/**
+ * Fetches a single workflow execution by ID.
+ *
+ * @param api - Axios instance used to make the HTTP request.
+ * @param workflowId - The unique identifier of the workflow.
+ * @param executionId - The unique identifier of the workflow execution to fetch.
+ * @param workspace - The workspace in which the workflow execution resides.
+ * @returns A promise that resolves with the {@link WorkflowExecution} object.
+ * @throws {Error} If `workspace` is not provided.
+ * @throws {Error} If the request fails.
+ */
+export const getWorkflowExecution = async (api: AxiosInstance, workflowId: string, executionId: string, workspace: string): Promise<WorkflowExecution> => {
+  if (!workspace) {
+    throw new Error("Workspace is required to fetch a workflow execution");
+  }
+
+  try {
+    const params: AnyRecord = { workspace, workflow_execution_id: executionId };
+    const response: AxiosResponse<WorkflowExecutionSingleResponse> = await api.get(`${baseUrl}/${workflowId}/workflow_executions`, { params });
+    return response.data.workflow_execution;
+  } catch (error: unknown) {
+    if (isAxiosError<AnyRecord>(error)) {
+      throw new Error(error.message || "Error fetching workflow execution");
+    }
+
+    if (error instanceof Error) {
+      throw error;
+    }
+
+    throw new Error("Error fetching workflow execution");
+  }
+};
+
+/**
+ * Fetches a paginated list of workflow executions matching the given query.
+ *
+ * @param api - Axios instance used to make the HTTP request.
+ * @param workflowId - The unique identifier of the workflow whose executions to list.
+ * @param query - Query object containing filters, pagination, and sorting options.
+ *   Must include a `workspace` filter expression.
+ * @returns A promise that resolves with a {@link WorkflowExecutionListResponse} containing the matched executions.
+ * @throws {Error} If the `workspace` filter is not present in `query.filters`.
+ * @throws {Error} If the request fails.
+ */
+export const listWorkflowExecutions = async (api: AxiosInstance, workflowId: string, query: QueryObject): Promise<WorkflowExecutionListResponse> => {
+  const workspaceFilter = query.filters.find((filter: FilterExpression) => filter[0] === "workspace");
+  const workspace = workspaceFilter?.[workspaceFilter.length - 1];
+
+  if (!workspace) throw new Error("Workspace filter is required to list workflows");
+
+  try {
+    const params: AnyRecord = {
+      workspace,
+      ...(query ? { query: JSON.stringify(query) } : {}),
+    };
+
+    const response: AxiosResponse<WorkflowExecutionListResponse> = await api.get(`${baseUrl}/${workflowId}/workflow_executions`, { params });
+    return response.data;
+  } catch (error: unknown) {
+    if (isAxiosError<AnyRecord>(error)) {
+      throw new Error(error.message || "Error listing workflow executions");
+    }
+
+    if (error instanceof Error) {
+      throw error;
+    }
+
+    throw new Error("Error listing workflow executions");
+  }
+};
+
+/**
+ * Fetches a single worker execution by ID.
+ *
+ * @param api - Axios instance used to make the HTTP request.
+ * @param workflowId - The unique identifier of the parent workflow.
+ * @param workerExecutionId - The unique identifier of the worker execution to fetch.
+ * @param workspace - The workspace in which the worker execution resides.
+ * @returns A promise that resolves with the {@link WorkerExecution} object.
+ * @throws {Error} If `workspace` is not provided.
+ * @throws {Error} If the request fails.
+ */
+export const getWorkerExecution = async (api: AxiosInstance, workflowId: string, workerExecutionId: string, workspace: string): Promise<WorkerExecution> => {
+  if (!workspace) {
+    throw new Error("Workspace is required to fetch a worker execution");
+  }
+
+  try {
+    const params: AnyRecord = { workspace, worker_execution_id: workerExecutionId, with_result: true };
+    const response: AxiosResponse<WorkerExecutionSingleResponse> = await api.get(`${baseUrl}/${workflowId}/worker_executions`, { params });
+    return response.data.worker_execution;
+  } catch (error: unknown) {
+    if (isAxiosError<AnyRecord>(error)) {
+      throw new Error(error.message || "Error fetching worker execution");
+    }
+
+    if (error instanceof Error) {
+      throw error;
+    }
+
+    throw new Error("Error fetching worker execution");
+  }
+}
+
+/**
+ * Fetches a paginated list of worker executions for a given workflow.
+ *
+ * @param api - Axios instance used to make the HTTP request.
+ * @param workflowId - The unique identifier of the parent workflow.
+ * @param workflowExecutionId - The unique identifier of the workflow execution to filter by.
+ * @param query - Query object containing filters, pagination, and sorting options.
+ *   Must include a `workspace` filter expression.
+ * @returns A promise that resolves with a {@link WorkerExecutionListResponse} containing the matched worker executions.
+ * @throws {Error} If the `workspace` filter is not present in `query.filters`.
+ * @throws {Error} If the request fails.
+ */
+export const listWorkerExecutions = async (api: AxiosInstance, workflowId: string, workflowExecutionId: string, query: QueryObject): Promise<WorkerExecutionListResponse> => {
+  const workspaceFilter = query.filters.find((filter: FilterExpression) => filter[0] === "workspace");
+  const workspace = workspaceFilter?.[workspaceFilter.length - 1];
+
+  if (!workspace) throw new Error("Workspace filter is required to list worker executions");
+
+  try {
+    const params: AnyRecord = {
+      workspace,
+      workflow_execution_id: workflowExecutionId,
+      ...(query ? { query: JSON.stringify(query) } : {}),
+    };
+
+    const response: AxiosResponse<WorkerExecutionListResponse> = await api.get(`${baseUrl}/${workflowId}/worker_executions`, { params });
+    return response.data;
+  } catch (error: unknown) {
+    if (isAxiosError<AnyRecord>(error)) {
+      throw new Error(error.message || "Error listing worker executions");
+    }
+
+    if (error instanceof Error) {
+      throw error;
+    }
+
+    throw new Error("Error listing worker executions");
+  }
+};

package/src/api/workspace.ts

@@ -0,0 +1,72 @@
+import { isAxiosError, type AxiosInstance, type AxiosResponse } from "axios";
+
+import type { AnyRecord } from "@/types/anyRecord";
+import type { Workspace, WorkspaceListResponse, WorkspaceSingleResponse } from "@/types/workspace";
+
+const baseUrl = "workspaces";
+
+/**
+ * getWorkspace
+ *
+ * Fetches a single workspace by name.
+ *
+ * @param {AxiosInstance} api - Axios instance.
+ * @param {string} name - Workspace name.
+ * @returns {Promise<Workspace>} The fetched workspace.
+ *
+ * @throws {Error} If the request fails.
+ */
+export const getWorkspace = async (api: AxiosInstance, name: string): Promise<Workspace> => {
+  if (!name) throw new Error("Workspace name is required to fetch a workspace");
+
+  try {
+    const response: AxiosResponse<WorkspaceSingleResponse> = await api.get(`${baseUrl}/${name}`);
+    return response.data.workspace;
+  } catch (error: unknown) {
+    if (isAxiosError<AnyRecord>(error)) {
+      throw new Error(error.message || "Error while fetching workspace");
+    }
+
+    if (error instanceof Error) {
+      throw error;
+    }
+
+    throw new Error("Error while fetching workspace");
+  }
+};
+
+/**
+ * listWorkspaces
+ *
+ * Fetches a list of workspaces with optional cursor-based pagination.
+ *
+ * @param {AxiosInstance} api - Axios instance.
+ * @param {string} [workspace] - Current workspace name. Sent as a query param via the legacy method, required by some API configurations.
+ * @param {number} [pageSize] - Number of items per page.
+ * @param {string} [pageToken] - Cursor token for the next page.
+ * @returns {Promise<WorkspaceListResponse>} List of workspaces.
+ *
+ * @throws {Error} If the request fails.
+ */
+export const listWorkspaces = async (api: AxiosInstance, workspace?: string, pageSize?: number, pageToken?: string): Promise<WorkspaceListResponse> => {
+  const params: AnyRecord = {};
+
+  if (workspace) params.workspace = workspace;
+  if (pageSize) params.page_size = pageSize;
+  if (pageToken) params.page_token = pageToken;
+
+  try {
+    const response: AxiosResponse<WorkspaceListResponse> = await api.get(baseUrl, { params });
+    return response.data;
+  } catch (error: unknown) {
+    if (isAxiosError<AnyRecord>(error)) {
+      throw new Error(error.message || "Error while fetching workspaces");
+    }
+
+    if (error instanceof Error) {
+      throw error;
+    }
+
+    throw new Error("Error while fetching workspaces");
+  }
+};

package/src/components/ui/EveryskIcon/index.tsx

@@ -0,0 +1,24 @@
+import SvgIcon, { type SvgIconProps } from "@mui/material/SvgIcon";
+
+// The Everysk brand mark always renders in the brand color (hardcoded `fill` below),
+// so `color` is intentionally omitted from the public props — it cannot be overridden.
+type EveryskIconProps = Omit<SvgIconProps, "color">;
+
+export const EveryskIcon = (props: EveryskIconProps) => {
+    return (
+        <SvgIcon viewBox="0 0 232.468 232.47" {...props}>
+            <g transform="matrix(1.90217,0,0,1.90217,-829.46974,-201.49716)">
+                <path
+                    d="m 504.00435,178.6316 c -3.10349,-6.57161 -6.79598,-14.3885 -14.28016,-17.57649 l 17.02712,-19.54438 h 16.70879 v -9.57528 h -21.06556 l -24.04193,27.59281 -10.24551,0.0558 v 0.009 h -0.90364 v 9.57529 h 14.95337 c 6.46328,0 9.20027,5.15474 13.18994,13.56505 l 0.007,0.0144 c 4.0444,8.5514 9.07315,19.18404 22.11214,19.18404 h 6.00047 l -0.008,-9.58329 h -6.00047 c -6.64688,0 -9.44775,-5.23453 -13.45333,-13.71662 z"
+                    fill="#FF9933"
+                />
+                <path
+                    d="m 464.42384,228.13498 h 93.85315 v -122.1966 h -122.212 v 93.83775 c 0.008,7.51868 2.99897,14.72726 8.31545,20.04332 5.31645,5.31607 12.52472,8.30732 20.0434,8.31553 z m -18.78357,-28.35885 v -84.26247 l 103.06226,0.0319 v 103.01388 h -84.27869 c -4.97976,-0.006 -9.75396,-1.98698 -13.27517,-5.50809 -3.52121,-3.52111 -5.50206,-8.2955 -5.5084,-13.27527 z"
+                    fillRule="evenodd"
+                    clipRule="evenodd"
+                    fill="#FF9933"
+                />
+            </g>
+        </SvgIcon>
+    );
+};

package/src/components/ui/Footer/index.tsx

@@ -0,0 +1,30 @@
+import type { PropsWithChildren } from "react"
+
+import { clsx } from 'clsx';
+import Paper from "@mui/material/Paper";
+import { useTheme, type Theme } from "@mui/material/styles";
+
+import type { AnyRecord } from "@/types/anyRecord";
+
+export const Footer = ({ className, children }: PropsWithChildren<{ className?: string }>) => {
+    const theme: Theme = useTheme();
+    const paperProps: AnyRecord = {
+        light: {
+            variant: 'outlined',
+        },
+        dark: {
+            variant: 'elevation'
+        }
+    };
+
+    return (
+        <Paper
+            square
+            elevation={1}
+            component="footer"
+            className={clsx("flex shrink-0 grow-0 basis-auto h-16 pl-6 pr-6", className)}
+            {...paperProps?.[theme.palette.mode]} >
+            {children}
+        </Paper>
+    );
+}