One definition. Thirteen platforms.

const { POST } = createEndpoint({
  scopedTranslation,
  method: Methods.POST,
  path: ["explain", "to-my-boss"],
  title: "post.title" as const,
  description: "post.description" as const,
  icon: "sparkles",
  category: "endpointCategories.ai",
  allowedRoles: [UserRole.CUSTOMER, UserRole.ADMIN] as const,
  fields: customWidgetObject({
    render: ExplainContainer,
    usage: { request: "data", response: true } as const,
    children: {
      decision: requestField(scopedTranslation, {
        type: WidgetType.FORM_FIELD,
        fieldType: FieldDataType.TEXTAREA,
        label: "post.decision.label" as const,
        columns: 12,
        schema: z.string().min(10),
      }),
      justification: responseField(scopedTranslation, {
        type: WidgetType.TEXT,
        content: "post.justification.content" as const,
        schema: z.string(),
      }),
    },
  }),
  errorTypes: {
    [EndpointErrorTypes.UNAUTHORIZED]:      { title: "post.errors.unauthorized.title" as const,      description: "post.errors.unauthorized.description" as const },
    [EndpointErrorTypes.SERVER_ERROR]:      { title: "post.errors.serverError.title" as const,       description: "post.errors.serverError.description" as const },
    // ... other error types
  },
  successTypes: { title: "post.success.title" as const, description: "post.success.description" as const },
  examples: { requests: { default: { decision: "Rewrite everything in TypeScript" } }, responses: { default: { justification: "..." } } },
});

export type ExplainResponseOutput = typeof POST.types.ResponseOutput;
const definitions = { POST } as const;
export default definitions;

import "server-only";

export class ExplainRepository {
  static async explainToMyBoss(
    data: ExplainRequestOutput,
    user: JwtPayloadType,
    logger: EndpointLogger,
    t: ExplainT,
  ): Promise<ResponseType<ExplainResponseOutput>> {
    if (!user.id) {
      return fail({ message: t("post.errors.unauthorized.title"), errorType: ErrorResponseTypes.UNAUTHORIZED });
    }
    try {
      const [saved] = await db
        .insert(explainResults)
        .values({ userId: user.id, decision: data.decision })
        .returning();
      logger.info("Saved decision", { userId: user.id, id: saved.id });
      return success({ justification: saved.justification ?? "" });
    } catch (error) {
      logger.error("Failed to save decision", parseError(error));
      return fail({ message: t("post.errors.serverError.title"), errorType: ErrorResponseTypes.INTERNAL_ERROR });
    }
  }
}

"use client";

interface CustomWidgetProps {
  field: {
    value: ExplainResponseOutput | null | undefined;
  } & (typeof definition.POST)["fields"];
}

export function ExplainContainer({ field }: CustomWidgetProps): JSX.Element {
  const children = field.children;
  const emptyField = useMemo(() => ({}), []);

  return (
    <Div className="flex flex-col gap-4 p-4">
      <TextareaFieldWidget fieldName="decision" field={children.decision} />
      <SubmitButtonWidget<typeof definition.POST>
        field={{
          text: "Explain to my boss",
          loadingText: "Explaining...",
          icon: "sparkles",
          variant: "primary",
        }}
      />
      <FormAlertWidget field={emptyField} />
      <AlertWidget
        fieldName="justification"
        field={withValue(children.justification, field.value?.justification, null)}
      />
    </Div>
  );
}