sveltekit-ui 1.0.8 → 1.0.9

package/dist/client/types/index.js

@@ -72,86 +72,6 @@ export const acceptable_storage_mime_types = [
   "text/markdown",
 ]
 
-export const node_categories = {
-  main: {
-    h: 7,
-    display_order: 1,
-  },
-  variables: {
-    h: 9,
-    display_order: 2,
-  },
-  actions: {
-    h: 12,
-    display_order: 3,
-  },
-  math: {
-    h: 15,
-    display_order: 4,
-  },
-  compare: {
-    h: 18,
-    display_order: 5,
-  },
-  arrays: {
-    h: 20,
-    display_order: 6,
-  },
-  triggers: {
-    h: 22,
-    display_order: 7,
-  },
-}
-
-// triggers:
-// cron
-// link_visited / qr_code_scanned
-// signed_up_to_contibase
-// subscribed_to_email_list
-// unsubscribed_from_email_list
-// submits_form
-// opens_email
-// clicks_link_in_email
-// votes_in_poll
-// replies_to_email
-// date_has_passed
-// makes_a_purchase
-// abandons_cart
-// qualified_score_changes
-// value_score
-// subscription_payment_failed
-// views_post_on_contibase
-// upgraded
-// downgraded
-// email was sent,received,opened,clicked
-// days_without_opens
-// days_without_clicks
-// days_without_opens_change
-// referred_users_change
-// subscription_tier_change
-// twitter_verified
-// twitter_followers
-// instagram_verified
-// instagram_followers
-// discord_verified
-// webhook_endpoint_called
-// manual_call
-// user_poll_amounts
-// user_poll_correct within last 30 days
-// user_poll_amounts
-// user_poll_correct_percentage of last 30 days or of last 10 polls
-
-// get_current_date
-// ask_chat_ai
-// set_custom_field_on_subscriber
-// set_subscriber_tier
-// send_email
-// rate_limiter
-
-// image_literal
-// audio_literal
-// get_typeof
-
 const array_literal = {
   kind: "literal",
   category: "variables",
@@ -520,2154 +440,102 @@ const location_literal = {
       country_code: { type: "string" },
       administrative_area: { type: "string" },
       administrative_area_code: { type: "string" },
-      locality: { type: "string" },
-      sub_locality: { type: "string" },
-      full_thoroughfare: { type: "string" },
-    },
-    required: ["latitude", "longitude", "name"],
-    additionalProperties: false,
-  },
-  validator: (input) => {
-    // validate here
-  },
-}
-const cron_literal = {
-  kind: "literal",
-  category: "variables",
-  name: "Cron",
-  postgres_type: "jsonb",
-  json_schema: {
-    type: "object",
-    properties: {
-      content: { type: "string" },
-      cron: { type: "string" },
-      minute: { type: "string" },
-      hour: { type: "string" },
-      day_of_month: { type: "string" },
-      month: { type: "string" },
-      day_of_week: { type: "string" },
-    },
-    additionalProperties: false,
-    required: [],
-  },
-  validator: (input) => {
-    // validate here
-  },
-}
-const variable_path_literal = {
-  kind: "literal",
-  category: "variables",
-  name: "Variable Path",
-  postgres_type: "jsonb",
-  json_schema: {
-    type: "array",
-    description: "The path to the value within variables.",
-    items: {
-      anyOf: [
-        {
-          type: "string",
-        },
-        {
-          type: "number",
-        },
-        {
-          type: "array",
-          items: {
-            anyOf: [
-              {
-                type: "string",
-              },
-              {
-                type: "number",
-              },
-            ],
-          },
-        },
-      ],
-    },
-  },
-  validator: (input) => {
-    // validate here
-  },
-}
-const content_literal = {
-  kind: "literal",
-  category: "variables",
-  name: "Content",
-  postgres_type: "jsonb",
-  // json_schema: get_content_node_json_schema("content_literal"),
-  validator: (input) => {
-    // validate here
-  },
-}
-const table_id_for_foreign_row_literal = {
-  kind: "literal",
-  category: "variables",
-  name: "Table ID for Foreign Row",
-  postgres_type: "text",
-  // json_schema: get_content_node_json_schema("content_literal"),
-  validator: (input) => {
-    // validate here
-  },
-}
-// image_literal
-// audio_literal
-// file_literal
-// dropdown_literal
-// text_array_literal
-// function_literal
-
-const node_json_schema = {}
-const all_node_types = [
-  "defined_target_literal",
-  "stack_literal",
-  "function_literal",
-  "define",
-  "set_defined",
-  "get_defined",
-  "run_defined",
-  "if_then",
-  "if_then_else",
-  "for_loop",
-  "return",
-  "dropdown_literal",
-  "log",
-  "truthy_compare",
-  "arithmetic_binary_operation",
-  "round",
-  "parse",
-  "add_item_to_array",
-  "add_item_to_array_at_index",
-  "remove_item_from_array",
-  "remove_item_from_array_at_index",
-  "split_text",
-  "concat_arrays",
-  "sort_array",
-  "local_compare",
-  "slice",
-  "join_array_of_text_items",
-  "reverse_array",
-  "average_of_number_array",
-  "sum_of_number_array",
-  "trim_text",
-  "replace_text",
-  "compare_numbers",
-  "compare_text",
-  "get_length",
-  "object_expression",
-  "call_endpoint",
-  "cron_job",
-]
-const value_node_types = [
-  "array_literal",
-  "array_uniform_literal",
-  "object_literal",
-  "object_uniform_literal",
-  "text_literal",
-  "boolean_literal",
-  "int_literal",
-  "bigint_literal",
-  "null_literal",
-  "epoch_literal",
-  "float_literal",
-  "color_literal",
-  "domain_literal",
-  "email_address_literal",
-  "email_address_full_literal",
-  "email_attachment_literal",
-  "json_literal",
-  "storage_item_literal",
-  "html_literal",
-  "phone_literal",
-  "vector_literal",
-  "icon_literal",
-  "time_literal",
-  "time_zone_literal",
-  "location_literal",
-  "cron_literal",
-  "variable_path_literal",
-  "content_literal",
-  "table_id_for_foreign_row_literal",
-]
-
-export const function_types = {
-  defined_target_literal: {
-    kind: "literal",
-    category: "variables",
-    name: "Defined Target Literal",
-    value: {
-      identifier: null,
-      property_path: [],
-    },
-    node_structure: [[{ ui_type: "input", value: "defined_target_literal" }]],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        identifier: {
-          type: "string",
-        },
-        property_path: {
-          type: "array",
-          minItems: 1,
-          maxItems: 50,
-          items: {
-            anyOf: [
-              {
-                type: "string",
-                pattern: "^[a-z0-9]+(_[a-z0-9]+)*$",
-              },
-              {
-                type: "number",
-              },
-            ],
-          },
-        },
-      },
-    },
-    validator: (input) => {
-      // validate here, made up of identifier_literal values
-    },
-  },
-
-  stack_literal: {
-    kind: "literal",
-    category: "hidden",
-    name: "Stack Literal",
-    child_node_options: [
-      "define",
-      "set_defined",
-      "run_defined",
-      "instantiate_function",
-      "if_then",
-      "if_then_else",
-      "for_loop",
-      "return",
-      "log",
-      "call_endpoint",
-      "cron_job",
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          type: {
-            type: "string",
-          },
-          value: {
-            type: "any",
-          },
-        },
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  function_literal: {
-    kind: "literal",
-    category: "main",
-    name: "Function Literal",
-    fields: {
-      parameters: {
-        node_options: ["parameters_literal"],
-        forced_node: "parameters_literal",
-      },
-      is_do_collapsed: {
-        node_options: ["arrow_toggle_literal", "checkbox_literal"],
-        forced_node: "arrow_toggle_literal",
-      },
-      do: {
-        node_options: ["stack_literal"],
-        forced_node: "stack_literal",
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "field", field: "is_do_collapsed" },
-        { ui_type: "text", value: "function with parameters" },
-        { ui_type: "field", field: "parameters" },
-      ],
-      { ui_type: "stack", field: "do" },
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      default: { parameters: [], is_do_collapsed: false, do: [] },
-      properties: {
-        parameters: {
-          type: "array",
-          items: {
-            type: "object",
-            default: { identifier: null, type: null },
-            properties: {
-              identifier: {
-                type: "string",
-                minLength: 1,
-                maxLength: 50,
-                pattern: "^[a-z0-9]+(_[a-z0-9]+)*$",
-              },
-              type: {
-                type: "string",
-                enum: all_node_types,
-              },
-            },
-          },
-        },
-        is_do_collapsed: {
-          type: "boolean",
-        },
-        do: {
-          type: "array",
-          items: node_json_schema,
-        },
-      },
-      required: ["do"],
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  define: {
-    kind: "definition",
-    category: "variables",
-    name: "Define",
-    fields: {
-      identifier: {
-        node_options: ["identifier_literal", "get_defined"],
-        forced_node: "identifier_literal",
-      },
-      value: {
-        node_options: all_node_types,
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "field", field: "identifier" },
-        { ui_type: "text", value: "=" },
-        { ui_type: "field", field: "value" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        identifier: {
-          type: "string",
-          minLength: 1,
-          maxLength: 50,
-          pattern: "^[a-z0-9]+(_[a-z0-9]+)*$",
-        },
-        value: node_json_schema,
-      },
-      required: ["identifier", "value"],
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  set_defined: {
-    kind: "definition",
-    category: "variables",
-    name: "Set Defined",
-    fields: {
-      defined_target: {
-        node_options: ["defined_target_literal"],
-        forced_node: "defined_target_literal",
-      },
-      value: {
-        node_options: all_node_types,
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "field", field: "defined_target" },
-        { ui_type: "text", value: "=" },
-        { ui_type: "field", field: "value" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        defined_target: {
-          type: "object",
-          properties: {
-            identifier: {
-              type: "string",
-            },
-            property_path: {
-              type: "array",
-              minItems: 1,
-              maxItems: 50,
-              items: {
-                anyOf: [
-                  {
-                    type: "string",
-                    pattern: "^[a-z0-9]+(_[a-z0-9]+)*$",
-                  },
-                  {
-                    type: "number",
-                  },
-                ],
-              },
-            },
-          },
-        },
-        value: node_json_schema,
-      },
-      required: ["defined_target"],
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  get_defined: {
-    kind: "expression",
-    category: "variables",
-    name: "Get Defined",
-    fields: {
-      defined_target: {
-        node_options: ["defined_target_literal"],
-        forced_node: "defined_target_literal",
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "text", value: "value of" },
-        { ui_type: "field", field: "defined_target" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        defined_target: {
-          type: "array",
-          minItems: 1,
-          maxItems: 50,
-          items: {
-            anyOf: [
-              {
-                type: "string",
-                pattern: "^[a-z0-9]+(_[a-z0-9]+)*$",
-              },
-              {
-                type: "number",
-              },
-            ],
-          },
-        },
-      },
-      required: ["defined_target"],
-    },
-    output: {
-      json_schema: {
-        type: "any",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  run_defined: {
-    kind: "expression",
-    category: "variables",
-    name: "Run Defined",
-    fields: {
-      defined_target: {
-        node_options: ["defined_target_literal"],
-        forced_node: "defined_target_literal",
-      },
-      arguments: {
-        node_options: ["arguments_literal"],
-        forced_node: "arguments_literal",
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "text", value: "run" },
-        { ui_type: "field", field: "defined_target" },
-        { ui_type: "text", value: "with arguments" },
-        { ui_type: "field", field: "arguments" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        defined_target: {
-          type: "array",
-          minItems: 1,
-          maxItems: 50,
-          items: {
-            anyOf: [
-              {
-                type: "string",
-                pattern: "^[a-z0-9]+(_[a-z0-9]+)*$",
-              },
-              {
-                type: "number",
-              },
-            ],
-          },
-        },
-        arguments: {
-          type: "array",
-          items: {
-            parameter: {
-              type: "string",
-            },
-            value: {
-              type: "any",
-            },
-          },
-        },
-      },
-      required: ["defined_target"],
-    },
-    output: {
-      json_schema: {
-        type: "any",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  if_then: {
-    kind: "statement",
-    category: "main",
-    name: "If Then",
-    fields: {
-      condition: {
-        node_options: value_node_types,
-      },
-      is_do_collapsed: {
-        node_options: ["arrow_toggle_literal"],
-        forced_node: "arrow_toggle_literal",
-      },
-      do: {
-        node_options: ["stack_literal"],
-        forced_node: "stack_literal",
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "field", field: "is_do_collapsed" },
-        { ui_type: "text", value: "if" },
-        { ui_type: "field", field: "condition" },
-        { ui_type: "text", value: "then" },
-      ],
-      { ui_type: "stack", field: "do" },
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        condition: {
-          type: ["boolean", "number", "string", "epoch", "object", "array"],
-        },
-        passed_do: {
-          type: "array",
-          items: node_json_schema,
-        },
-      },
-      required: ["condition"],
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  if_then_else: {
-    kind: "statement",
-    category: "main",
-    name: "If Then Else",
-    fields: {
-      condition: {
-        node_options: value_node_types,
-      },
-      is_passed_do_collapsed: {
-        node_options: ["arrow_toggle_literal"],
-        forced_node: "arrow_toggle_literal",
-      },
-      passed_do: {
-        node_options: ["stack_literal"],
-        forced_node: "stack_literal",
-      },
-      is_failed_do_collapsed: {
-        node_options: ["arrow_toggle_literal"],
-        forced_node: "arrow_toggle_literal",
-      },
-      failed_do: {
-        node_options: ["stack_literal"],
-        forced_node: "stack_literal",
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "field", field: "is_passed_do_collapsed" },
-        { ui_type: "text", value: "if" },
-        { ui_type: "field", field: "condition" },
-        { ui_type: "text", value: "then" },
-      ],
-      { ui_type: "stack", field: "passed_do" },
-      [
-        { ui_type: "field", field: "is_failed_do_collapsed" },
-        { ui_type: "text", value: "else" },
-      ],
-      { ui_type: "stack", field: "failed_do" },
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        condition: {
-          type: ["boolean", "number", "string", "epoch", "object", "array"],
-        },
-        passed_do: {
-          type: "array",
-          items: node_json_schema,
-        },
-        failed_do: {
-          type: "array",
-          items: node_json_schema,
-        },
-      },
-      required: ["condition"],
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  for_loop: {
-    kind: "statement",
-    category: "main",
-    name: "For Loop",
-    fields: {
-      loop_over: {
-        node_options: ["get_defined", "int_literal"],
-      },
-      iter_item_identifier: {
-        node_options: ["identifier_literal"],
-        forced_node: "identifier_literal",
-      },
-      is_do_collapsed: {
-        node_options: ["arrow_toggle_literal"],
-        forced_node: "arrow_toggle_literal",
-      },
-      do: {
-        node_options: ["stack_literal"],
-        forced_node: "stack_literal",
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "field", field: "is_do_collapsed" },
-        { ui_type: "text", value: "loop over" },
-        { ui_type: "field", field: "loop_over" },
-        { ui_type: "text", value: "as" },
-        { ui_type: "field", field: "iter_item_identifier" },
-      ],
-      { ui_type: "stack", field: "do" },
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        loop_over: {
-          type: ["number", "object", "array"],
-        },
-        iter_item_identifier: {
-          type: "string",
-          minLength: 1,
-          maxLength: 80,
-          pattern: "^[a-z0-9]+(_[a-z0-9]+)*$",
-        },
-        do: {
-          type: "array",
-          items: node_json_schema,
-        },
-      },
-      required: ["loop_over"],
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  return: {
-    kind: "statement",
-    category: "main",
-    name: "Return",
-    fields: {
-      value: {
-        node_options: all_node_types,
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "text", value: "return" },
-        { ui_type: "field", field: "value" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        value: node_json_schema,
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  dropdown_literal: {
-    kind: "statement",
-    category: "main",
-    name: "Dropdown",
-    fields: {
-      type: {
-        node_options: ["dropdown_literal"],
-        forced_node: "dropdown_literal",
-        dropdown_options: [
-          { key: "log", name: "Log" },
-          { key: "warning", name: "Warning" },
-          { key: "error", name: "Error" },
-        ],
-        dropdown_default: "log",
-      },
-      label: {
-        node_options: ["text_literal"],
-        forced_node: "text_literal",
-      },
-      value: {
-        node_options: all_node_types,
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "field", field: "type" },
-        { ui_type: "field", field: "label" },
-        { ui_type: "field", field: "value" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        kind: {
-          type: "string",
-          enum: ["log", "warning", "error"],
-          default: "log",
-        },
-        label: {
-          type: "string",
-        },
-        value: node_json_schema,
-      },
-      required: ["kind", "value"],
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  log: {
-    kind: "statement",
-    category: "main",
-    name: "Log",
-    fields: {
-      type: {
-        node_options: ["dropdown_literal"],
-        forced_node: "dropdown_literal",
-        dropdown_options: [
-          { key: "log", name: "Log" },
-          { key: "warning", name: "Warning" },
-          { key: "error", name: "Error" },
-        ],
-        dropdown_default: "log",
-      },
-      label: {
-        node_options: ["text_literal"],
-        forced_node: "text_literal",
-      },
-      value: {
-        node_options: all_node_types,
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "field", field: "type" },
-        { ui_type: "field", field: "label" },
-        { ui_type: "field", field: "value" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        kind: {
-          type: "string",
-          enum: ["log", "warning", "error"],
-          default: "log",
-        },
-        label: {
-          type: "string",
-        },
-        value: node_json_schema,
-      },
-      required: ["kind", "value"],
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  truthy_compare: {
-    kind: "expression",
-    category: "compare",
-    name: "Truthy Compare",
-    fields: {
-      a: {
-        node_options: all_node_types,
-      },
-      b: {
-        node_options: all_node_types,
-      },
-      operator: {
-        node_options: ["dropdown_literal"],
-        forced_node: "dropdown_literal",
-        dropdown_options: [
-          { key: "logical_or", name: "logical_or (||)" },
-          { key: "nullish_coalescing", name: "nullish_coalescing (??)" },
-          { key: "and", name: "and (&&)" },
-        ],
-        dropdown_default: "and",
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "field", field: "a" },
-        { ui_type: "field", field: "operator" },
-        { ui_type: "field", field: "b" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        a: {
-          type: ["string", "number", "boolean", "object", "array"],
-        },
-        b: {
-          type: ["string", "number", "boolean", "object", "array"],
-        },
-        operator: {
-          type: "string",
-          enum: ["logical_or", "nullish_coalescing", "and"],
-          default: "and",
-        },
-      },
-      required: ["operator"],
-    },
-    output: {
-      json_schema: {
-        type: "boolean_literal",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  arithmetic_binary_operation: {
-    kind: "expression",
-    category: "math",
-    name: "Arithmatic Binary Operator",
-    fields: {
-      a: {
-        node_options: [
-          "get_defined",
-          "arithmetic_binary_operation",
-          "round",
-          "parse",
-          "get_length",
-          "int_literal",
-          "bigint_literal",
-          "float_literal",
-        ],
-      },
-      b: {
-        node_options: [
-          "get_defined",
-          "arithmetic_binary_operation",
-          "round",
-          "parse",
-          "get_length",
-          "int_literal",
-          "bigint_literal",
-          "float_literal",
-        ],
-      },
-      operator: {
-        node_options: ["dropdown_literal"],
-        forced_node: "dropdown_literal",
-        dropdown_options: [
-          { key: "add", name: "addition (+)" },
-          { key: "subtract", name: "subtraction (-)" },
-          { key: "multiply", name: "multiplication (*)" },
-          { key: "divide", name: "division (/)" },
-          { key: "remainder", name: "remainder (%)" },
-          { key: "exponent", name: "exponent (^)" },
-          { key: "min", name: "lowest" },
-          { key: "max", name: "highest" },
-          { key: "rand_value_between", name: "random value between" },
-          { key: "to_precision", name: "round to significant figures" },
-        ],
-        dropdown_default: "add",
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "field", field: "a" },
-        { ui_type: "field", field: "operator" },
-        { ui_type: "field", field: "b" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        a: {
-          type: "number",
-        },
-        b: {
-          type: "number",
-        },
-        operator: {
-          type: "string",
-          enum: [
-            "add",
-            "subtract",
-            "multiply",
-            "divide",
-            "remainder",
-            "exponent",
-            "min",
-            "max",
-            "rand_value_between",
-            "to_precision",
-          ],
-          default: "add",
-        },
-      },
-      required: ["a", "b", "operator"],
-    },
-    output: {
-      json_schema: {
-        type: "number",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  round: {
-    kind: "expression",
-    category: "math",
-    name: "Round",
-    fields: {
-      value: {
-        node_options: [
-          "get_defined",
-          "arithmetic_binary_operation",
-          "round",
-          "parse",
-          "get_length",
-          "int_literal",
-          "bigint_literal",
-          "float_literal",
-        ],
-      },
-      operator: {
-        node_options: ["dropdown_literal"],
-        forced_node: "dropdown_literal",
-        dropdown_options: [
-          { key: "nearest_int", name: "nearest_int" },
-          { key: "floor_int", name: "floor_int" },
-          { key: "ceil_int", name: "ceil_int" },
-          { key: "absolute_value", name: "absolute_value" },
-        ],
-        dropdown_default: "floor_int",
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "field", field: "operator" },
-        { ui_type: "field", field: "value" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        value: {
-          type: "number",
-        },
-        operator: {
-          type: "string",
-          enum: ["nearest_int", "floor_int", "ceil_int", "absolute_value"],
-          default: "floor_int",
-        },
-      },
-      required: ["value", "operator"],
-    },
-    output: {
-      json_schema: {
-        type: "number",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  parse: {
-    kind: "expression",
-    category: "main",
-    name: "Parse",
-    fields: {
-      value: {
-        node_options: ["get_defined", "text_literal"],
-      },
-      operator: {
-        node_options: ["dropdown_literal"],
-        forced_node: "dropdown_literal",
-        dropdown_options: [
-          { key: "to_int", name: "to_int" },
-          { key: "to_float", name: "to_float" },
-          { key: "to_json", name: "to_json" },
-          { key: "to_boolean", name: "to_boolean" },
-        ],
-        dropdown_default: "to_json",
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "field", field: "operator" },
-        { ui_type: "field", field: "value" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        value: {
-          type: "string",
-        },
-        operator: {
-          type: "string",
-          enum: ["to_int", "to_float", "to_object", "to_array", "to_boolean"],
-          default: "to_object",
-        },
-      },
-      required: ["value", "operator"],
-    },
-    output: {
-      json_schema: {
-        type: "any",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  add_item_to_array: {
-    kind: "expression",
-    category: "arrays",
-    name: "Add Item To Array",
-    fields: {
-      array: {
-        node_options: ["get_defined", "empty_array_literal"],
-      },
-      value_to_add: {
-        node_options: all_node_types,
-      },
-      where_to_add: {
-        node_options: ["dropdown_literal"],
-        forced_node: "dropdown_literal",
-        dropdown_options: [
-          { key: "start", name: "start" },
-          { key: "end", name: "end" },
-        ],
-        dropdown_default: "end",
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "text", value: "add" },
-        { ui_type: "field", field: "value_to_add" },
-        { ui_type: "text", value: "to" },
-        { ui_type: "field", field: "array" },
-        { ui_type: "text", value: "at" },
-        { ui_type: "field", field: "where_to_add" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        array: {
-          type: "array",
-          items: {
-            type: "any",
-          },
-        },
-        value_to_add: node_json_schema,
-        where_to_add: {
-          type: "string",
-          enum: ["start", "end"],
-          default: "end",
-        },
-      },
-      required: ["array", "value_to_add", "where_to_add"],
-    },
-    output: {
-      json_schema: {
-        type: "array",
-        items: {
-          type: "any",
-        },
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  add_item_to_array_at_index: {
-    kind: "expression",
-    category: "arrays",
-    name: "Add Item To Array At Index",
-    fields: {
-      array: {
-        node_options: ["get_defined", "empty_array_literal"],
-      },
-      value_to_add: {
-        node_options: all_node_types,
-      },
-      where_to_add: {
-        node_options: ["get_defined", "int_literal"],
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "add" },
-        { ui_type: "field", field: "value_to_add" },
-        { ui_type: "text", value: "to" },
-        { ui_type: "field", field: "array" },
-        { ui_type: "text", value: "at index" },
-        { ui_type: "field", field: "where_to_add" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        array: {
-          type: "array",
-          items: {
-            type: "any",
-          },
-        },
-        value_to_add: node_json_schema,
-        where_to_add: {
-          type: "number",
-        },
-      },
-      required: ["array", "value_to_add", "where_to_add"],
-    },
-    output: {
-      json_schema: {
-        type: "array",
-        items: {
-          type: "any",
-        },
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  remove_item_from_array: {
-    kind: "expression",
-    category: "arrays",
-    name: "Remove Item From Array",
-    fields: {
-      array: {
-        node_options: ["get_defined"],
-        forced_node: "get_defined",
-      },
-      where_to_remove: {
-        node_options: ["dropdown_literal"],
-        forced_node: "dropdown_literal",
-        dropdown_options: [
-          { key: "start", name: "start" },
-          { key: "end", name: "end" },
-        ],
-        dropdown_default: "end",
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "text", value: "remove item from array" },
-        { ui_type: "field", field: "array" },
-        { ui_type: "text", value: "at" },
-        { ui_type: "field", field: "where_to_remove" },
-      ],
-    ],
-    json_schema: {
-      type: "object",
-      properties: {
-        array: {
-          type: "array",
-          items: {
-            type: "any",
-          },
-        },
-        where_to_remove: {
-          type: "string",
-          enum: ["start", "end"],
-          default: "end",
-        },
-      },
-      required: ["array", "where_to_remove"],
-    },
-    output: {
-      json_schema: {
-        type: "array",
-        items: {
-          type: "any",
-        },
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  remove_item_from_array_at_index: {
-    kind: "expression",
-    category: "arrays",
-    name: "Remove Item From Array At Index",
-    fields: {
-      array: {
-        node_options: ["get_defined"],
-        forced_node: "get_defined",
-      },
-      where_to_remove: {
-        node_options: ["get_defined", "int_literal"],
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "remove item from array" },
-        { ui_type: "field", field: "array" },
-        { ui_type: "text", value: "at index" },
-        { ui_type: "field", field: "where_to_remove" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        array: {
-          type: "array",
-          items: {
-            type: "any",
-          },
-        },
-        where_to_remove: {
-          type: "number",
-        },
-      },
-      required: ["array", "where_to_remove"],
-    },
-    output: {
-      json_schema: {
-        type: "array",
-        items: {
-          type: "any",
-        },
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  split_text: {
-    kind: "expression",
-    category: "arrays",
-    name: "Split Text",
-    fields: {
-      text: {
-        node_options: ["text_literal", "get_defined"],
-      },
-      delimiter: {
-        node_options: ["text_literal", "get_defined"],
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "split text" },
-        { ui_type: "field", field: "text" },
-        { ui_type: "text", value: "to array at delimiter" },
-        { ui_type: "field", field: "delimiter" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        text: {
-          type: "string",
-        },
-        delimiter: {
-          type: "string",
-        },
-      },
-      required: ["text", "delimiter"],
-    },
-    output: {
-      json_schema: {
-        type: "array",
-        items: {
-          type: "string",
-        },
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  concat_arrays: {
-    kind: "expression",
-    category: "arrays",
-    name: "Concat Arrays",
-    fields: {
-      first_array: {
-        node_options: [
-          "get_defined",
-          "concat_arrays",
-          "add_item_to_array",
-          "add_item_to_array_at_index",
-          "remove_item_from_array",
-          "remove_item_from_array_at_index",
-        ],
-      },
-      second_array: {
-        node_options: [
-          "get_defined",
-          "concat_arrays",
-          "add_item_to_array",
-          "add_item_to_array_at_index",
-          "remove_item_from_array",
-          "remove_item_from_array_at_index",
-        ],
-      },
-    },
-    postgres_type: "jsonb",
-    node_structure: [
-      [
-        { ui_type: "text", value: "concat arrays" },
-        { ui_type: "field", field: "first_array" },
-        { ui_type: "text", value: "and" },
-        { ui_type: "field", field: "second_array" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        first_array: {
-          type: "array",
-          items: {
-            type: "any",
-          },
-        },
-        second_array: {
-          type: "array",
-          items: {
-            type: "any",
-          },
-        },
-      },
-      required: ["first_array", "second_array"],
-    },
-    output: {
-      json_schema: {
-        type: "array",
-        items: {
-          type: "any",
-        },
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  sort_array: {
-    kind: "expression",
-    category: "arrays",
-    name: "Sort Array",
-    fields: {
-      array: {
-        node_options: [
-          "get_defined",
-          "concat_arrays",
-          "add_item_to_array",
-          "add_item_to_array_at_index",
-          "remove_item_from_array",
-          "remove_item_from_array_at_index",
-        ],
-      },
-      iter_item_a_identifier: {
-        node_options: ["identifier_literal"],
-        forced_node: "identifier_literal",
-      },
-      iter_item_b_identifier: {
-        node_options: ["identifier_literal"],
-        forced_node: "identifier_literal",
-      },
-      do: {
-        node_options: ["stack_literal"],
-        forced_node: "stack_literal",
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "sort array" },
-        { ui_type: "field", field: "array" },
-        { ui_type: "text", value: "with item identifiers" },
-        { ui_type: "field", field: "iter_item_a_identifier" },
-        { ui_type: "field", field: "iter_item_b_identifier" },
-      ],
-      { ui_type: "stack", field: "do" },
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        array: {
-          type: "array",
-          items: {
-            type: "any",
-          },
-        },
-        iter_item_a_identifier: {
-          type: "string",
-        },
-        iter_item_b_identifier: {
-          type: "string",
-        },
-        do: {
-          type: "array",
-          items: {
-            type: "node",
-          },
-        },
-      },
-      required: ["array", "do"],
-    },
-    output: {
-      json_schema: {
-        type: "array",
-        items: {
-          type: "any",
-        },
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  local_compare: {
-    kind: "expression",
-    category: "arrays",
-    name: "Alphabetically Compare",
-    fields: {
-      a: {
-        node_options: ["text_literal", "get_defined"],
-      },
-      b: {
-        node_options: ["text_literal", "get_defined"],
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "alphabetically compare" },
-        { ui_type: "field", field: "a" },
-        { ui_type: "text", value: "to" },
-        { ui_type: "field", field: "b" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        a: {
-          type: "string",
-        },
-        b: {
-          type: "string",
-        },
-      },
-      required: ["a", "b"],
-    },
-    output: {
-      json_schema: {
-        type: "boolean",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  slice: {
-    kind: "expression",
-    category: "arrays",
-    name: "Slice",
-    fields: {
-      value: {
-        node_options: ["get_defined"],
-        forced_node: "get_defined",
-      },
-      start_index: {
-        node_options: ["int_literal", "get_defined"],
-      },
-      end_index: {
-        node_options: ["int_literal", "get_defined"],
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "slice" },
-        { ui_type: "field", field: "value" },
-        { ui_type: "text", value: "from" },
-        { ui_type: "field", field: "start_index" },
-        { ui_type: "text", value: "to" },
-        { ui_type: "field", field: "end_index" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        value: {
-          type: ["array", "string"],
-        },
-        start_index: {
-          type: "number",
-        },
-        end_index: {
-          type: "number",
-        },
-      },
-      required: ["value", "start_index", "end_index"],
-    },
-    output: {
-      json_schema: {
-        type: "array",
-        items: {
-          type: "any",
-        },
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  join_array_of_text_items: {
-    kind: "expression",
-    category: "arrays",
-    name: "Join Array Of Text Items",
-    fields: {
-      array: {
-        node_options: ["get_defined"],
-        forced_node: "get_defined",
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "join array of text" },
-        { ui_type: "field", field: "array" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        array: {
-          type: "array",
-          items: {
-            type: "any",
-          },
-        },
-      },
-      required: ["array"],
-    },
-    output: {
-      json_schema: {
-        type: "string",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  reverse_array: {
-    kind: "expression",
-    category: "arrays",
-    name: "Reverse Array",
-    fields: {
-      array: {
-        node_options: ["get_defined"],
-        forced_node: "get_defined",
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "reverse array" },
-        { ui_type: "field", field: "array" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        array: {
-          type: "array",
-          items: {
-            type: "any",
-          },
-        },
-      },
-      required: ["array"],
-    },
-    output: {
-      json_schema: {
-        type: "array",
-        items: {
-          type: "any",
-        },
-      },
-    },
-    validator: (input) => {
-      // validate here
+      locality: { type: "string" },
+      sub_locality: { type: "string" },
+      full_thoroughfare: { type: "string" },
     },
+    required: ["latitude", "longitude", "name"],
+    additionalProperties: false,
   },
-
-  average_of_number_array: {
-    kind: "expression",
-    category: "arrays",
-    name: "Average Of Number Array",
-    fields: {
-      array: {
-        node_options: ["get_defined"],
-        forced_node: "get_defined",
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "average of numbers in" },
-        { ui_type: "field", field: "array" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        array: {
-          type: "array",
-          items: {
-            type: "number",
-          },
-        },
-      },
-      required: ["array"],
-    },
-    output: {
-      json_schema: {
-        type: "number",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
+  validator: (input) => {
+    // validate here
   },
-
-  sum_of_number_array: {
-    kind: "expression",
-    category: "arrays",
-    name: "Sum Of Number Array",
-    fields: {
-      array: {
-        node_options: ["get_defined"],
-        forced_node: "get_defined",
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "sum of numbers in" },
-        { ui_type: "field", field: "array" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        array: {
-          type: "array",
-          items: {
-            type: "number",
-          },
-        },
-      },
-      required: ["array"],
-    },
-    output: {
-      json_schema: {
-        type: "number",
-      },
-    },
-    validator: (input) => {
-      // validate here
+}
+const cron_literal = {
+  kind: "literal",
+  category: "variables",
+  name: "Cron",
+  postgres_type: "jsonb",
+  json_schema: {
+    type: "object",
+    properties: {
+      content: { type: "string" },
+      cron: { type: "string" },
+      minute: { type: "string" },
+      hour: { type: "string" },
+      day_of_month: { type: "string" },
+      month: { type: "string" },
+      day_of_week: { type: "string" },
     },
+    additionalProperties: false,
+    required: [],
   },
-
-  trim_text: {
-    kind: "expression",
-    category: "operation",
-    name: "Trim Text",
-    fields: {
-      text: {
-        node_options: ["get_defined"],
-        forced_node: "get_defined",
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "trim" },
-        { ui_type: "field", field: "text" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        text: {
-          type: "string",
-        },
-      },
-      required: ["text"],
-    },
-    output: {
-      json_schema: {
-        type: "string",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
+  validator: (input) => {
+    // validate here
   },
-
-  replace_text: {
-    kind: "expression",
-    category: "operation",
-    name: "Replace Text",
-    fields: {
-      base_text: {
-        node_options: ["text_literal", "get_defined"],
-      },
-      text_to_replace: {
-        node_options: ["text_literal", "get_defined"],
-      },
-      replacement_text: {
-        node_options: ["text_literal", "get_defined"],
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "from base text" },
-        { ui_type: "field", field: "base_text" },
-        { ui_type: "text", value: "replace" },
-        { ui_type: "field", field: "text_to_replace" },
-        { ui_type: "text", value: "with" },
-        { ui_type: "field", field: "replacement_text" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        base_text: {
-          type: "string",
-        },
-        text_to_replace: {
-          type: "string",
-        },
-        replacement_text: {
+}
+const variable_path_literal = {
+  kind: "literal",
+  category: "variables",
+  name: "Variable Path",
+  postgres_type: "jsonb",
+  json_schema: {
+    type: "array",
+    description: "The path to the value within variables.",
+    items: {
+      anyOf: [
+        {
           type: "string",
         },
-      },
-      required: ["base_text", "text_to_replace", "replacement_text"],
-    },
-    output: {
-      json_schema: {
-        type: "string",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  compare_numbers: {
-    kind: "expression",
-    category: "compare",
-    name: "Compare Numbers",
-    fields: {
-      a: {
-        node_options: [
-          "get_defined",
-          "arithmetic_binary_operation",
-          "round",
-          "parse",
-          "get_length",
-          "int_literal",
-          "bigint_literal",
-          "float_literal",
-        ],
-      },
-      b: {
-        node_options: [
-          "get_defined",
-          "arithmetic_binary_operation",
-          "round",
-          "parse",
-          "get_length",
-          "int_literal",
-          "bigint_literal",
-          "float_literal",
-        ],
-      },
-      operator: {
-        node_options: ["dropdown_literal"],
-        forced_node: "dropdown_literal",
-        dropdown_options: [
-          { key: "less_than", name: "less than (<)" },
-          { key: "less_than_or_equal", name: "less than or equal to (<=)" },
-          { key: "greater_than", name: "greater than (>)" },
-          { key: "greater_than_or_equal", name: "greater than or equal to (>=)" },
-          { key: "equal_to", name: "equals (==)" },
-          { key: "not_equal_to", name: "not equal to (!=)" },
-        ],
-        dropdown_default: "less_than",
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "field", field: "a" },
-        { ui_type: "field", field: "operator" },
-        { ui_type: "field", field: "b" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        a: {
-          type: "number",
-        },
-        b: {
+        {
           type: "number",
         },
-        operator: {
-          type: "string",
-          enum: [
-            "less_than",
-            "less_than_or_equal",
-            "greater_than",
-            "greater_than_or_equal",
-            "equal_to",
-            "not_equal_to",
-          ],
-          default: "less_than",
-        },
-      },
-      required: ["a", "b", "operator"],
-    },
-    output: {
-      json_schema: {
-        type: "boolean",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  compare_text: {
-    kind: "expression",
-    category: "compare",
-    name: "Compare Text",
-    fields: {
-      a: {
-        node_options: ["get_defined", "text_literal"],
-      },
-      b: {
-        node_options: ["get_defined", "text_literal"],
-      },
-      operator: {
-        node_options: ["dropdown_literal"],
-        forced_node: "dropdown_literal",
-        dropdown_options: [
-          { key: "equal_to", name: "equals (==)" },
-          { key: "not_equal_to", name: "not equal to (!=)" },
-          { key: "contains", name: "contains" },
-          { key: "does_not_contain", name: "does not contain" },
-          { key: "starts_with", name: "starts with" },
-          { key: "ends_with", name: "ends with" },
-        ],
-        dropdown_default: "starts_with",
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "field", field: "a" },
-        { ui_type: "field", field: "operator" },
-        { ui_type: "field", field: "b" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        a: {
-          type: "text",
-        },
-        b: {
-          type: "text",
-        },
-        operator: {
-          type: "string",
-          enum: ["equal_to", "not_equal_to", "contains", "does_not_contain", "starts_with", "ends_with"],
-          default: "starts_with",
+        {
+          type: "array",
+          items: {
+            anyOf: [
+              {
+                type: "string",
+              },
+              {
+                type: "number",
+              },
+            ],
+          },
         },
-      },
-      required: ["a", "b", "operator"],
-    },
-    output: {
-      json_schema: {
-        type: "boolean",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
-  },
-
-  get_length: {
-    kind: "expression",
-    category: "math",
-    name: "Get Length",
-    fields: {
-      value: {
-        node_options: ["get_defined", "text_literal"], // array types
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "length of" },
-        { ui_type: "field", field: "value" },
       ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        value: {
-          type: ["array", "object", "text"],
-        },
-      },
-      required: ["value"],
-    },
-    output: {
-      json_schema: {
-        type: "number",
-      },
-    },
-    validator: (input) => {
-      // validate here
     },
   },
-
-  object_expression: {
-    kind: "expression",
-    category: "variables",
-    name: "Object Expression",
-    fields: {
-      value: {
-        node_options: ["object_builder"],
-        forced_node: "object_builder",
-      },
-    },
-    node_structure: [
-      [{ ui_type: "text", value: "build object" }, { ui_type: "br" }, { ui_type: "field", field: "value" }],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          key: {
-            type: "string",
-            node_options: ["text_literal", "get_defined"],
-          },
-          value: {
-            type: "any",
-            node_options: [...value_node_types],
-          },
-        },
-      },
-    },
-    output: {
-      json_schema: {
-        type: "object",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
+  validator: (input) => {
+    // validate here
   },
-
-  call_endpoint: {
-    kind: "expression",
-    category: "actions",
-    name: "Call Endpoint",
-    fields: {
-      endpoint: {
-        node_options: ["get_defined", "text_literal"],
-      },
-      headers: {
-        node_options: ["object_literal", "get_defined"],
-      },
-      body: {
-        node_options: ["object_literal", "get_defined"],
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "call endpoint" },
-        { ui_type: "br" },
-        { ui_type: "field", field: "endpoint" },
-        { ui_type: "br" },
-        { ui_type: "text", value: "with headers" },
-        { ui_type: "br" },
-        { ui_type: "field", field: "headers" },
-        { ui_type: "br" },
-        { ui_type: "text", value: "and body" },
-        { ui_type: "br" },
-        { ui_type: "field", field: "body" },
-      ],
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        endpoint: { type: "string" },
-        headers: { type: "object" },
-        body: { type: "object" },
-      },
-      required: ["endpoint"],
-    },
-    output: {
-      json_schema: {
-        type: "object",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
+}
+const content_literal = {
+  kind: "literal",
+  category: "variables",
+  name: "Content",
+  postgres_type: "jsonb",
+  // json_schema: get_content_node_json_schema("content_literal"),
+  validator: (input) => {
+    // validate here
   },
-
-  cron_job: {
-    kind: "expression",
-    category: "triggers",
-    name: "Cron Job",
-    fields: {
-      cron: {
-        node_options: ["cron_literal"],
-        forced_node: "cron_literal",
-      },
-      do: {
-        node_options: ["stack_literal"],
-        forced_node: "stack_literal",
-      },
-    },
-    node_structure: [
-      [
-        { ui_type: "text", value: "cron" },
-        { ui_type: "field", field: "cron" },
-      ],
-      { ui_type: "stack", field: "do" },
-    ],
-    postgres_type: "jsonb",
-    json_schema: {
-      type: "object",
-      properties: {
-        cron: { type: "string" },
-        do: {
-          type: "array",
-          items: node_json_schema,
-        },
-      },
-      required: ["cron", "do"],
-    },
-    output: {
-      json_schema: {
-        type: "object",
-      },
-    },
-    validator: (input) => {
-      // validate here
-    },
+}
+const table_id_for_foreign_row_literal = {
+  kind: "literal",
+  category: "variables",
+  name: "Table ID for Foreign Row",
+  postgres_type: "text",
+  // json_schema: get_content_node_json_schema("content_literal"),
+  validator: (input) => {
+    // validate here
   },
 }
+// image_literal
+// audio_literal
+// file_literal
+// dropdown_literal
+// text_array_literal
+// function_literal
 
 export const literal_types = {
   array_literal,
@@ -4139,7 +2007,6 @@ export const content_types = {
 export const node_types = {
   ...literal_types,
   ...content_types,
-  ...function_types,
 }
 
 function get_content_node_json_schema(type_id) {
@@ -4606,33 +2473,6 @@ function find_match(match_for, value) {
   return false
 }
 
-// function is_pass_predicate(predicate, value, check_value) {
-//   switch (predicate) {
-//     case "equal_to":
-//       return check_value === value
-//     case "not_equal_to":
-//       return check_value !== value
-//     case "less_than":
-//       return check_value < value
-//     case "less_than_or_equal":
-//       return check_value <= value
-//     case "greater_than":
-//       return check_value > value
-//     case "greater_than_or_equal":
-//       return check_value >= value
-//     case "contains":
-//       return check_value.includes(value)
-//     case "does_not_contain":
-//       return !check_value.includes(value)
-//     case "starts_with":
-//       return check_value.startsWith(value)
-//     case "ends_with":
-//       return check_value.endsWith(value)
-//     default:
-//       return false
-//   }
-// }
-
 // const override_base = {
 //   options: {
 //     color: null,