@rnaga/wp-node 1.1.0

package/types/capabilities.d.ts

@@ -0,0 +1,71 @@
+import { ROLE_CAPABILITY_ACTIONS, ROLE_CAPABILITIES } from "../constants";
+
+export interface MapMetaCapArgs {
+  edit_user: [userId: number] | [];
+  remove_user: [userId: number] | [];
+  delete_post: [postId: number];
+  delete_page: [postId: number];
+  edit_post: [postId: number];
+  edit_page: [postId: number];
+  read_post: [postId: number];
+  read_page: [postId: number];
+  publish_post: [postId: number];
+  publish_page: [postId: number];
+  edit_post_meta: [objectId: number];
+  delete_post_meta: [objectId: number];
+  add_post_meta: [objectId: number];
+  edit_comment_meta: [objectId: number];
+  delete_comment_meta: [objectId: number];
+  add_comment_meta: [objectId: number];
+  edit_term_meta: [objectId: number];
+  delete_term_meta: [objectId: number];
+  add_term_meta: [objectId: number];
+  edit_user_meta: [objectId: number];
+  delete_user_meta: [objectId: number];
+  add_user_meta: [objectId: number];
+  edit_comment: [commentId: number];
+  edit_term: [termId: number];
+  delete_term: [termId: number];
+  assign_term: [termId: number];
+  create_app_password: [userId: number] | [];
+  list_app_passwords: [userId: number] | [];
+  read_app_password: [userId: number] | [];
+  edit_app_password: [userId: number] | [];
+  delete_app_passwords: [userId: number] | [];
+  delete_app_password: [userId: number] | [];
+
+  // In filter
+  create_users: [siteIds: number[]] | [];
+  edit_admin_roles: [blogId: number] | [];
+  edit_user_roles: [blogIds: number[]] | [];
+  manage_roles: [blogId: number] | [];
+
+  delete_user: [targetUserId: number];
+  manage_network_users: [blogIds: number[]] | [];
+  manage_network_user: [userId: number[]] | [];
+  manage_network: [siteIds: number[]] | [];
+  manage_network_options: [siteIds: number[]] | [];
+
+  manage_sites: [blogIds: number[]] | [];
+  delete_sites: [blogIds: number[]] | [];
+  create_sites: [blogIds: number[]] | [];
+  manage_options: [blogIds: number[]] | [];
+
+  manage_blog_users: [blogIds: number[]] | [];
+  manage_site_users: [siteIds: number[]] | [];
+
+  list_blog_users: [blogIds: number[]] | [];
+}
+
+export type MapMetaCapArgsKeys = keyof MapMetaCapArgs;
+
+export type RoleCapabilityActions =
+  | (typeof ROLE_CAPABILITY_ACTIONS)[number]
+  | (typeof ROLE_CAPABILITIES)[number]
+  | MapMetaCapArgsKeys;
+
+export type TMapMetaCapArgs<T> = T extends keyof MapMetaCapArgs
+  ? MapMetaCapArgs[T] extends Array<any> | undefined
+    ? MapMetaCapArgs[T]
+    : any
+  : any;

package/types/common.d.ts

@@ -0,0 +1,16 @@
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type Abstract<T> = Function & { prototype: T };
+export type Constructor<T = any> = new (...args: any[]) => T;
+export type Class<T> = Abstract<T> | Constructor<T>;
+
+export type JSONValue =
+  | string
+  | number
+  | boolean
+  | null
+  | { [x: string]: JSONValue }
+  | Array<JSONValue>;
+
+export type DeepPartial<T> = {
+  [P in keyof T]?: DeepPartial<T[P]>;
+};

package/types/component.d.ts

@@ -0,0 +1,3 @@
+import type { Constructor } from "./common";
+
+export type Component = Constructor;

package/types/config.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+
+import * as val from "../validators";
+import type { TaxonomyObject } from "./taxonomy";
+import type { PostTypeObject, PostStatusObject } from "./post";
+import type { DeepPartial } from "./common";
+
+export type Config = z.infer<typeof val.config.config>;
+export type Configs = z.infer<typeof val.config.configs>;
+
+export type ConfigTaxonomy = Omit<TaxonomyObject, "objectType" | "_builtin"> & {
+  objectType?: string;
+};
+
+export type ConfigPostTypeObject = Partial<
+  Omit<PostTypeObject[string], "_builtin" | "supports">
+> & {
+  supports?: string[];
+};
+
+export type ConfigPostStatusObject = Omit<
+  PostStatusObject[string],
+  "label" | "_builtin"
+>;
+
+export type JSONWPConfig = DeepPartial<Exclude<Config, "database">> &
+  Required<{
+    staticAssetsPath: Config["staticAssetsPath"];
+  }>;
+
+export type JSONConfigTaxonomy = Record<string, ConfigTaxonomy>;
+export type JSONConfigPostTypeObject = Record<string, ConfigPostTypeObject>;
+export type JSONConfigPostStatusObject = Record<string, ConfigPostStatusObject>;

package/types/crud.d.ts

@@ -0,0 +1,230 @@
+import { BlogCrud } from "../crud/blog.crud";
+import { CommentCrud } from "../crud/comment.crud";
+import { MetaCrud } from "../crud/meta.crud";
+import { OptionsCrud } from "../crud/options.crud";
+import { PostCrud } from "../crud/post.crud";
+import { SiteCrud } from "../crud/site.crud";
+import { SettingsCrud } from "../crud/settings.crud";
+import { TermCrud } from "../crud/term.crud";
+import { UserCrud } from "../crud/user.crud";
+import { CrudUtil } from "../core/utils/crud.util";
+import { Crud } from "../crud/crud";
+import { RevisionCrud } from "../crud/revision.crud";
+import { RolesCrud } from "../crud/roles.crud";
+import { UserSelfRegistrationCrud } from "../crud/user-self-registration.crud";
+
+export type ParseError = ReturnType<CrudUtil["parseError"]>;
+
+type Operation =
+  | "list"
+  | "create"
+  | "get"
+  | "getAsUpsert"
+  | "update"
+  | "delete";
+
+export type CrudKeys =
+  | "blog"
+  | "comment"
+  | "meta"
+  | "options"
+  | "post"
+  | "site"
+  | "term"
+  | "settings"
+  | "user"
+  | "revision"
+  | "roles";
+
+type Context = "view" | "edit" | "embed";
+
+interface CrudComponents {
+  blog: BlogCrud;
+  comment: CommentCrud;
+  meta: MetaCrud;
+  options: OptionsCrud;
+  post: PostCrud;
+  site: SiteCrud;
+  term: TermCrud;
+  settings: SettingsCrud;
+  user: UserCrud;
+  userSelfRegistration: UserSelfRegistrationCrud;
+  revision: RevisionCrud;
+  roles: RolesCrud;
+}
+
+// interface CrudOperations {
+//   blog: Exclude<Operation, "getAsUpsert">;
+//   comment: Operation;
+//   meta: Extract<Operation, "create" | "get" | "update" | "delete">;
+//   options: Extract<Operation, "get" | "update"> | "getAll";
+//   post: Operation | "trash" | "untrash";
+//   site: Exclude<Operation, "getAsUpsert">;
+//   settings: Extract<Operation, "get" | "update">;
+//   term: Exclude<Operation, "getAsUpsert"> | "taxonomies";
+//   user:
+//     | Operation
+//     | "updatePassword"
+//     | "updateRole"
+//     | "updateSuperAdmin"
+//     | "getAvailableSites"
+//     | "getBlogs";
+//   revision: Extract<Operation, "get" | "list">;
+//   roles: Exclude<Operation, "get" | "getAsUpsert"> | "count";
+// }
+
+export type CrudParameters<
+  Component extends keyof CrudComponents,
+  Operation extends keyof CrudComponents[Component]
+> = CrudComponents[Component][Operation] extends (...args: any) => any
+  ? Parameters<CrudComponents[Component][Operation]>
+  : never;
+
+export type CrudReturnType<
+  Component extends keyof CrudComponents,
+  Operation extends keyof CrudComponents[Component]
+> = CrudComponents[Component][Operation] extends (...args: any) => any
+  ? Awaited<ReturnType<CrudComponents[Component][Operation]>>
+  : never;
+
+export type BlogOperations = Exclude<Operation, "getAsUpsert">;
+
+export type BlogParams<T extends BlogOperations> = {
+  list: Parameters<BlogCrud["list"]>;
+  create: Parameters<BlogCrud["create"]>;
+  get: Parameters<BlogCrud["get"]>;
+  update: Parameters<BlogCrud["update"]>;
+  delete: Parameters<BlogCrud["delete"]>;
+}[T];
+
+export type CommentOperations = Operation;
+
+export type CommentParams<T extends CommentOperations> = {
+  list: Parameters<CommentCrud["list"]>;
+  create: Parameters<CommentCrud["create"]>;
+  get: Parameters<CommentCrud["get"]>;
+  getAsUpsert: Parameters<CommentCrud["getAsUpsert"]>;
+  update: Parameters<CommentCrud["update"]>;
+  delete: Parameters<CommentCrud["delete"]>;
+}[T];
+
+export type MetaOperations = Extract<
+  Operation,
+  "create" | "get" | "update" | "delete"
+>;
+
+export type MetaParams<T extends MetaOperations> = {
+  create: Parameters<MetaCrud["create"]>;
+  get: Parameters<MetaCrud["get"]>;
+  update: Parameters<MetaCrud["update"]>;
+  delete: Parameters<MetaCrud["delete"]>;
+}[T];
+
+export type OptionsOperations = Extract<Operation, "get" | "update"> | "getAll";
+
+export type OptionsParams<T extends OptionsOperations> = {
+  get: Parameters<OptionsCrud["get"]>;
+  getAll: Parameters<OptionsCrud["getAll"]>;
+  update: Parameters<OptionsCrud["update"]>;
+}[T];
+
+export type PostOperations = Operation;
+
+export type PostParams<T extends PostOperations> = {
+  list: Parameters<PostCrud["list"]>;
+  create: Parameters<PostCrud["create"]>;
+  get: Parameters<PostCrud["get"]>;
+  getAsUpsert: Parameters<PostCrud["getAsUpsert"]>;
+  update: Parameters<PostCrud["update"]>;
+  delete: Parameters<PostCrud["delete"]>;
+  trash: Parameters<PostCrud["trash"]>;
+  untrash: Parameters<PostCrud["untrash"]>;
+}[T];
+
+export type SiteOperations = Exclude<Operation, "getAsUpsert">;
+
+export type SiteParams<T extends SiteOperations> = {
+  list: Parameters<SiteCrud["list"]>;
+  create: Parameters<SiteCrud["create"]>;
+  get: Parameters<SiteCrud["get"]>;
+  update: Parameters<SiteCrud["update"]>;
+  delete: Parameters<SiteCrud["delete"]>;
+}[T];
+
+export type SettingsOperations = Extract<Operation, "get" | "update">;
+
+export type SettingsParams<T extends SettingsOperations> = {
+  get: Parameters<SettingsCrud["get"]>;
+  update: Parameters<SettingsCrud["update"]>;
+}[T];
+
+export type TermOperations = Exclude<Operation, "getAsUpsert"> | "taxonomies";
+
+export type TermParams<T extends TermOperations> = {
+  list: Parameters<TermCrud["list"]>;
+  create: Parameters<TermCrud["create"]>;
+  get: Parameters<TermCrud["get"]>;
+  update: Parameters<TermCrud["update"]>;
+  delete: Parameters<TermCrud["delete"]>;
+  taxonomies: Parameters<TermCrud["taxonomies"]>;
+}[T];
+
+export type UserOperations =
+  | Operation
+  | "updatePassword"
+  | "updateRole"
+  | "updateSuperAdmin"
+  | "getAvailableSites"
+  | "getBlogs";
+
+export type UserParams<T extends UserOperations> = {
+  list: Parameters<UserCrud["list"]>;
+  create: Parameters<UserCrud["create"]>;
+  get: Parameters<UserCrud["get"]>;
+  getAsUpsert: Parameters<UserCrud["getAsUpsert"]>;
+  getAvailableSites: Parameters<UserCrud["getAvailableSites"]>;
+  getBlogs: Parameters<UserCrud["getBlogs"]>;
+  update: Parameters<UserCrud["update"]>;
+  updatePassword: Parameters<UserCrud["updatePassword"]>;
+  updateRole: Parameters<UserCrud["updateRole"]>;
+  updateSuperAdmin: Parameters<UserCrud["updateSuperAdmin"]>;
+  delete: Parameters<UserCrud["delete"]>;
+}[T];
+
+export type UserSelfRegistrationOperations =
+  | "update"
+  | "register"
+  | "activate"
+  | "registerWithoutActivation";
+
+export type UserSelfRegistrationParams<
+  T extends UserSelfRegistrationOperations
+> = {
+  update: Parameters<UserSelfRegistrationCrud["update"]>;
+  register: Parameters<UserSelfRegistrationCrud["register"]>;
+  activate: Parameters<UserSelfRegistrationCrud["activate"]>;
+  registerWithoutActivation: Parameters<
+    UserSelfRegistrationCrud["registerWithoutActivation"]
+  >;
+}[T];
+
+export type RevisionOperations = Extract<Operation, "get" | "list">;
+
+export type RevisionParams<T extends RevisionOperations> = {
+  get: Parameters<RevisionCrud["get"]>;
+  list: Parameters<RevisionCrud["list"]>;
+}[T];
+
+export type RolesOperations =
+  | Extract<Operation, "create" | "list" | "update">
+  | "count";
+
+export type RolesParams<T extends RolesOperations> = {
+  create: Parameters<RolesCrud["create"]>;
+  list: Parameters<RolesCrud["list"]>;
+  count: Parameters<RolesCrud["count"]>;
+  update: Parameters<RolesCrud["update"]>;
+  delete: Parameters<RolesCrud["delete"]>;
+}[T];
+
+export type Pagination = ReturnType<Crud["pagination"]>;

package/types/database.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+
+import type * as val from "../validators";
+
+export interface Tables {
+  blogmeta: WpBlogMeta;
+  blogs: WpBlogs;
+  commentmeta: WpCommentMeta;
+  comments: WpComments;
+  links: WpLinks;
+  options: WpOptions;
+  postmeta: WpPostMeta;
+  posts: WpPosts;
+  registration_log: WpRegistrationLog;
+  signups: WpSignups;
+  site: WpSite;
+  sitemeta: WpSiteMeta;
+  termmeta: WpTermMeta;
+  term_relationships: WpTermRelationships;
+  term_taxonomy: WpTermTaxonomy;
+  terms: WpTerms;
+  users: WpUsers;
+  usermeta: WpUserMeta;
+}
+
+export type TableNames = keyof Tables;
+export type Columns<K extends TableNames> = keyof Tables[K];
+
+export interface WpBlogMeta extends z.infer<typeof val.database.wpBlogMeta> {}
+export interface WpBlogs extends z.infer<typeof val.database.wpBlogs> {}
+export interface WpCommentMeta
+  extends z.infer<typeof val.database.wpCommentMeta> {}
+export interface WpComments extends z.infer<typeof val.database.wpComments> {}
+export interface WpLinks extends z.infer<typeof val.database.wpLinks> {}
+export interface WpOptions extends z.infer<typeof val.database.wpOptions> {}
+export interface WpPostMeta extends z.infer<typeof val.database.wpPostMeta> {}
+export interface WpPosts extends z.infer<typeof val.database.wpPosts> {}
+export interface WpRegistrationLog
+  extends z.infer<typeof val.database.wpRegistrationLog> {}
+export interface WpSignups extends z.infer<typeof val.database.wpSignups> {}
+export interface WpSite extends z.infer<typeof val.database.wpSite> {}
+export interface WpSiteMeta extends z.infer<typeof val.database.wpSiteMeta> {}
+export interface WpTermMeta extends z.infer<typeof val.database.wpTermMeta> {}
+export interface WpTerms extends z.infer<typeof val.database.wpTerms> {}
+export interface WpTermRelationships
+  extends z.infer<typeof val.database.wpTermRelationships> {}
+export interface WpTermTaxonomy
+  extends z.infer<typeof val.database.wpTermTaxonomy> {}
+export interface WpUserMeta extends z.infer<typeof val.database.wpUserMeta> {}
+export interface WpUsers extends z.infer<typeof val.database.wpUsers> {}

package/types/hooks/actions.d.ts

@@ -0,0 +1,67 @@
+import { User } from "../../core/user";
+import type { LogLevel } from "../logging";
+import { Context } from "../../core/context";
+
+export interface Actions {
+  core_test_action: () => void;
+  core_test_async_action: () => Promise<void>;
+
+  /**
+   * Triggered when the application context is initialized.
+   *
+   * @param context - The application context.
+   * @returns void - No return value.
+   */
+  core_init: (context: Context) => void;
+
+  /**
+   * Triggered when the user requests a password reset.
+   *
+   * @param resetKey - The reset key.
+   * @param user - The user requesting the password reset.
+   * @param siteName - The name of the site.
+   * @param registration - Whether the reset key is generated while user self registration.
+   * @param context - The application context.
+   * @returns Promise<void> - A promise that resolves when the action is complete.
+   */
+  core_reset_password: (
+    resetKey: string,
+    user: User,
+    siteName: string,
+    registration: boolean,
+    context: Context
+  ) => Promise<void>;
+
+  /**
+   * Triggered when a new user is registered.
+   *
+   * @param userId - The ID of the user.
+   * @returns void
+   */
+  core_register_new_user: (
+    activationKey: string,
+    userLogin: string,
+    email: string,
+    context: Context
+  ) => Promise<void>;
+
+  /**
+   * For logging messages.
+   *
+   * @param message - The message to log.
+   * @param meta - Additional metadata to log.
+   * @param level - The log level.
+   * @returns void - No return value.
+   */
+  core_logging: (
+    message: string,
+    meta: Record<string, any> | undefined,
+    level: LogLevel
+  ) => void;
+}
+
+export type ActionParameters<T extends keyof Actions> = Parameters<Actions[T]>;
+export type ActionsReturnType<T extends keyof Actions> = ReturnType<Actions[T]>;
+export type ActionsAwaitedReturnType<T extends keyof Actions> = Awaited<
+  ReturnType<Actions[T]>
+>;

package/types/hooks/command.d.ts

@@ -0,0 +1,17 @@
+import type { Filters, FilterParameters } from "./filters";
+export type HooksCommandPrefix = "__command_";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type CommandFilter<T1, T2 = null> = {
+  id: string;
+};
+
+export type CommandFilterSecondParam<T extends keyof Filters> =
+  FilterParameters<T>[1] extends NonNullable<FilterParameters<T>[1]>
+    ? Exclude<FilterParameters<T>, FilterParameters<T>[0]>
+    : null;
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type CommandAction<T> = {
+  id: string;
+};

package/types/hooks/filters.d.ts

@@ -0,0 +1,86 @@
+import type { RoleCapabilityActions } from "../capabilities";
+import { Context } from "../../core/context";
+import { User } from "../../core/user";
+
+/**
+ * Represents a collection of filters.
+ */
+export interface Filters {
+  /**
+   * Filter for testing a filter.
+   *
+   * @param data - The data to be filtered.
+   * @returns The filtered data.
+   */
+  test_filter: (data: number) => number;
+
+  /**
+   * Filter for validating a user's capabilities.
+   *
+   * @param capabilities - The set of capabilities to validate.
+   * @param context - The application context.
+   * @param action - The action being performed.
+   * @param user - The user performing the action.
+   * @param args - Additional arguments passed to the filter.
+   * @returns A promise that resolves with the validated capabilities.
+   */
+  core_map_meta_cap: (
+    capabilities: Set<string>,
+    context: Context,
+    action: RoleCapabilityActions,
+    user: User,
+    ...args: any
+  ) => Promise<Set<string>>;
+
+  /**
+   * Filter for validating a user's capabilities of managing network users.
+   *
+   * @param capabilities - The set of capabilities to validate.
+   * @param context - The application context.
+   * @param user - The user performing the action.
+   * @param args - Additional arguments passed to the filter.
+   * @returns A promise that resolves with the validated capabilities.
+   */
+  core_map_meta_cap_manage_network_users: (
+    capabilities: Set<string>,
+    context: Context,
+    user: User,
+    ...args: any
+  ) => Promise<Set<string>>;
+
+  /**
+   * Filter for validating a user's capabilities of deleting a user.
+   *
+   * @param capabilities - The set of capabilities to validate.
+   * @param context - The application context.
+   * @param user - The user performing the action.
+   * @param args - Additional arguments passed to the filter.
+   * @returns A promise that resolves with the validated capabilities.
+   */
+  core_map_meta_cap_delete_user: (
+    capabilities: Set<string>,
+    context: Context,
+    user: User,
+    ...args: any
+  ) => Promise<Set<string>>;
+
+  /**
+   * Filter for generating a unique user login.
+   *
+   * @param userLogin - Randomly generated user login
+   * @returns A promise that resolves with the unique user login.
+   */
+  core_unigue_user_login: (userLogin: string) => Promise<string>;
+}
+
+type Parameters<T extends (...args: any) => any> = T extends (
+  ...args: infer P
+) => any
+  ? P
+  : never;
+
+export type FilterParameters<T extends keyof Filters> = Parameters<Filters[T]>;
+export type FiltersReturnType<T extends keyof Filters> = ReturnType<Filters[T]>;
+export type FiltersAwaitedReturnType<T extends keyof Filters> = Awaited<
+  ReturnType<Filters[T]>
+>;

package/types/hooks/index.d.ts

@@ -0,0 +1,11 @@
+export type * from "./actions";
+export type * from "./filters";
+export type * from "./command";
+
+import { Hooks as HooksCore } from "../../core/hooks/hooks";
+import { Filters } from "./filters";
+import { Actions } from "./actions";
+
+export type Hooks<TFilters = Filters, TActions = Actions> = InstanceType<
+  typeof HooksCore<TFilters, TActions>
+>;

package/types/index.d.ts

@@ -0,0 +1,18 @@
+export type * from "./common";
+export type * from "./component";
+export type * from "./config";
+export type * from "./role";
+export type * from "./query-builder";
+export type * from "./database";
+export type * from "./capabilities";
+export type * from "./taxonomy";
+export type * from "./post";
+export type * as validating from "./validating";
+export type * from "./meta";
+export type * from "./schema";
+export type * as hooks from "./hooks/index.d";
+export type * as crud from "./crud";
+export type * from "./options";
+export type * as trx from "./transactions";
+export type * from "./user";
+export type * from "./logging";

package/types/logging.d.ts

@@ -0,0 +1 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";

package/types/meta.d.ts

@@ -0,0 +1,9 @@
+export type MetaTable = "post" | "comment" | "blog" | "term" | "user" | "site";
+export type MetaColumns =
+  | "meta_id"
+  | `${MetaTable}_id`
+  | "meta_key"
+  | "meta_value";
+//export type MetaColumns = Extract<Columns, "meta_key" | "meta_value">;
+export type MetaKey = Extract<MetaColumns, "meta_key">;
+export type MetaValue = Extract<MetaColumns, "meta_value">;

package/types/options.d.ts

@@ -0,0 +1,3 @@
+import type * as val from "../validators";
+
+export type DefaultOptionNames = keyof typeof val.options.shape;

package/types/post.d.ts

@@ -0,0 +1,54 @@
+import * as defaults from "../defaults";
+
+export interface PostTypeExtend {}
+
+export type PostType =
+  | (typeof defaults.postTypes)[number]
+  | keyof PostTypeExtend;
+
+type PostTypeSupports =
+  | "title"
+  | "editor"
+  | "author"
+  | "thumbnail"
+  | "excerpt"
+  | "trackbacks"
+  | "custom-fields"
+  | "comments"
+  | "revisions"
+  | "post-formats"
+  | "page-attributes";
+
+export type PostTypeObject = Record<
+  string,
+  {
+    supports: PostTypeSupports[];
+    capabilityType: string | [string, string];
+    deleteWithUser: boolean;
+    mapMetaCap: boolean;
+    capabilities?: Record<string, string>;
+    hierarchical?: boolean;
+    showInRest: boolean;
+    publiclyQueryable?: boolean;
+    _builtin: boolean;
+    public: boolean;
+  }
+>;
+
+export interface PostStatusExtend {}
+
+export type PostStatus =
+  | (typeof defaults.postStatuses)[number]
+  | keyof PostStatusExtend;
+
+export type PostStatusObject = Record<
+  string,
+  {
+    label: string;
+    public?: boolean;
+    protected?: boolean;
+    private?: boolean;
+    internal?: boolean;
+    _builtin: boolean;
+  }
+>;