diff --git a/src/builders.ts b/src/builders.ts
index 72b0070..6446091 100644
--- a/src/builders.ts
+++ b/src/builders.ts
@@ -1,6 +1,6 @@
-import type { RegexElement } from './components/types';
+import type { RegexNode } from './types';
 import { encodeSequence } from './encoder/encoder';
-import { asElementArray } from './utils/elements';
+import { asNodeArray } from './utils/nodes';
 import { optionalFirstArg } from './utils/optional-arg';
 
 export interface RegexFlags {
@@ -26,7 +26,7 @@ export interface RegexFlags {
  * @param elements Single regex element or array of elements
  * @returns
  */
-export function buildRegex(elements: RegexElement | RegexElement[]): RegExp;
+export function buildRegex(elements: RegexNode | RegexNode[]): RegExp;
 
 /**
  * Generate RegExp object from elements with passed flags.
@@ -37,7 +37,7 @@ export function buildRegex(elements: RegexElement | RegexElement[]): RegExp;
  */
 export function buildRegex(
   flags: RegexFlags,
-  elements: RegexElement | RegexElement[]
+  elements: RegexNode | RegexNode[]
 ): RegExp;
 
 export function buildRegex(first: any, second?: any): RegExp {
@@ -46,9 +46,9 @@ export function buildRegex(first: any, second?: any): RegExp {
 
 export function _buildRegex(
   flags: RegexFlags,
-  elements: RegexElement | RegexElement[]
+  elements: RegexNode | RegexNode[]
 ): RegExp {
-  const pattern = encodeSequence(asElementArray(elements)).pattern;
+  const pattern = encodeSequence(asNodeArray(elements)).pattern;
   const flagsString = encodeFlags(flags ?? {});
   return new RegExp(pattern, flagsString);
 }
@@ -58,8 +58,8 @@ export function _buildRegex(
  * @param elements Single regex element or array of elements
  * @returns regex pattern string
  */
-export function buildPattern(elements: RegexElement | RegexElement[]): string {
-  return encodeSequence(asElementArray(elements)).pattern;
+export function buildPattern(elements: RegexNode | RegexNode[]): string {
+  return encodeSequence(asNodeArray(elements)).pattern;
 }
 
 function encodeFlags(flags: RegexFlags): string {
diff --git a/src/components/__tests__/character-class.test.ts b/src/components/__tests__/character-class.test.ts
index 0656092..ff14592 100644
--- a/src/components/__tests__/character-class.test.ts
+++ b/src/components/__tests__/character-class.test.ts
@@ -5,11 +5,11 @@ import {
   characterClass,
   characterRange,
   digit,
-  encodeCharacterClass,
   inverted,
   whitespace,
   word,
 } from '../character-class';
+import { buildRegex } from '../../builders';
 
 test('`any` character class', () => {
   expect(any).toHavePattern('.');
@@ -64,7 +64,7 @@ test('`characterRange` base cases', () => {
 
 test('`characterRange` throws on incorrect arguments', () => {
   expect(() => characterRange('z', 'a')).toThrowErrorMatchingInlineSnapshot(
-    `"\`start\` should be less or equal to \`end\`"`
+    `"\`start\` should be before or equal to \`end\`"`
   );
   expect(() => characterRange('aa', 'z')).toThrowErrorMatchingInlineSnapshot(
     `"\`characterRange\` should receive only single character \`start\` string"`
@@ -119,12 +119,15 @@ test('`inverted` character class execution', () => {
 
 test('`encodeCharacterClass` throws on empty text', () => {
   expect(() =>
-    encodeCharacterClass({
-      type: 'characterClass',
-      characters: [],
-      ranges: [],
-      isInverted: false,
-    })
+    buildRegex(
+      // @ts-expect-error
+      inverted({
+        type: 'characterClass',
+        characters: [],
+        ranges: [],
+        isInverted: false,
+      })
+    )
   ).toThrowErrorMatchingInlineSnapshot(
     `"Character class should contain at least one character or character range"`
   );
diff --git a/src/components/__tests__/choice-of.test.ts b/src/components/__tests__/choice-of.test.ts
index f887de8..852c528 100644
--- a/src/components/__tests__/choice-of.test.ts
+++ b/src/components/__tests__/choice-of.test.ts
@@ -38,6 +38,6 @@ test('`choiceOf` using nested regex', () => {
 
 test('`choiceOf` throws on empty options', () => {
   expect(() => choiceOf()).toThrowErrorMatchingInlineSnapshot(
-    `"\`choiceOf\` should receive at least one option"`
+    `"\`choiceOf\` should receive at least one alternative"`
   );
 });
diff --git a/src/components/anchors.ts b/src/components/anchors.ts
index 78e537c..b877ccc 100644
--- a/src/components/anchors.ts
+++ b/src/components/anchors.ts
@@ -1,19 +1,26 @@
-import { type EncoderNode, EncoderPrecedence } from '../encoder/types';
-import type { Anchor } from './types';
+import type { EncodeOutput } from '../encoder/types';
+import type { RegexElement } from '../types';
+
+export interface Anchor extends RegexElement {
+  type: 'anchor';
+  symbol: string;
+}
 
 export const startOfString: Anchor = {
   type: 'anchor',
   symbol: '^',
+  encode: encodeAnchor,
 };
 
 export const endOfString: Anchor = {
   type: 'anchor',
   symbol: '$',
+  encode: encodeAnchor,
 };
 
-export function encodeAnchor(anchor: Anchor): EncoderNode {
+function encodeAnchor(this: Anchor): EncodeOutput {
   return {
-    precedence: EncoderPrecedence.Sequence,
-    pattern: anchor.symbol,
+    precedence: 'sequence',
+    pattern: this.symbol,
   };
 }
diff --git a/src/components/capture.ts b/src/components/capture.ts
index d912e5b..4fd7b21 100644
--- a/src/components/capture.ts
+++ b/src/components/capture.ts
@@ -1,17 +1,24 @@
-import { type EncoderNode, EncoderPrecedence } from '../encoder/types';
-import { asElementArray } from '../utils/elements';
-import type { Capture, RegexElement } from './types';
+import { encodeSequence } from '../encoder/encoder';
+import type { EncodeOutput } from '../encoder/types';
+import { asNodeArray } from '../utils/nodes';
+import type { RegexElement, RegexNode } from '../types';
 
-export function capture(children: RegexElement | RegexElement[]): Capture {
+export interface Capture extends RegexElement {
+  type: 'capture';
+  children: RegexNode[];
+}
+
+export function capture(nodes: RegexNode | RegexNode[]): Capture {
   return {
     type: 'capture',
-    children: asElementArray(children),
+    children: asNodeArray(nodes),
+    encode: encodeCapture,
   };
 }
 
-export function encodeCapture(node: EncoderNode): EncoderNode {
+function encodeCapture(this: Capture): EncodeOutput {
   return {
-    precedence: EncoderPrecedence.Atom,
-    pattern: `(${node.pattern})`,
+    precedence: 'atom',
+    pattern: `(${encodeSequence(this.children).pattern})`,
   };
 }
diff --git a/src/components/character-class.ts b/src/components/character-class.ts
index 19a7de2..54525d6 100644
--- a/src/components/character-class.ts
+++ b/src/components/character-class.ts
@@ -1,12 +1,28 @@
-import { type EncoderNode, EncoderPrecedence } from '../encoder/types';
+import type { EncodeOutput } from '../encoder/types';
 import { escapeText } from '../utils/text';
-import type { CharacterClass } from './types';
+
+export interface CharacterClass {
+  type: 'characterClass';
+  characters: string[];
+  ranges: CharacterRange[];
+  isInverted: boolean;
+  encode: () => EncodeOutput;
+}
+
+/**
+ * Character range from start to end (inclusive).
+ */
+export interface CharacterRange {
+  start: string;
+  end: string;
+}
 
 export const any: CharacterClass = {
   type: 'characterClass',
   characters: ['.'],
   ranges: [],
   isInverted: false,
+  encode: encodeCharacterClass,
 };
 
 export const digit: CharacterClass = {
@@ -14,6 +30,7 @@ export const digit: CharacterClass = {
   characters: ['\\d'],
   ranges: [],
   isInverted: false,
+  encode: encodeCharacterClass,
 };
 
 export const word: CharacterClass = {
@@ -21,6 +38,7 @@ export const word: CharacterClass = {
   characters: ['\\w'],
   ranges: [],
   isInverted: false,
+  encode: encodeCharacterClass,
 };
 
 export const whitespace: CharacterClass = {
@@ -28,6 +46,7 @@ export const whitespace: CharacterClass = {
   characters: ['\\s'],
   ranges: [],
   isInverted: false,
+  encode: encodeCharacterClass,
 };
 
 export function characterClass(...elements: CharacterClass[]): CharacterClass {
@@ -44,6 +63,7 @@ export function characterClass(...elements: CharacterClass[]): CharacterClass {
     characters: elements.map((c) => c.characters).flat(),
     ranges: elements.map((c) => c.ranges).flat(),
     isInverted: false,
+    encode: encodeCharacterClass,
   };
 }
 
@@ -61,7 +81,7 @@ export function characterRange(start: string, end: string): CharacterClass {
   }
 
   if (start > end) {
-    throw new Error('`start` should be less or equal to `end`');
+    throw new Error('`start` should be before or equal to `end`');
   }
 
   const range = {
@@ -74,6 +94,7 @@ export function characterRange(start: string, end: string): CharacterClass {
     characters: [],
     ranges: [range],
     isInverted: false,
+    encode: encodeCharacterClass,
   };
 }
 
@@ -88,53 +109,51 @@ export function anyOf(characters: string): CharacterClass {
     characters: charactersArray,
     ranges: [],
     isInverted: false,
+    encode: encodeCharacterClass,
   };
 }
 
-export function inverted({
-  characters,
-  ranges,
-  isInverted,
-}: CharacterClass): CharacterClass {
+export function inverted(element: CharacterClass): CharacterClass {
   return {
     type: 'characterClass',
-    characters: characters,
-    ranges: ranges,
-    isInverted: !isInverted,
+    characters: element.characters,
+    ranges: element.ranges,
+    isInverted: !element.isInverted,
+    encode: encodeCharacterClass,
   };
 }
 
-export function encodeCharacterClass({
-  characters,
-  ranges,
-  isInverted,
-}: CharacterClass): EncoderNode {
-  if (characters.length === 0 && ranges.length === 0) {
+function encodeCharacterClass(this: CharacterClass): EncodeOutput {
+  if (this.characters.length === 0 && this.ranges.length === 0) {
     throw new Error(
       'Character class should contain at least one character or character range'
     );
   }
 
   // Direct rendering for single-character class
-  if (characters.length === 1 && ranges?.length === 0 && !isInverted) {
+  if (
+    this.characters.length === 1 &&
+    this.ranges?.length === 0 &&
+    !this.isInverted
+  ) {
     return {
-      precedence: EncoderPrecedence.Atom,
-      pattern: characters[0]!,
+      precedence: 'atom',
+      pattern: this.characters[0]!,
     };
   }
 
   // If passed characters includes hyphen (`-`) it need to be moved to
   // first (or last) place in order to treat it as hyphen character and not a range.
   // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Character_classes#types
-  const hyphenString = characters.includes('-') ? '-' : '';
-  const charactersString = characters.filter((c) => c !== '-').join('');
-  const rangesString = ranges
+  const hyphen = this.characters.includes('-') ? '-' : '';
+  const otherCharacters = this.characters.filter((c) => c !== '-').join('');
+  const ranges = this.ranges
     .map(({ start, end }) => `${start}-${end}`)
     .join('');
-  const invertedString = isInverted ? '^' : '';
+  const isInverted = this.isInverted ? '^' : '';
 
   return {
-    precedence: EncoderPrecedence.Atom,
-    pattern: `[${invertedString}${hyphenString}${rangesString}${charactersString}]`,
+    precedence: 'atom',
+    pattern: `[${isInverted}${hyphen}${ranges}${otherCharacters}]`,
   };
 }
diff --git a/src/components/choice-of.ts b/src/components/choice-of.ts
index 36ed184..47c7121 100644
--- a/src/components/choice-of.ts
+++ b/src/components/choice-of.ts
@@ -1,35 +1,35 @@
-import {
-  type EncoderNode,
-  EncoderPrecedence,
-  type EncodeSequence,
-} from '../encoder/types';
-import { asElementArray } from '../utils/elements';
-import type { ChoiceOf, RegexElement } from './types';
+import { encodeSequence } from '../encoder/encoder';
+import type { EncodeOutput } from '../encoder/types';
+import { asNodeArray } from '../utils/nodes';
+import type { RegexElement, RegexNode } from '../types';
+
+export interface ChoiceOf extends RegexElement {
+  type: 'choiceOf';
+  alternatives: RegexNode[][];
+}
 
 export function choiceOf(
-  ...children: Array<RegexElement | RegexElement[]>
+  ...alternatives: Array<RegexNode | RegexNode[]>
 ): ChoiceOf {
-  if (children.length === 0) {
-    throw new Error('`choiceOf` should receive at least one option');
+  if (alternatives.length === 0) {
+    throw new Error('`choiceOf` should receive at least one alternative');
   }
 
   return {
     type: 'choiceOf',
-    children: children.map((c) => asElementArray(c)),
+    alternatives: alternatives.map((c) => asNodeArray(c)),
+    encode: encodeChoiceOf,
   };
 }
 
-export function encodeChoiceOf(
-  element: ChoiceOf,
-  encodeSequence: EncodeSequence
-): EncoderNode {
-  const encodedNodes = element.children.map((c) => encodeSequence(c));
-  if (encodedNodes.length === 1) {
-    return encodedNodes[0]!;
+function encodeChoiceOf(this: ChoiceOf): EncodeOutput {
+  const encodedAlternatives = this.alternatives.map((c) => encodeSequence(c));
+  if (encodedAlternatives.length === 1) {
+    return encodedAlternatives[0]!;
   }
 
   return {
-    precedence: EncoderPrecedence.Alternation,
-    pattern: encodedNodes.map((n) => n.pattern).join('|'),
+    precedence: 'alternation',
+    pattern: encodedAlternatives.map((n) => n.pattern).join('|'),
   };
 }
diff --git a/src/components/quantifiers.ts b/src/components/quantifiers.ts
index 5d90d89..93711b6 100644
--- a/src/components/quantifiers.ts
+++ b/src/components/quantifiers.ts
@@ -1,67 +1,81 @@
-import { type EncoderNode, EncoderPrecedence } from '../encoder/types';
-import { toAtom } from '../encoder/utils';
-import { asElementArray } from '../utils/elements';
-import type {
-  One,
-  OneOrMore,
-  Optionally,
-  RegexElement,
-  ZeroOrMore,
-} from './types';
+import { encodeAtom, encodeSequence } from '../encoder/encoder';
+import type { EncodeOutput } from '../encoder/types';
+import { asNodeArray } from '../utils/nodes';
+import type { RegexElement, RegexNode } from '../types';
 
-export function one(children: RegexElement | RegexElement[]): One {
+export interface One extends RegexElement {
+  type: 'one';
+  children: RegexNode[];
+}
+
+export interface OneOrMore extends RegexElement {
+  type: 'oneOrMore';
+  children: RegexNode[];
+}
+
+export interface Optionally extends RegexElement {
+  type: 'optionally';
+  children: RegexNode[];
+}
+
+export interface ZeroOrMore extends RegexElement {
+  type: 'zeroOrMore';
+  children: RegexNode[];
+}
+
+export function one(nodes: RegexNode | RegexNode[]): One {
   return {
     type: 'one',
-    children: asElementArray(children),
+    children: asNodeArray(nodes),
+    encode: encodeOne,
   };
 }
 
-export function oneOrMore(children: RegexElement | RegexElement[]): OneOrMore {
+export function oneOrMore(nodes: RegexNode | RegexNode[]): OneOrMore {
   return {
     type: 'oneOrMore',
-    children: asElementArray(children),
+    children: asNodeArray(nodes),
+    encode: encodeOneOrMore,
   };
 }
 
-export function optionally(
-  children: RegexElement | RegexElement[]
-): Optionally {
+export function optionally(nodes: RegexNode | RegexNode[]): Optionally {
   return {
     type: 'optionally',
-    children: asElementArray(children),
+    children: asNodeArray(nodes),
+    encode: encodeOptionally,
   };
 }
 
-export function zeroOrMore(
-  children: RegexElement | RegexElement[]
-): ZeroOrMore {
+export function zeroOrMore(nodes: RegexNode | RegexNode[]): ZeroOrMore {
   return {
     type: 'zeroOrMore',
-    children: asElementArray(children),
+    children: asNodeArray(nodes),
+    encode: encodeZeroOrMore,
   };
 }
 
-export function encodeOne(node: EncoderNode) {
-  return node;
+function encodeOne(this: One) {
+  return encodeSequence(this.children);
 }
 
-export function encodeOneOrMore(node: EncoderNode): EncoderNode {
+function encodeOneOrMore(this: OneOrMore): EncodeOutput {
   return {
-    precedence: EncoderPrecedence.Sequence,
-    pattern: `${toAtom(node)}+`,
+    precedence: 'sequence',
+    pattern: `${encodeAtom(this.children).pattern}+`,
   };
 }
 
-export function encodeOptionally(node: EncoderNode): EncoderNode {
+function encodeOptionally(this: Optionally): EncodeOutput {
   return {
-    precedence: EncoderPrecedence.Sequence,
-    pattern: `${toAtom(node)}?`,
+    precedence: 'sequence',
+    pattern: `${encodeAtom(this.children).pattern}?`,
   };
 }
 
-export function encodeZeroOrMore(node: EncoderNode): EncoderNode {
+function encodeZeroOrMore(this: ZeroOrMore): EncodeOutput {
   return {
-    precedence: EncoderPrecedence.Sequence,
-    pattern: `${toAtom(node)}*`,
+    precedence: 'sequence',
+    pattern: `${encodeAtom(this.children).pattern}*`,
   };
 }
diff --git a/src/components/repeat.ts b/src/components/repeat.ts
index 11e304f..76f2368 100644
--- a/src/components/repeat.ts
+++ b/src/components/repeat.ts
@@ -1,13 +1,21 @@
-import { type EncoderNode, EncoderPrecedence } from '../encoder/types';
-import { toAtom } from '../encoder/utils';
-import { asElementArray } from '../utils/elements';
-import type { RegexElement, Repeat, RepeatConfig } from './types';
+import { encodeAtom } from '../encoder/encoder';
+import type { EncodeOutput } from '../encoder/types';
+import { asNodeArray } from '../utils/nodes';
+import type { RegexElement, RegexNode } from '../types';
+
+export interface Repeat extends RegexElement {
+  type: 'repeat';
+  options: RepeatOptions;
+  children: RegexNode[];
+}
+
+export type RepeatOptions = { count: number } | { min: number; max?: number };
 
 export function repeat(
-  config: RepeatConfig,
-  children: RegexElement | RegexElement[]
+  options: RepeatOptions,
+  nodes: RegexNode | RegexNode[]
 ): Repeat {
-  children = asElementArray(children);
+  const children = asNodeArray(nodes);
 
   if (children.length === 0) {
     throw new Error('`repeat` should receive at least one element');
@@ -16,23 +24,25 @@ export function repeat(
   return {
     type: 'repeat',
     children,
-    config,
+    options,
+    encode: encodeRepeat,
   };
 }
 
-export function encodeRepeat(
-  config: RepeatConfig,
-  node: EncoderNode
-): EncoderNode {
-  if ('count' in config) {
+function encodeRepeat(this: Repeat): EncodeOutput {
+  const atomicNodes = encodeAtom(this.children);
+
+  if ('count' in this.options) {
     return {
-      precedence: EncoderPrecedence.Sequence,
-      pattern: `${toAtom(node)}{${config.count}}`,
+      precedence: 'sequence',
+      pattern: `${atomicNodes.pattern}{${this.options.count}}`,
     };
   }
 
   return {
-    precedence: EncoderPrecedence.Sequence,
-    pattern: `${toAtom(node)}{${config.min},${config?.max ?? ''}}`,
+    precedence: 'sequence',
+    pattern: `${atomicNodes.pattern}{${this.options.min},${
+      this.options?.max ?? ''
+    }}`,
   };
 }
diff --git a/src/components/types.ts b/src/components/types.ts
deleted file mode 100644
index 7c5e36d..0000000
--- a/src/components/types.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-export type RegexElement =
-  | string
-  | CharacterClass
-  | Anchor
-  | ChoiceOf
-  | Quantifier
-  | Capture;
-
-export type Quantifier = One | OneOrMore | Optionally | ZeroOrMore | Repeat;
-
-/**
- * Character range from start to end (inclusive).
- */
-export type CharacterRange = {
-  start: string;
-  end: string;
-};
-
-// Components
-export type CharacterClass = {
-  type: 'characterClass';
-  characters: string[];
-  ranges: CharacterRange[];
-  isInverted: boolean;
-};
-
-export type Anchor = {
-  type: 'anchor';
-  symbol: string;
-};
-
-export type ChoiceOf = {
-  type: 'choiceOf';
-  children: RegexElement[][];
-};
-
-// Quantifiers
-export type One = {
-  type: 'one';
-  children: RegexElement[];
-};
-
-export type OneOrMore = {
-  type: 'oneOrMore';
-  children: RegexElement[];
-};
-
-export type Optionally = {
-  type: 'optionally';
-  children: RegexElement[];
-};
-
-export type ZeroOrMore = {
-  type: 'zeroOrMore';
-  children: RegexElement[];
-};
-
-export type Repeat = {
-  type: 'repeat';
-  children: RegexElement[];
-  config: RepeatConfig;
-};
-
-export type RepeatConfig = { count: number } | { min: number; max?: number };
-
-// Captures
-export type Capture = {
-  type: 'capture';
-  children: RegexElement[];
-};
diff --git a/src/encoder/__tests__/encoder.test.tsx b/src/encoder/__tests__/encoder.test.tsx
index 919573a..fdd40f0 100644
--- a/src/encoder/__tests__/encoder.test.tsx
+++ b/src/encoder/__tests__/encoder.test.tsx
@@ -59,7 +59,9 @@ test('`buildRegex` throws error on unknown element', () => {
   expect(() =>
     // @ts-expect-error intentionally passing incorrect object
     buildRegex({ type: 'unknown' })
-  ).toThrowErrorMatchingInlineSnapshot(`"Unknown element type unknown"`);
+  ).toThrowErrorMatchingInlineSnapshot(
+    `"\`encodeNode\`: unknown element type unknown"`
+  );
 });
 
 test('`buildPattern` throws on empty text', () => {
diff --git a/src/encoder/encoder.ts b/src/encoder/encoder.ts
index b588235..2d2614d 100644
--- a/src/encoder/encoder.ts
+++ b/src/encoder/encoder.ts
@@ -1,83 +1,67 @@
-import type { RegexElement } from '../components/types';
-import { encodeAnchor } from '../components/anchors';
-import { encodeCapture } from '../components/capture';
-import { encodeCharacterClass } from '../components/character-class';
-import { encodeChoiceOf } from '../components/choice-of';
-import {
-  encodeOne,
-  encodeOneOrMore,
-  encodeOptionally,
-  encodeZeroOrMore,
-} from '../components/quantifiers';
-import { encodeRepeat } from '../components/repeat';
+import type { RegexNode } from '../types';
 import { escapeText } from '../utils/text';
+import type { EncodeOutput } from './types';
 
-import { type EncoderNode, EncoderPrecedence } from './types';
-import { concatNodes } from './utils';
-
-export function encodeSequence(elements: RegexElement[]): EncoderNode {
-  return concatNodes(elements.map((c) => encodeElement(c)));
+export function encodeSequence(nodes: RegexNode[]): EncodeOutput {
+  const encodedNodes = nodes.map((n) => encodeNode(n));
+  return concatSequence(encodedNodes);
 }
 
-export function encodeElement(element: RegexElement): EncoderNode {
-  if (typeof element === 'string') {
-    return encodeText(element);
-  }
-
-  if (element.type === 'characterClass') {
-    return encodeCharacterClass(element);
-  }
-
-  if (element.type === 'anchor') {
-    return encodeAnchor(element);
-  }
-
-  if (element.type === 'choiceOf') {
-    return encodeChoiceOf(element, encodeSequence);
-  }
-
-  if (element.type === 'repeat') {
-    return encodeRepeat(element.config, encodeSequence(element.children));
-  }
-
-  if (element.type === 'one') {
-    return encodeOne(encodeSequence(element.children));
-  }
-
-  if (element.type === 'oneOrMore') {
-    return encodeOneOrMore(encodeSequence(element.children));
-  }
-
-  if (element.type === 'optionally') {
-    return encodeOptionally(encodeSequence(element.children));
-  }
+export function encodeAtom(nodes: RegexNode[]): EncodeOutput {
+  return asAtom(encodeSequence(nodes));
+}
 
-  if (element.type === 'zeroOrMore') {
-    return encodeZeroOrMore(encodeSequence(element.children));
+function encodeNode(node: RegexNode): EncodeOutput {
+  if (typeof node === 'string') {
+    return encodeText(node);
   }
 
-  if (element.type === 'capture') {
-    return encodeCapture(encodeSequence(element.children));
+  if (typeof node.encode !== 'function') {
+    throw new Error(`\`encodeNode\`: unknown element type ${node.type}`);
   }
 
-  // @ts-expect-error User passed incorrect type
-  throw new Error(`Unknown element type ${element.type}`);
+  return node.encode();
 }
 
-function encodeText(text: string): EncoderNode {
+function encodeText(text: string): EncodeOutput {
   if (text.length === 0) {
     throw new Error('`encodeText`: received text should not be empty');
   }
 
+  // Optimize for single character case
   if (text.length === 1) {
     return {
-      precedence: EncoderPrecedence.Atom,
+      precedence: 'atom',
       pattern: escapeText(text),
     };
   }
 
   return {
-    precedence: EncoderPrecedence.Sequence,
+    precedence: 'sequence',
     pattern: escapeText(text),
   };
 }
+
+function concatSequence(encoded: EncodeOutput[]): EncodeOutput {
+  if (encoded.length === 1) {
+    return encoded[0]!;
+  }
+
+  return {
+    precedence: 'sequence',
+    pattern: encoded
+      .map((n) => (n.precedence === 'alternation' ? asAtom(n) : n).pattern)
+      .join(''),
+  };
+}
+
+function asAtom(encoded: EncodeOutput): EncodeOutput {
+  if (encoded.precedence === 'atom') {
+    return encoded;
+  }
+
+  return {
+    precedence: 'atom',
+    pattern: `(?:${encoded.pattern})`,
+  };
+}
diff --git a/src/encoder/types.ts b/src/encoder/types.ts
index 0e38864..ad779c3 100644
--- a/src/encoder/types.ts
+++ b/src/encoder/types.ts
@@ -1,30 +1,9 @@
-import type { RegexElement } from '../components/types';
-
 /**
  * Encoded regex pattern with information about its type (atom, sequence)
  */
-export interface EncoderNode {
-  precedence: EncoderPrecedence;
+export interface EncodeOutput {
+  precedence: EncodePrecedence;
   pattern: string;
 }
 
-/**
- * Order of precedence for regex operators.
- */
-export const EncoderPrecedence = {
-  // Atoms: single characters, character classes (`\d`, `[a-z]`),
-  // capturing and non-capturing groups (`()`)
-  Atom: 1,
-
-  // Sequence of atoms, e.g., `abc`
-  Sequence: 2,
-
-  // Alteration (OR, `|`) expression, e.g., `a|b`
-  Alternation: 3,
-} as const;
-
-type ValueOf<T> = T[keyof T];
-type EncoderPrecedence = ValueOf<typeof EncoderPrecedence>;
-
-export type EncodeSequence = (elements: RegexElement[]) => EncoderNode;
-export type EncodeElement = (element: RegexElement) => EncoderNode;
+export type EncodePrecedence = 'atom' | 'sequence' | 'alternation';
diff --git a/src/encoder/utils.ts b/src/encoder/utils.ts
deleted file mode 100644
index d575c57..0000000
--- a/src/encoder/utils.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import { type EncoderNode, EncoderPrecedence } from './types';
-
-/**
- * Returns atomic pattern for given node.
- *
- * @param node
- * @returns
- */
-export function toAtom(node: EncoderNode): string {
-  if (node.precedence === EncoderPrecedence.Atom) {
-    return node.pattern;
-  }
-
-  return `(?:${node.pattern})`;
-}
-
-export function concatNodes(nodes: EncoderNode[]): EncoderNode {
-  if (nodes.length === 1) {
-    return nodes[0]!;
-  }
-
-  return {
-    precedence: EncoderPrecedence.Sequence,
-    pattern: nodes
-      .map((n) =>
-        n.precedence > EncoderPrecedence.Sequence ? toAtom(n) : n.pattern
-      )
-      .join(''),
-  };
-}
diff --git a/src/index.ts b/src/index.ts
index 652875f..df4ad3b 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,4 +1,4 @@
-export type * from './components/types';
+export type * from './types';
 
 export { buildPattern, buildRegex } from './builders';
 
diff --git a/src/types.ts b/src/types.ts
new file mode 100644
index 0000000..71efcd2
--- /dev/null
+++ b/src/types.ts
@@ -0,0 +1,8 @@
+import type { EncodeOutput } from './encoder/types';
+
+export type RegexNode = RegexElement | string;
+
+export interface RegexElement {
+  type: string;
+  encode(): EncodeOutput;
+}
diff --git a/src/utils/elements.ts b/src/utils/elements.ts
deleted file mode 100644
index 6bb8282..0000000
--- a/src/utils/elements.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import type { RegexElement } from '../components/types';
-
-export function isRegexElement(element: unknown): element is RegexElement {
-  return (
-    typeof element === 'string' ||
-    (typeof element === 'object' && element !== null && 'type' in element)
-  );
-}
-
-export function asElementArray(
-  elementOrArray: RegexElement | RegexElement[]
-): RegexElement[] {
-  return Array.isArray(elementOrArray) ? elementOrArray : [elementOrArray];
-}
diff --git a/src/utils/nodes.ts b/src/utils/nodes.ts
new file mode 100644
index 0000000..76020b0
--- /dev/null
+++ b/src/utils/nodes.ts
@@ -0,0 +1,5 @@
+import type { RegexNode } from '../types';
+
+export function asNodeArray(nodeOrArray: RegexNode | RegexNode[]): RegexNode[] {
+  return Array.isArray(nodeOrArray) ? nodeOrArray : [nodeOrArray];
+}
diff --git a/test-utils/to-have-pattern.ts b/test-utils/to-have-pattern.ts
index eca8cab..1867b0d 100644
--- a/test-utils/to-have-pattern.ts
+++ b/test-utils/to-have-pattern.ts
@@ -1,26 +1,24 @@
 import { buildPattern } from '../src/builders';
-import type { RegexElement } from '../src/components/types';
-import { isRegexElement } from '../src/utils/elements';
+import type { RegexNode } from '../src/types';
+import { asNodeArray } from '../src/utils/nodes';
+import { isRegexNode } from './utils';
 
 export function toHavePattern(
   this: jest.MatcherContext,
-  elements: RegexElement | RegexElement[],
+  nodes: RegexNode | RegexNode[],
   expected: string
 ) {
-  if (!Array.isArray(elements)) {
-    elements = [elements];
-  }
+  nodes = asNodeArray(nodes);
 
-  elements.forEach((e) => {
-    if (!isRegexElement(e)) {
+  nodes.forEach((e) => {
+    if (!isRegexNode(e)) {
       throw new Error(
         `\`toHavePattern()\` received an array of RegexElements and strings.`
       );
     }
   });
 
-  const received = buildPattern(elements);
-
+  const received = buildPattern(nodes);
   const options = {
     isNot: this.isNot,
   };
diff --git a/test-utils/to-match-groups.ts b/test-utils/to-match-groups.ts
index 73afa96..87eb86f 100644
--- a/test-utils/to-match-groups.ts
+++ b/test-utils/to-match-groups.ts
@@ -1,26 +1,25 @@
 import { buildRegex } from '../src/builders';
-import type { RegexElement } from '../src/components/types';
-import { isRegexElement } from '../src/utils/elements';
+import type { RegexNode } from '../src/types';
+import { asNodeArray } from '../src/utils/nodes';
+import { isRegexNode } from './utils';
 
 export function toMatchGroups(
   this: jest.MatcherContext,
-  elements: RegexElement | RegexElement[],
+  nodes: RegexNode | RegexNode[],
   input: string,
   expected: string[]
 ) {
-  if (!Array.isArray(elements)) {
-    elements = [elements];
-  }
+  nodes = asNodeArray(nodes);
 
-  elements.forEach((e) => {
-    if (!isRegexElement(e)) {
+  nodes.forEach((e) => {
+    if (!isRegexNode(e)) {
       throw new Error(
         `\`toMatchGroups()\` received an array of RegexElements and strings.`
       );
     }
   });
 
-  const regex = buildRegex(elements);
+  const regex = buildRegex(nodes);
   const options = {
     isNot: this.isNot,
   };
diff --git a/test-utils/utils.ts b/test-utils/utils.ts
new file mode 100644
index 0000000..66d48d7
--- /dev/null
+++ b/test-utils/utils.ts
@@ -0,0 +1,14 @@
+import type { RegexElement, RegexNode } from '../src/types';
+
+export function isRegexNode(node: unknown): node is RegexNode {
+  return typeof node === 'string' || isRegexElement(node);
+}
+
+export function isRegexElement(element: unknown): element is RegexElement {
+  return (
+    typeof element === 'object' &&
+    element !== null &&
+    'encode' in element &&
+    typeof element.encode === 'function'
+  );
+}