Element Catalog

ui.Accordion(
    sections=[
        {
            "title": "Section one",
            "content": ui.Text(content="Body one"),
        },
        {
            "title": "Section two",
            "content": ui.Text(content="Body two"),
        },
    ],
)

ui.Alert(
    type="info",
    title="Heads up",
    message="This is an alert message.",
)

ui.Audio(
    src="https://www.w3schools.com/html/horse.mp3",
    title="Sample audio",
    controls=True,
)

ui.Avatar(fallback="AI", size="md")

ui.Badge(label="New", color="blue")

ui.Button(label="Click me", variant="primary")

ui.Call(function="save_note")

ui.Card(
    title="Card title",
    subtitle="Subtitle",
    content=ui.Text(content="Card body content."),
)

ui.Chart(
    type="line",
    x_key="label",
    data=[
        {
            "label": "Mon",
            "value": 3,
        },
        {
            "label": "Tue",
            "value": 7,
        },
        {
            "label": "Wed",
            "value": 5,
        },
    ],
)

ui.Checkbox(
    label="Email me deploy results",
    value=True,
    description="One message per finished deploy.",
    param_name="notify",
)

ui.Code(language="python", content="def hello():\n    print('hi')")

ui.Column(
    children=[
        ui.Text(content="Row A"),
        ui.Text(content="Row B"),
    ],
    direction="column",
)

ui.DataColumn(key="last_sync", label="Save", sortable=True, width="width")

ui.DataTable(
    columns=[
        {
            "key": "name",
            "label": "Name",
        },
        {
            "key": "role",
            "label": "Role",
        },
    ],
    rows=[
        {
            "name": "Ada",
            "role": "Admin",
        },
        {
            "name": "Linus",
            "role": "Dev",
        },
    ],
)

ui.DatePicker(placeholder="Pick a date", value="2026-06-21")

ui.Dialog(
    title="Confirm action",
    content="Are you sure?",
    confirm_label="Yes",
    cancel_label="No",
)

ui.Divider(label="Section")

ui.Empty(message="Nothing here yet", icon="Inbox")

ui.Error(title="Something went wrong", message="Could not load data.")

ui.FileUpload(accept="image/*", max_size_mb=5)

ui.Form(
    submit_label="Save",
    action="#",
    children=[
        ui.Input(
            label="Email",
            placeholder="you@example.com",
            param_name="email",
        ),
    ],
)

ui.Graph(
    nodes=[
        {
            "id": "a",
            "label": "A",
        },
        {
            "id": "b",
            "label": "B",
        },
        {
            "id": "c",
            "label": "C",
        },
    ],
    edges=[
        {
            "source": "a",
            "target": "b",
        },
        {
            "source": "b",
            "target": "c",
        },
    ],
)

ui.Grid(
    columns=2,
    children=[
        ui.Card(title="One"),
        ui.Card(title="Two"),
    ],
)

ui.Header(text="Section heading", level=2, subtitle="A subtitle")

ui.Html(content="<p style='margin:0'>Inline <b>HTML</b> content.</p>")

ui.Icon(name="Star", size=24)

ui.Image(
    src="https://placehold.co/200x120",
    alt="Sample",
    width=200,
    height=120,
    caption="A caption",
)

ui.Input(placeholder="Type here…", value="Hello", param_name="demo")

ui.KeyValue(
    items=[
        {
            "key": "Status",
            "value": "Active",
        },
        {
            "key": "Plan",
            "value": "Pro",
        },
    ],
)

ui.Link(label="Imperal docs", href="https://docs.imperal.io")

ui.List(
    items=[
        {
            "id": "1",
            "title": "First item",
            "subtitle": "A subtitle",
        },
        {
            "id": "2",
            "title": "Second item",
        },
        {
            "id": "3",
            "title": "Third item",
        },
    ],
)

ui.ListItem(
    id="note_1042",
    title="Invoice #1042",
    subtitle="subtitle",
    meta="meta",
)

ui.Loading(message="Loading…")

ui.Markdown(
    content="# Title\n\nSome **markdown** with a [link](https://imperal.io) and `code`.",
)

ui.Menu(
    items=[
        {
            "label": "Edit",
        },
        {
            "label": "Duplicate",
        },
        {
            "label": "Delete",
        },
    ],
)

ui.Modal(
    title="Delete project?",
    subtitle="This cannot be undone.",
    content=ui.Text(content="The project and all of its deployments are removed."),
    confirm_label="Delete",
    cancel_label="Cancel",
    destructive=True,
)

ui.MultiSelect(
    placeholder="Pick tags",
    options=[
        {
            "label": "Alpha",
            "value": "a",
        },
        {
            "label": "Beta",
            "value": "b",
        },
    ],
    values=[
        "a",
    ],
)

ui.Navigate(path="/billing")

ui.Open(url="https://api.example.com/orders")

ui.Page(
    title="Page title",
    subtitle="Subtitle",
    children=[
        ui.Text(content="Page content."),
    ],
)

ui.Password(placeholder="••••••", param_name="pwd", type="password")

ui.Progress(value=64, label="Uploading", variant="primary")

ui.RadioGroup(
    label="Billing cycle",
    value="monthly",
    param_name="cycle",
    options=[
        {
            "label": "Monthly",
            "value": "monthly",
        },
        {
            "label": "Yearly (2 months free)",
            "value": "yearly",
        },
    ],
)

ui.RichEditor(
    content="<p>Rich <b>text</b> editor.</p>",
    placeholder="Write…",
)

ui.Row(
    children=[
        ui.Badge(label="A"),
        ui.Badge(label="B"),
    ],
    direction="row",
)

ui.Section(
    title="Section",
    children=[
        ui.Text(content="Section content."),
    ],
)

ui.Select(
    placeholder="Choose one",
    value="1",
    options=[
        {
            "label": "One",
            "value": "1",
        },
        {
            "label": "Two",
            "value": "2",
        },
    ],
)

ui.Send(message="Deploy finished.")

ui.SlideOver(
    title="Slide over",
    open=True,
    children=[
        ui.Text(content="Slide-over content."),
    ],
)

ui.Slider(min=0, max=100, value=40, step=1, label="Volume")

ui.Stack(
    direction="row",
    gap=2,
    children=[
        ui.Badge(label="A"),
        ui.Badge(label="B"),
    ],
)

ui.Stat(label="Active users", value="1,284", trend="+12%")

ui.Stats(
    columns=2,
    children=[
        ui.Stat(label="Users", value="1.2k"),
        ui.Stat(label="Revenue", value="$8.4k"),
    ],
)

ui.Tabs(
    tabs=[
        {
            "label": "Overview",
            "content": ui.Text(content="First tab."),
        },
        {
            "label": "Details",
            "content": ui.Text(content="Second tab."),
        },
    ],
)

ui.TagInput(
    placeholder="Add tags…",
    values=[
        "alpha",
        "beta",
    ],
)

ui.Text(content="Example text.", variant="body")

ui.TextArea(
    placeholder="Write something…",
    value="Multiline\ntext",
    rows=3,
)

ui.theme(ctx="ctx")

ui.Timeline(
    items=[
        {
            "title": "Created",
            "description": "09:00",
        },
        {
            "title": "Updated",
            "description": "10:30",
        },
    ],
)

ui.Toast(
    title="Deploy queued",
    message="Building imperal-panel #482.",
    variant="success",
)

ui.Toggle(label="Enabled", value=True)

ui.Tooltip(
    content="Tooltip text",
    children=[
        ui.Button(label="Hover me"),
    ],
)

ui.TrayResponse(badge="badge", panel="panel")

ui.Tree(
    nodes=[
        {
            "label": "root",
            "children": [
                {
                    "label": "child A",
                },
                {
                    "label": "child B",
                },
            ],
        },
    ],
)

ui.Video(
    src="https://www.w3schools.com/html/mov_bbb.mp4",
    controls=True,
    width=240,
)

@chat.function(
    name="send_invoice",
    description="Send the invoice for one order to the customer.",
    params={},
)
async def send_invoice(ctx):
    ...

@ext.cache_model(name="send_invoice")
async def send_invoice(ctx):
    ...

@ext.emits(event_type="order.created", schema_ref="note.v1")
async def emits(ctx):
    ...

@ext.file_sink(tool="upload_report", accepts=[], arg="arg", arg_kind="text")
async def file_sink(ctx):
    ...

@ext.lifecycle
async def lifecycle(ctx):
    ...

@ext.oauth(provider="google", collection="notes")
async def oauth(ctx):
    ...

@ext.on_upgrade(version="1.4.0")
async def on_upgrade(ctx):
    ...

@ext.panel(panel_id="panel_1042", slot="center")
async def panel(ctx):
    ...

@ext.secret(
    name="send_invoice",
    description="Send the invoice for one order to the customer.",
    required=True,
)
async def send_invoice(ctx):
    ...

@ext.skeleton(section_name="section", alert=True)
async def skeleton(ctx):
    ...

@ext.tool(name="send_invoice", scopes=[])
async def send_invoice(ctx):
    ...

@ext.tray(tray_id="inbox", icon="Circle")
async def tray(ctx):
    ...

@ext.webhook(path="/billing", method="POST")
async def webhook(ctx):
    ...

@ext.widget(widget_id="widget_1042", slot="dashboard.stats")
async def widget(ctx):
    ...

class Record(sdl.Entity, sdl.AccessLeveled):
    """Gains:
      access_visibility,
      classification,
      clearance_required,
      handling_caveats,
    """

class Record(sdl.Entity, sdl.ActivityMetrics):
    """Gains:
      active_calories_kcal,
      active_minutes,
      activity_distance_m,
      floors_climbed,
      … 1 more
    """

class Record(sdl.Entity, sdl.ActuatorState):
    """Gains:
      actuator_color_hex,
      actuator_position,
      color_temp_k,
      level_pct,
      … 3 more
    """

class Record(sdl.Entity, sdl.AdminRegion):
    """Gains: continent, country_code, county, locality, …"""

class Record(sdl.Entity, sdl.AdmissionPolicy):
    """Gains: doors_open_at, dress_code, min_age, prohibited_items, …"""

class Record(sdl.Entity, sdl.AgendaSlot):
    """Gains: order_index, parent_event, session_type, speakers, …"""

class Record(sdl.Entity, sdl.Aggregated):
    """Gains: aggregation, fill_policy, granularity, window_end, …"""

class Record(sdl.Entity, sdl.AIProvenance):
    """Gains: ai_confidence, ai_model, generated_by_ai, prompt_ref, …"""

class Record(sdl.Entity, sdl.Alertable):
    """Gains: alert_severity, alert_state, alert_threshold, fired_at, …"""

class Record(sdl.Entity, sdl.Angle):
    """Gains: angle_deg, angle_unit"""

class Record(sdl.Entity, sdl.ApiEndpoint):
    """Gains: api_path, auth_required, deprecated, method, …"""

class Record(sdl.Entity, sdl.Approvable):
    """Gains: approval_status, approver, decided_at, decision_note"""

class Record(sdl.Entity, sdl.Archive):
    """Gains:
      archive_format,
      compression_ratio,
      entry_count,
      is_encrypted,
      … 1 more
    """

class Record(sdl.Entity, sdl.Area):
    """Gains: area_m2, area_unit"""

class Record(sdl.Entity, sdl.Assignable):
    """Gains: assigned_at, assignee, assignees, delegated_by, …"""

class Record(sdl.Entity, sdl.Attached):
    """Gains:
      attachment_count,
      attachments,
      has_attachments,
      inline_images,
    """

class Record(sdl.Entity, sdl.Attested):
    """Gains:
      attestation_confidence,
      attestation_result,
      attestation_type,
      attested_by,
    """

class Record(sdl.Entity, sdl.AudioTrack):
    """Gains: audio_codec, bit_depth, bitrate_kbps, channels, …"""

class Record(sdl.Entity, sdl.Auditable):
    """Gains: action, actor, audit_target, changes, …"""

class Record(sdl.Entity, sdl.Authorship):
    """Gains: author, contributors, creator, editors, …"""

class Record(sdl.Entity, sdl.Backup):
    """Gains:
      backup_is_verified,
      backup_kind,
      backup_size_bytes,
      retain_until,
      … 3 more
    """

class Record(sdl.Entity, sdl.Balanced):
    """Gains:
      available_balance,
      balance,
      balance_currency,
      credit_limit,
      … 1 more
    """

class Record(sdl.Entity, sdl.Biometric):
    """Gains:
      biometric_context,
      biometric_measured_at,
      biometric_type,
      biometric_unit,
      … 3 more
    """

class Record(sdl.Entity, sdl.Bitrate):
    """Gains: bitrate_bps, bitrate_unit"""

class Record(sdl.Entity, sdl.Blockable):
    """Gains: blocked_reason, blocked_since, is_blocked, waiting_on"""

class Record(sdl.Entity, sdl.Boarded):
    """Gains: board, column, position, swimlane"""

class Record(sdl.Entity, sdl.Bodied):
    """Gains: body, body_format, raw_body"""

class Record(sdl.Entity, sdl.BodyComposition):
    """Gains: bmi, body_fat_pct, body_measured_at, body_weight_kg, …"""

class Record(sdl.Entity, sdl.Booked):
    """Gains:
      booked_at,
      cancellation_deadline,
      cancelled_at,
      check_in_at,
      … 1 more
    """

class Record(sdl.Entity, sdl.BoundingBox):
    """Gains: max_lat, max_lon, min_lat, min_lon"""

class Record(sdl.Entity, sdl.Branded):
    """Gains: brand, country_of_origin, manufacturer, model_name, …"""

class Record(sdl.Entity, sdl.Bundle):
    """Gains: bundle_items, bundle_type, is_bundle"""

class Record(sdl.Entity, sdl.CalendarFeed):
    """Gains: calendar_color, calendar_name, feed_url, ical_uid, …"""

class Record(sdl.Entity, sdl.Callable):
    """Gains: answered, call_direction, call_state, call_type, …"""

class Record(sdl.Entity, sdl.Cancellation):
    """Gains: is_cancelled, is_refundable, refund_deadline, refund_policy"""

class Record(sdl.Entity, sdl.Capacity):
    """Gains:
      capacity_remaining,
      capacity_total,
      is_sold_out,
      registered_count,
      … 1 more
    """

class Record(sdl.Entity, sdl.Caseable):
    """Gains: case_number, case_resolution, case_stage, case_type, …"""

class Record(sdl.Entity, sdl.Categorized):
    """Gains: categories, keywords, labels, tags, …"""

class Record(sdl.Entity, sdl.Certificated):
    """Gains: cert_is_valid, cert_issuer, cert_subject, fingerprint, …"""

class Record(sdl.Entity, sdl.Checklist):
    """Gains: checked_count, checklist_items, checklist_total"""

class Record(sdl.Entity, sdl.ColorMaterial):
    """Gains: color, finish, material, material_color_hex, …"""

class Record(sdl.Entity, sdl.Completable):
    """Gains: completed_at, completed_by, is_done, resolution"""

class Record(sdl.Entity, sdl.Compliant):
    """Gains: assessed_by, compliance_status, control_id, framework, …"""

class Record(sdl.Entity, sdl.ComputeSpec):
    """Gains: arch, disk_bytes, gpu_count, memory_bytes, …"""

class Record(sdl.Entity, sdl.Confident):
    """Gains: ci_lower, ci_upper, confidence_level, is_significant, …"""

class Record(sdl.Entity, sdl.ConfigSetting):
    """Gains:
      config_key,
      config_source,
      config_value,
      config_value_type,
      … 2 more
    """

class Record(sdl.Entity, sdl.Consented):
    """Gains:
      consent_proof,
      consent_purpose,
      consent_state,
      consent_subject,
      … 2 more
    """

class Record(sdl.Entity, sdl.Consumable):
    """Gains: consumable_type, low, remaining_pct, replace_after_at"""

class Record(sdl.Entity, sdl.ContactPoints):
    """Gains: emails, phones, preferred_channel, social_handles, …"""

class Record(sdl.Entity, sdl.Container):
    """Gains: compose_project, container_id, container_name, image, …"""

class Record(sdl.Entity, sdl.ContentSafety):
    """Gains: is_nsfw, moderation_labels, scan_state, scanned_at, …"""

class Record(sdl.Entity, sdl.Conversational):
    """Gains:
      channel_name,
      conversation_participant_count,
      conversation_ref,
      conversation_type,
      … 3 more
    """

class Record(sdl.Entity, sdl.Correspondents):
    """Gains:
      recipient_count,
      recipients_bcc,
      recipients_cc,
      recipients_to,
      … 2 more
    """

class Record(sdl.Entity, sdl.DataRecord):
    """Gains: query, row_id, schema_ref, table"""

class Record(sdl.Entity, sdl.DataSize):
    """Gains: bytes, data_size_unit"""

class Record(sdl.Entity, sdl.Dependencies):
    """Gains: blocked_by, blocks, related"""

class Record(sdl.Entity, sdl.DeviceIdentity):
    """Gains:
      device_id,
      device_manufacturer,
      device_model,
      firmware_version,
      … 1 more
    """

class Record(sdl.Entity, sdl.DeviceState):
    """Gains: battery_pct, device_last_seen_at, online, signal_strength"""

class Record(sdl.Entity, sdl.Dimensioned):
    """Gains: dimensions"""

class Record(sdl.Entity, sdl.Dimensions3D):
    """Gains: dim_depth, dim_height, dim_unit, dim_width"""

class Record(sdl.Entity, sdl.Discountable):
    """Gains: discount_pct, is_on_sale, sale_price"""

class Record(sdl.Entity, sdl.Draftable):
    """Gains:
      is_auto_generated,
      is_draft,
      last_saved_at,
      scheduled_send_at,
    """

class Record(sdl.Entity, sdl.Duration):
    """Gains: duration_display_unit, duration_s"""

class Record(sdl.Entity, sdl.Editorial):
    """Gains:
      editorial_is_draft,
      editorial_state,
      first_published_at,
      published_at,
    """

class Record(sdl.Entity, sdl.Entity):
    """Gains: description, id, kind, status, …"""

class Record(sdl.Entity, sdl.EntityList):
    """Gains: """

class Record(sdl.Entity, sdl.Estimable):
    """Gains: estimate_s, remaining_s, spent_s"""

class Record(sdl.Entity, sdl.Eventful):
    """Gains: event_host, event_organizer, event_type, venue"""

class Record(sdl.Entity, sdl.Excerptable):
    """Gains: excerpt, reading_time_s, summary, word_count"""

class Record(sdl.Entity, sdl.FileObject):
    """Gains: checksum_sha256, extension, filename, media_class, …"""

class Record(sdl.Entity, sdl.Geofence):
    """Gains: center_lat, center_lon, dwell_s, radius_m, …"""

class Record(sdl.Entity, sdl.Geolocated):
    """Gains: accuracy_m, altitude_m, geo_speed_mps, heading_deg, …"""

class Record(sdl.Entity, sdl.HostResource):
    """Gains: environment, host_region, hostname, resource_id"""

class Record(sdl.Entity, sdl.Iconified):
    """Gains: avatar_url, color_hex, emoji, icon"""

class Record(sdl.Entity, sdl.ImageMedia):
    """Gains: blurhash, color_space, exif, height, …"""

class Record(sdl.Entity, sdl.Inventory):
    """Gains: availability, backorderable, in_stock, is_low_stock, …"""

class Record(sdl.Entity, sdl.Invoiced):
    """Gains: invoice_due_at, invoice_number, paid_at, payment_status, …"""

class Record(sdl.Entity, sdl.Length):
    """Gains: length_m, length_unit"""

class Record(sdl.Entity, sdl.Lifecycle):
    """Gains: is_archived, is_deleted, is_favorite, is_pinned, …"""

class Record(sdl.Entity, sdl.Localized):
    """Gains: available_locales, language, languages, locale, …"""

class Record(sdl.Entity, sdl.Measured):
    """Gains: dimension, formatted_value, uncertainty, unit, …"""

class Record(sdl.Entity, sdl.MessageState):
    """Gains: delivery_state, direction, edited_at, is_from_me, …"""

class Record(sdl.Entity, sdl.Monetary):
    """Gains: amount, currency"""

class Record(sdl.Entity, sdl.NetAsset):
    """Gains: domain, ip, port, protocol, …"""

class Record(sdl.Entity, sdl.Participants):
    """Gains: active_now, admins, host, join_state, …"""

class Record(sdl.Entity, sdl.Percentage):
    """Gains: percent"""

class Record(sdl.Entity, sdl.Permissioned):
    """Gains: can_delete, can_read, can_share, can_write, …"""

class Record(sdl.Entity, sdl.Placed):
    """Gains: place_name, place_type, plus_code"""

class Record(sdl.Entity, sdl.PostalAddress):
    """Gains: city, country, postal_code, region, …"""

class Record(sdl.Entity, sdl.Presence):
    """Gains: active_until, last_seen_at, online_status, status_emoji, …"""

class Record(sdl.Entity, sdl.Priced):
    """Gains:
      compare_at_price,
      list_price,
      price_currency,
      price_includes_tax,
      … 1 more
    """

class Record(sdl.Entity, sdl.Prioritized):
    """Gains: priority, severity, urgency"""

class Record(sdl.Entity, sdl.ProductCompliance):
    """Gains:
      age_restriction,
      certifications,
      hs_code,
      requires_prescription,
      … 1 more
    """

class Record(sdl.Entity, sdl.Progress):
    """Gains: done_count, progress, total_count"""

class Record(sdl.Entity, sdl.Range):
    """Gains: max_value, min_value, target"""

class Record(sdl.Entity, sdl.Rated):
    """Gains: distribution, max_score, rating, rating_count"""

class Record(sdl.Entity, sdl.Reactable):
    """Gains: my_reactions, reaction_count, reactions"""

class Record(sdl.Entity, sdl.Recurring):
    """Gains:
      is_recurring_master,
      next_occurrence_at,
      recurrence_anchor,
      recurrence_count,
      … 2 more
    """

class Record(sdl.Entity, sdl.Ref):
    """Gains: id, kind, title"""

class Record(sdl.Entity, sdl.Retained):
    """Gains: legal_hold, retention_class, sec_retain_until"""

class Record(sdl.Entity, sdl.Reviewed):
    """Gains: helpfulness, is_verified, review_body, would_recommend"""

class Record(sdl.Entity, sdl.RiskScored):
    """Gains: risk_factors, risk_level, risk_score"""

class Record(sdl.Entity, sdl.Routed):
    """Gains: destination, distance_m, origin, route_duration_s, …"""

class Record(sdl.Entity, sdl.RSVP):
    """Gains: check_in_method, checked_in, is_no_show, rsvp_state"""

class Record(sdl.Entity, sdl.Schedulable):
    """Gains: all_day, due_at, end_at, start_at, …"""

class Record(sdl.Entity, sdl.SensorReading):
    """Gains: measured_at, quality, sensor_type, sensor_unit, …"""

class Record(sdl.Entity, sdl.Sentiment):
    """Gains: magnitude, sentiment, sentiment_score"""

class Record(sdl.Entity, sdl.ServiceHealth):
    """Gains: health, last_check_at, uptime_s"""

class Record(sdl.Entity, sdl.Signed):
    """Gains: algorithm, signature, signature_is_valid, signed_at, …"""

class Record(sdl.Entity, sdl.SleepRecord):
    """Gains:
      awake_at,
      in_bed_at,
      sleep_duration_s,
      sleep_quality_score,
      … 1 more
    """

class Record(sdl.Entity, sdl.Speed):
    """Gains: speed_mps, speed_unit"""

class Record(sdl.Entity, sdl.Subscribable):
    """Gains:
      billing_interval,
      billing_interval_count,
      cancel_at_period_end,
      current_period_end,
      … 4 more
    """

class Record(sdl.Entity, sdl.Temperature):
    """Gains: temp_c, temp_unit"""

class Record(sdl.Entity, sdl.Threaded):
    """Gains: depth, reply_to_message, root, thread_ref"""

class Record(sdl.Entity, sdl.Threshold):
    """Gains: breached, threshold, threshold_target"""

class Record(sdl.Entity, sdl.Ticketed):
    """Gains: barcode, seat, ticket_price, ticket_type"""

class Record(sdl.Entity, sdl.TimeSeriesPoint):
    """Gains: ts_timestamp, ts_value"""

class Record(sdl.Entity, sdl.Timestamped):
    """Gains: created_at, deleted_at, updated_at"""

class Record(sdl.Entity, sdl.Transcribable):
    """Gains: captions_url, transcript, transcript_language"""

class Record(sdl.Entity, sdl.Trended):
    """Gains: change_pct, delta, trend, trend_period"""

class Record(sdl.Entity, sdl.Versioned):
    """Gains: channel, content_hash, is_latest, released_at, …"""

class Record(sdl.Entity, sdl.VideoTrack):
    """Gains: fps, hdr, video_bitrate_kbps, video_codec, …"""

class Record(sdl.Entity, sdl.VitalSign):
    """Gains:
      blood_pressure,
      body_temp_c,
      heart_rate_bpm,
      respiratory_rate,
      … 1 more
    """

class Record(sdl.Entity, sdl.Voted):
    """Gains: downvotes, my_vote, score, upvotes"""

class Record(sdl.Entity, sdl.Weight):
    """Gains: weight_kg, weight_unit"""

class Record(sdl.Entity, sdl.WorkflowState):
    """Gains: allowed_transitions, entered_state_at, state"""

# sdl.entity — module namespace
class Record(sdl.Entity):
    ...

# sdl.facet_resolve — module namespace
class Record(sdl.Entity):
    ...

# sdl.facets — module namespace
class Record(sdl.Entity):
    ...

sdl.field(role="admin", default="default")

sdl.is_valid_role(role="admin")

sdl.namespace_of(role="admin")

sdl.resolve_facets(names=[])

# sdl.roles — module namespace
class Record(sdl.Entity):
    ...

sdl.roles_of(model="claude-sonnet-4")

sdl.validate_custom_role(role="admin")

result = await ctx.ai.complete(
    prompt="Summarise this thread in two sentences.",
    model="claude-sonnet-4-6",
)  # -> CompletionResult

result = await ctx.billing.cancel_subscription(user="imp_u_4Kd2")  # -> dict

result = await ctx.billing.change_plan(
    plan_id="pro",
    period="monthly",
    user="imp_u_4Kd2",
)  # -> ChangePlanResult

result = await ctx.billing.check_limits(
    user="imp_u_4Kd2",
)  # -> LimitsResult

result = await ctx.billing.create_billing_portal_session(
    user="imp_u_4Kd2",
)  # -> str

result = await ctx.billing.create_setup_intent(
    user="imp_u_4Kd2",
)  # -> SetupIntentResult

result = await ctx.billing.get_auto_topup(
    user="imp_u_4Kd2",
)  # -> AutoTopupSettings

result = await ctx.billing.get_balance(user="imp_u_4Kd2")  # -> BalanceInfo

result = await ctx.billing.get_subscription(
    user="imp_u_4Kd2",
)  # -> SubscriptionInfo

result = await ctx.billing.list_payment_methods(
    user="imp_u_4Kd2",
)  # -> list[PaymentMethod]

result = await ctx.billing.list_payments(
    user="imp_u_4Kd2",
    limit=20,
)  # -> list[PaymentRecord]

result = await ctx.billing.list_plans(
    user="imp_u_4Kd2",
)  # -> list[PlanInfo]

result = await ctx.billing.remove_payment_method(
    pm_id="pm_1042",
    user="imp_u_4Kd2",
)  # -> bool

result = await ctx.billing.renew_subscription(user="imp_u_4Kd2")  # -> dict

result = await ctx.billing.resume_subscription(user="imp_u_4Kd2")  # -> dict

result = await ctx.billing.set_auto_topup(
    enabled=True,
    threshold_pct=1,
    recharge_tokens=1,
)  # -> bool

result = await ctx.billing.set_default_payment_method(
    pm_id="pm_1042",
    user="imp_u_4Kd2",
)  # -> bool

result = await ctx.billing.topup(
    tokens=1,
    price_cents=1,
    save_payment_method=True,
    off_session=True,
)  # -> TopupResult

result = await ctx.billing.track_usage(
    meter="tokens",
    quantity=1,
    user="imp_u_4Kd2",
)  # -> bool

result = await ctx.billing.update_billing_profile(
    profile={},
    user="imp_u_4Kd2",
)  # -> bool

result = await ctx.config.all()  # -> dict

result = await ctx.config.get(key="last_sync", default="default")  # -> Any

result = await ctx.config.get_section(section="sidebar")  # -> dict

result = await ctx.http.delete(
    url="https://api.example.com/orders",
    timeout=30,
)  # -> HTTPResponse

result = await ctx.http.get(
    url="https://api.example.com/orders",
    timeout=30,
)  # -> HTTPResponse

result = await ctx.http.patch(
    url="https://api.example.com/orders",
    timeout=30,
)  # -> HTTPResponse

result = await ctx.http.post(
    url="https://api.example.com/orders",
    timeout=30,
)  # -> HTTPResponse

result = await ctx.http.put(
    url="https://api.example.com/orders",
    timeout=30,
)  # -> HTTPResponse

result = await ctx.notify.for_user(
    user_id="imp_u_4Kd2",
)  # -> 'NotifyClient'

await ctx.notify.send(message="Deploy finished.", channel="in_app")

result = await ctx.skeleton.get(section="sidebar")  # -> Any

result = await ctx.storage.delete(path="/billing")  # -> bool

result = await ctx.storage.download(path="/billing")  # -> bytes

result = await ctx.storage.list(prefix="notes/2026-08")  # -> Page[FileInfo]

result = await ctx.storage.upload(
    path="/billing",
    data={"note_id": "note_1042"},
    content_type="application/octet-stream",
)  # -> FileInfo

result = await ctx.store.count(collection="notes", where={})  # -> int

result = await ctx.store.create(
    collection="notes",
    data={"note_id": "note_1042"},
)  # -> Document

result = await ctx.store.delete(
    collection="notes",
    doc_id="note_1042",
)  # -> bool

result = await ctx.store.for_user(user_id="imp_u_4Kd2")  # -> 'StoreClient'

result = await ctx.store.get(
    collection="notes",
    doc_id="note_1042",
)  # -> Document | None

result = await ctx.store.list(prefix="notes/2026-08")  # -> list[Document]

result = await ctx.store.list_users(
    collection="notes",
    page_size=1,
)  # -> AsyncIterator[str]

result = await ctx.store.query(
    collection="notes",
    where={},
    order_by="-updated_at",
)  # -> Page[Document]

result = await ctx.store.query_all(
    collection="notes",
    limit=20,
)  # -> list[Document]

result = await ctx.store.set(
    key="last_sync",
    data={"note_id": "note_1042"},
)  # -> Document

result = await ctx.store.update(
    collection="notes",
    doc_id="note_1042",
    data={"note_id": "note_1042"},
    if_match="7a05dd3",
)  # -> Document

ActionResult(
    status="success",
    data={"note_id": "note_1042"},
    summary="Saved 3 notes.",
    retryable=True,
)

BalanceInfo(balance=1, plan="pro", cap=1)

ChatResult(
    response="Here is the summary you asked for.",
    handled=True,
    functions_called=[],
    had_successful_action=True,
)

CompletionResult(
    text="Here is the summary you asked for.",
    model="claude-sonnet-4",
    usage={},
    stop_reason="end_turn",
)

Document(
    id="note_1042",
    collection="notes",
    data={"note_id": "note_1042"},
    extension_id="extension_1042",
    tenant_id="default",
    created_at="2026-08-16T09:00:00Z",
)

Event(
    event_type="order.created",
    timestamp="2026-08-16T09:00:00Z",
    user_id="imp_u_4Kd2",
    tenant_id="tenant_1042",
)

EventHandlerDef(event_type="order.created", func=handler)

ExposedMethod(name="send_invoice", func=handler, action_type="read")

FileInfo(
    path="/billing",
    size=1,
    content_type="application/pdf",
    created_at="2026-08-16T09:00:00Z",
)

FunctionCall(
    name="send_invoice",
    params={},
    action_type="read",
    success=True,
    result={"ok": True},
    intercepted=True,
    event="order.created",
)

HealthCheckDef(func=handler)

HealthStatus(status="success", message="Deploy finished.", details={})

HTTPResponse(
    status_code=1,
    body="The full note body.",
    headers={"Accept": "application/json"},
)

LifecycleHook(name="send_invoice", func=handler, version="1.4.0")

LimitsResult(allowed=True, balance=1, plan="pro")

MeteredEvent(
    event_id="event_1042",
    ts=1,
    identity="imp_u_4Kd2",
    meter="tokens",
    attribution="attribution",
    v=1,
    dimensions={},
)

Page(
    data={"note_id": "note_1042"},
    cursor="eyJvZmZzZXQiOjIwfQ",
    has_more=True,
    total=1,
)

ScheduleDef(name="send_invoice", func=handler, cron="0 9 * * *")

SignalDef(name="send_invoice", func=handler)

SubscriptionInfo(plan_id="pro", plan_name="plan", status="success")

ToolDef(
    name="send_invoice",
    func=handler,
    scopes=[],
    description="Send the invoice for one order to the customer.",
)

TrayDef(
    tray_id="inbox",
    func=handler,
    icon="Circle",
    tooltip="Open the inbox",
)

WebhookDef(
    path="/billing",
    func=handler,
    method="POST",
    secret_header="X-Imperal-Signature",
)

WebhookRequest(
    method="POST",
    headers={"Accept": "application/json"},
    body="The full note body.",
    query_params={},
)

WebhookResponse(
    status_code=1,
    body="The full note body.",
    headers={"Accept": "application/json"},
)