type Trigger interface {
    Type() TriggerType
    Config() TriggerConfig
}

type TriggerType string

const (
    TriggerManual   TriggerType = "manual"
    TriggerSchedule TriggerType = "schedule"
    TriggerSignal   TriggerType = "signal"
    TriggerWebhook  TriggerType = "webhook"
)

type TriggerConfig struct {
    ID            string  // Identifier for manual triggers
    CronSchedule  string  // Cron expression for scheduled triggers
    SignalName    string  // Temporal signal name for signal triggers
    WebhookPath   string  // HTTP path for webhook triggers
    WebhookMethod string  // HTTP method for webhook triggers (default: POST)
    WebhookSecret string  // HMAC secret for webhook signature verification
}

func Manual(id string) Trigger

flow := core.NewFlow("my-flow").
    TriggeredBy(core.Manual("start-sync")).
    Then(myNode).
    Build()

// Start via Temporal client:
// client.ExecuteWorkflow(ctx, opts, flow.Execute, input)

func Schedule(cron string) Trigger

// Daily sync at 2 AM
flow := core.NewFlow("daily-sync").
    TriggeredBy(core.Schedule("0 2 * * *")).
    Then(syncNode).
    Build()

// Hourly check
flow := core.NewFlow("hourly-check").
    TriggeredBy(core.Schedule("0 * * * *")).
    Then(checkNode).
    Build()

func Signal(name string) Trigger

flow := core.NewFlow("event-handler").
    TriggeredBy(core.Signal("new-event")).
    Then(handleEventNode).
    Build()

// Send signal from another workflow or client:
// client.SignalWorkflow(ctx, workflowID, runID, "new-event", payload)

func Webhook(path string) *WebhookTrigger

flow := core.NewFlow("github-webhook").
    TriggeredBy(core.Webhook("/github/push").
        WithMethod("POST").
        WithSecret(os.Getenv("WEBHOOK_SECRET"))).
    Then(handlePushNode).
    Build()

func (w *WebhookTrigger) WithMethod(method string) *WebhookTrigger

func (w *WebhookTrigger) WithSecret(secret string) *WebhookTrigger

func (t Trigger) Type() TriggerType

func (t Trigger) Config() TriggerConfig

// Define flow
flow := core.NewFlow("process-order").
    TriggeredBy(core.Manual("process")).
    Then(processNode).
    Build()

// Start workflow
c, _ := client.Dial(client.Options{})
we, err := c.ExecuteWorkflow(ctx, client.StartWorkflowOptions{
    ID:        "order-123",
    TaskQueue: "orders",
}, flow.Execute, core.FlowInput{})

// Define scheduled flow
flow := core.NewFlow("nightly-sync").
    TriggeredBy(core.Schedule("0 2 * * *")).
    Then(syncNode).
    Build()

// Run worker (handles scheduling)
err := core.NewWorker().
    WithConfig(core.WorkerConfig{TaskQueue: "sync"}).
    WithFlow(flow).
    Run()

// Define webhook flow
flow := core.NewFlow("github-events").
    TriggeredBy(core.Webhook("/webhooks/github").
        WithSecret(os.Getenv("GITHUB_SECRET"))).
    Then(handleEventNode).
    Build()

// Run worker with webhook server
err := core.NewWorker().
    WithConfig(core.WorkerConfig{TaskQueue: "webhooks"}).
    WithFlow(flow).
    WithWebhookServer(":8080").
    Run()

// Webhook available at: POST http://localhost:8080/webhooks/github

// Parent workflow signals child
parentFlow := core.NewFlow("parent").
    TriggeredBy(core.Manual("start")).
    Then(prepareNode).
    Then(signalChildNode).  // Sends signal to child workflow
    Then(waitForChildNode).
    Build()

// Child workflow triggered by signal
childFlow := core.NewFlow("child").
    TriggeredBy(core.Signal("start-processing")).
    Then(processNode).
    Build()

package main

import (
    "os"
    "github.com/resolute/resolute/core"
)

func main() {
    // Manual trigger for on-demand execution
    manualFlow := core.NewFlow("manual-sync").
        TriggeredBy(core.Manual("sync")).
        Then(syncNode).
        Build()

    // Scheduled trigger for periodic execution
    scheduledFlow := core.NewFlow("hourly-check").
        TriggeredBy(core.Schedule("0 * * * *")).
        Then(checkNode).
        Build()

    // Webhook trigger for external events
    webhookFlow := core.NewFlow("github-events").
        TriggeredBy(core.Webhook("/github").
            WithMethod("POST").
            WithSecret(os.Getenv("GITHUB_SECRET"))).
        Then(handleGithubNode).
        Build()

    // Signal trigger for inter-workflow communication
    signalFlow := core.NewFlow("event-processor").
        TriggeredBy(core.Signal("process-event")).
        Then(processEventNode).
        Build()
}