sqlcv1

package
v0.55.0-alpha.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 7, 2025 License: MIT Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type APIToken 

type APIToken struct {
	ID          pgtype.UUID      `json:"id"`
	CreatedAt   pgtype.Timestamp `json:"createdAt"`
	UpdatedAt   pgtype.Timestamp `json:"updatedAt"`
	ExpiresAt   pgtype.Timestamp `json:"expiresAt"`
	Revoked     bool             `json:"revoked"`
	Name        pgtype.Text      `json:"name"`
	TenantId    pgtype.UUID      `json:"tenantId"`
	NextAlertAt pgtype.Timestamp `json:"nextAlertAt"`
	Internal    bool             `json:"internal"`
}

type AcquireOrExtendLeasesParams 

type AcquireOrExtendLeasesParams struct {
	LeaseDuration    pgtype.Interval `json:"leaseDuration"`
	Tenantid         pgtype.UUID     `json:"tenantid"`
	Kind             LeaseKind       `json:"kind"`
	Resourceids      []string        `json:"resourceids"`
	Existingleaseids []int64         `json:"existingleaseids"`
}

type Action 

type Action struct {
	Description pgtype.Text `json:"description"`
	TenantId    pgtype.UUID `json:"tenantId"`
	ActionId    string      `json:"actionId"`
	ID          pgtype.UUID `json:"id"`
}

type ActionToWorker 

type ActionToWorker struct {
	B pgtype.UUID `json:"B"`
	A pgtype.UUID `json:"A"`
}

type BulkUpdateRateLimitsParams 

type BulkUpdateRateLimitsParams struct {
	Tenantid pgtype.UUID `json:"tenantid"`
	Keys     []string    `json:"keys"`
	Units    []int32     `json:"units"`
}

type CheckStrategyActiveParams 

type CheckStrategyActiveParams struct {
	Workflowid        pgtype.UUID `json:"workflowid"`
	Tenantid          pgtype.UUID `json:"tenantid"`
	Workflowversionid pgtype.UUID `json:"workflowversionid"`
	Strategyid        int64       `json:"strategyid"`
}

type ConcurrencyLimitStrategy 

type ConcurrencyLimitStrategy string
const (
	ConcurrencyLimitStrategyCANCELINPROGRESS ConcurrencyLimitStrategy = "CANCEL_IN_PROGRESS"
	ConcurrencyLimitStrategyDROPNEWEST       ConcurrencyLimitStrategy = "DROP_NEWEST"
	ConcurrencyLimitStrategyQUEUENEWEST      ConcurrencyLimitStrategy = "QUEUE_NEWEST"
	ConcurrencyLimitStrategyGROUPROUNDROBIN  ConcurrencyLimitStrategy = "GROUP_ROUND_ROBIN"
	ConcurrencyLimitStrategyCANCELNEWEST     ConcurrencyLimitStrategy = "CANCEL_NEWEST"
)

func (*ConcurrencyLimitStrategy) Scan 

func (e *ConcurrencyLimitStrategy) Scan(src interface{}) error

type ControllerPartition 

type ControllerPartition struct {
	ID            string           `json:"id"`
	CreatedAt     pgtype.Timestamp `json:"createdAt"`
	UpdatedAt     pgtype.Timestamp `json:"updatedAt"`
	LastHeartbeat pgtype.Timestamp `json:"lastHeartbeat"`
	Name          pgtype.Text      `json:"name"`
}

type CountTasksParams 

type CountTasksParams struct {
	Tenantid    pgtype.UUID        `json:"tenantid"`
	Since       pgtype.Timestamptz `json:"since"`
	Statuses    []string           `json:"statuses"`
	Until       pgtype.Timestamptz `json:"until"`
	WorkflowIds []pgtype.UUID      `json:"workflowIds"`
	WorkerId    pgtype.UUID        `json:"workerId"`
	Keys        []string           `json:"keys"`
	Values      []string           `json:"values"`
}

type CountWorkflowRunsParams 

type CountWorkflowRunsParams struct {
	Tenantid    pgtype.UUID        `json:"tenantid"`
	Statuses    []string           `json:"statuses"`
	WorkflowIds []pgtype.UUID      `json:"workflowIds"`
	Since       pgtype.Timestamptz `json:"since"`
	Until       pgtype.Timestamptz `json:"until"`
	Keys        []string           `json:"keys"`
	Values      []string           `json:"values"`
}

type CreateDAGDataParams 

type CreateDAGDataParams struct {
	DagID              int64              `json:"dag_id"`
	DagInsertedAt      pgtype.Timestamptz `json:"dag_inserted_at"`
	Input              []byte             `json:"input"`
	AdditionalMetadata []byte             `json:"additional_metadata"`
}

type CreateDAGsOLAPParams 

type CreateDAGsOLAPParams struct {
	TenantID             pgtype.UUID        `json:"tenant_id"`
	ID                   int64              `json:"id"`
	InsertedAt           pgtype.Timestamptz `json:"inserted_at"`
	ExternalID           pgtype.UUID        `json:"external_id"`
	DisplayName          string             `json:"display_name"`
	WorkflowID           pgtype.UUID        `json:"workflow_id"`
	WorkflowVersionID    pgtype.UUID        `json:"workflow_version_id"`
	Input                []byte             `json:"input"`
	AdditionalMetadata   []byte             `json:"additional_metadata"`
	ParentTaskExternalID pgtype.UUID        `json:"parent_task_external_id"`
}

type CreateDAGsParams 

type CreateDAGsParams struct {
	Tenantids             []pgtype.UUID `json:"tenantids"`
	Externalids           []pgtype.UUID `json:"externalids"`
	Displaynames          []string      `json:"displaynames"`
	Workflowids           []pgtype.UUID `json:"workflowids"`
	Workflowversionids    []pgtype.UUID `json:"workflowversionids"`
	Parenttaskexternalids []pgtype.UUID `json:"parenttaskexternalids"`
}

type CreateMatchConditionsParams 

type CreateMatchConditionsParams struct {
	V1MatchID         int64                  `json:"v1_match_id"`
	TenantID          pgtype.UUID            `json:"tenant_id"`
	EventType         V1EventType            `json:"event_type"`
	EventKey          string                 `json:"event_key"`
	EventResourceHint pgtype.Text            `json:"event_resource_hint"`
	ReadableDataKey   string                 `json:"readable_data_key"`
	OrGroupID         pgtype.UUID            `json:"or_group_id"`
	Expression        pgtype.Text            `json:"expression"`
	Action            V1MatchConditionAction `json:"action"`
	IsSatisfied       bool                   `json:"is_satisfied"`
	Data              []byte                 `json:"data"`
}

type CreateMatchesForDAGTriggersParams 

type CreateMatchesForDAGTriggersParams struct {
	Tenantids                     []pgtype.UUID        `json:"tenantids"`
	Kinds                         []string             `json:"kinds"`
	Triggerdagids                 []int64              `json:"triggerdagids"`
	Triggerdaginsertedats         []pgtype.Timestamptz `json:"triggerdaginsertedats"`
	Triggerstepids                []pgtype.UUID        `json:"triggerstepids"`
	Triggerstepindex              []int64              `json:"triggerstepindex"`
	Triggerexternalids            []pgtype.UUID        `json:"triggerexternalids"`
	Triggerworkflowrunids         []pgtype.UUID        `json:"triggerworkflowrunids"`
	Triggerexistingtaskids        []pgtype.Int8        `json:"triggerexistingtaskids"`
	Triggerexistingtaskinsertedat []pgtype.Timestamptz `json:"triggerexistingtaskinsertedat"`
	TriggerParentTaskExternalIds  []pgtype.UUID        `json:"triggerparentTaskExternalIds"`
	TriggerParentTaskIds          []pgtype.Int8        `json:"triggerparentTaskIds"`
	TriggerParentTaskInsertedAt   []pgtype.Timestamptz `json:"triggerparentTaskInsertedAt"`
	TriggerChildIndex             []pgtype.Int8        `json:"triggerchildIndex"`
	TriggerChildKey               []pgtype.Text        `json:"triggerchildKey"`
}

type CreateMatchesForSignalTriggersParams 

type CreateMatchesForSignalTriggersParams struct {
	Tenantids             []pgtype.UUID        `json:"tenantids"`
	Kinds                 []string             `json:"kinds"`
	Signaltaskids         []int64              `json:"signaltaskids"`
	Signaltaskinsertedats []pgtype.Timestamptz `json:"signaltaskinsertedats"`
	Signalexternalids     []pgtype.UUID        `json:"signalexternalids"`
	Signalkeys            []string             `json:"signalkeys"`
}

type CreateOLAPPartitionsParams 

type CreateOLAPPartitionsParams struct {
	Partitions int32       `json:"partitions"`
	Date       pgtype.Date `json:"date"`
}

type CreateTaskEventsOLAPParams 

type CreateTaskEventsOLAPParams struct {
	TenantID               pgtype.UUID          `json:"tenant_id"`
	TaskID                 int64                `json:"task_id"`
	TaskInsertedAt         pgtype.Timestamptz   `json:"task_inserted_at"`
	EventType              V1EventTypeOlap      `json:"event_type"`
	WorkflowID             pgtype.UUID          `json:"workflow_id"`
	EventTimestamp         pgtype.Timestamptz   `json:"event_timestamp"`
	ReadableStatus         V1ReadableStatusOlap `json:"readable_status"`
	RetryCount             int32                `json:"retry_count"`
	ErrorMessage           pgtype.Text          `json:"error_message"`
	Output                 []byte               `json:"output"`
	WorkerID               pgtype.UUID          `json:"worker_id"`
	AdditionalEventData    pgtype.Text          `json:"additional__event_data"`
	AdditionalEventMessage pgtype.Text          `json:"additional__event_message"`
}

type CreateTaskEventsOLAPTmpParams 

type CreateTaskEventsOLAPTmpParams struct {
	TenantID       pgtype.UUID          `json:"tenant_id"`
	TaskID         int64                `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz   `json:"task_inserted_at"`
	EventType      V1EventTypeOlap      `json:"event_type"`
	ReadableStatus V1ReadableStatusOlap `json:"readable_status"`
	RetryCount     int32                `json:"retry_count"`
	WorkerID       pgtype.UUID          `json:"worker_id"`
}

type CreateTaskEventsParams 

type CreateTaskEventsParams struct {
	Tenantid        pgtype.UUID          `json:"tenantid"`
	Taskids         []int64              `json:"taskids"`
	Taskinsertedats []pgtype.Timestamptz `json:"taskinsertedats"`
	Retrycounts     []int32              `json:"retrycounts"`
	Eventtypes      []string             `json:"eventtypes"`
	Eventkeys       []pgtype.Text        `json:"eventkeys"`
	Datas           [][]byte             `json:"datas"`
}

type CreateTaskExpressionEvalsParams 

type CreateTaskExpressionEvalsParams struct {
	Taskids         []int64              `json:"taskids"`
	Taskinsertedats []pgtype.Timestamptz `json:"taskinsertedats"`
	Keys            []string             `json:"keys"`
	Valuesstr       []pgtype.Text        `json:"valuesstr"`
	Valuesint       []pgtype.Int4        `json:"valuesint"`
	Kinds           []string             `json:"kinds"`
}

type CreateTasksOLAPParams 

type CreateTasksOLAPParams struct {
	TenantID             pgtype.UUID          `json:"tenant_id"`
	ID                   int64                `json:"id"`
	InsertedAt           pgtype.Timestamptz   `json:"inserted_at"`
	Queue                string               `json:"queue"`
	ActionID             string               `json:"action_id"`
	StepID               pgtype.UUID          `json:"step_id"`
	WorkflowID           pgtype.UUID          `json:"workflow_id"`
	WorkflowVersionID    pgtype.UUID          `json:"workflow_version_id"`
	WorkflowRunID        pgtype.UUID          `json:"workflow_run_id"`
	ScheduleTimeout      string               `json:"schedule_timeout"`
	StepTimeout          pgtype.Text          `json:"step_timeout"`
	Priority             pgtype.Int4          `json:"priority"`
	Sticky               V1StickyStrategyOlap `json:"sticky"`
	DesiredWorkerID      pgtype.UUID          `json:"desired_worker_id"`
	ExternalID           pgtype.UUID          `json:"external_id"`
	DisplayName          string               `json:"display_name"`
	Input                []byte               `json:"input"`
	AdditionalMetadata   []byte               `json:"additional_metadata"`
	DagID                pgtype.Int8          `json:"dag_id"`
	DagInsertedAt        pgtype.Timestamptz   `json:"dag_inserted_at"`
	ParentTaskExternalID pgtype.UUID          `json:"parent_task_external_id"`
}

type CreateTasksParams 

type CreateTasksParams struct {
	Tenantids              []pgtype.UUID        `json:"tenantids"`
	Queues                 []string             `json:"queues"`
	Actionids              []string             `json:"actionids"`
	Stepids                []pgtype.UUID        `json:"stepids"`
	Stepreadableids        []string             `json:"stepreadableids"`
	Workflowids            []pgtype.UUID        `json:"workflowids"`
	Scheduletimeouts       []string             `json:"scheduletimeouts"`
	Steptimeouts           []string             `json:"steptimeouts"`
	Priorities             []int32              `json:"priorities"`
	Stickies               []string             `json:"stickies"`
	Desiredworkerids       []pgtype.UUID        `json:"desiredworkerids"`
	Externalids            []pgtype.UUID        `json:"externalids"`
	Displaynames           []string             `json:"displaynames"`
	Inputs                 [][]byte             `json:"inputs"`
	Retrycounts            []int32              `json:"retrycounts"`
	Additionalmetadatas    [][]byte             `json:"additionalmetadatas"`
	InitialStates          []string             `json:"initialstates"`
	InitialStateReasons    []pgtype.Text        `json:"initialStateReasons"`
	Dagids                 []pgtype.Int8        `json:"dagids"`
	Daginsertedats         []pgtype.Timestamptz `json:"daginsertedats"`
	ConcurrencyStrategyIds [][]int64            `json:"concurrencyStrategyIds"`
	ConcurrencyKeys        [][]string           `json:"concurrencyKeys"`
	ParentTaskExternalIds  []pgtype.UUID        `json:"parentTaskExternalIds"`
	ParentTaskIds          []pgtype.Int8        `json:"parentTaskIds"`
	ParentTaskInsertedAts  []pgtype.Timestamptz `json:"parentTaskInsertedAts"`
	ChildIndex             []pgtype.Int8        `json:"childIndex"`
	ChildKey               []pgtype.Text        `json:"childKey"`
	StepIndex              []int64              `json:"stepIndex"`
	RetryBackoffFactor     []pgtype.Float8      `json:"retryBackoffFactor"`
	RetryMaxBackoff        []pgtype.Int4        `json:"retryMaxBackoff"`
	WorkflowVersionIds     []pgtype.UUID        `json:"workflowVersionIds"`
	WorkflowRunIds         []pgtype.UUID        `json:"workflowRunIds"`
}

type DBTX 

type DBTX interface {
	Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error)
	Query(context.Context, string, ...interface{}) (pgx.Rows, error)
	QueryRow(context.Context, string, ...interface{}) pgx.Row
	CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error)
}

type DeleteMatchingSignalEventsParams 

type DeleteMatchingSignalEventsParams struct {
	Taskids         []int64              `json:"taskids"`
	Taskinsertedats []pgtype.Timestamptz `json:"taskinsertedats"`
	Eventkeys       []string             `json:"eventkeys"`
	Tenantid        pgtype.UUID          `json:"tenantid"`
	Eventtype       V1TaskEventType      `json:"eventtype"`
}

type DeleteTasksFromQueueParams 

type DeleteTasksFromQueueParams struct {
	Taskids     []int64 `json:"taskids"`
	Retrycounts []int32 `json:"retrycounts"`
}

type Dispatcher 

type Dispatcher struct {
	ID              pgtype.UUID      `json:"id"`
	CreatedAt       pgtype.Timestamp `json:"createdAt"`
	UpdatedAt       pgtype.Timestamp `json:"updatedAt"`
	DeletedAt       pgtype.Timestamp `json:"deletedAt"`
	LastHeartbeatAt pgtype.Timestamp `json:"lastHeartbeatAt"`
	IsActive        bool             `json:"isActive"`
}

type Event 

type Event struct {
	ID                 pgtype.UUID      `json:"id"`
	CreatedAt          pgtype.Timestamp `json:"createdAt"`
	UpdatedAt          pgtype.Timestamp `json:"updatedAt"`
	DeletedAt          pgtype.Timestamp `json:"deletedAt"`
	Key                string           `json:"key"`
	TenantId           pgtype.UUID      `json:"tenantId"`
	ReplayedFromId     pgtype.UUID      `json:"replayedFromId"`
	Data               []byte           `json:"data"`
	AdditionalMetadata []byte           `json:"additionalMetadata"`
	InsertOrder        pgtype.Int4      `json:"insertOrder"`
}

type EventKey 

type EventKey struct {
	Key      string      `json:"key"`
	TenantId pgtype.UUID `json:"tenantId"`
	ID       int64       `json:"id"`
}

type FailTaskAppFailureParams 

type FailTaskAppFailureParams struct {
	Taskids         []int64              `json:"taskids"`
	Taskinsertedats []pgtype.Timestamptz `json:"taskinsertedats"`
	Tenantid        pgtype.UUID          `json:"tenantid"`
}

type FailTaskAppFailureRow 

type FailTaskAppFailureRow struct {
	ID                 int64              `json:"id"`
	InsertedAt         pgtype.Timestamptz `json:"inserted_at"`
	RetryCount         int32              `json:"retry_count"`
	AppRetryCount      int32              `json:"app_retry_count"`
	RetryBackoffFactor pgtype.Float8      `json:"retry_backoff_factor"`
	RetryMaxBackoff    pgtype.Int4        `json:"retry_max_backoff"`
}

type FailTaskInternalFailureParams 

type FailTaskInternalFailureParams struct {
	Maxinternalretries int32                `json:"maxinternalretries"`
	Taskids            []int64              `json:"taskids"`
	Taskinsertedats    []pgtype.Timestamptz `json:"taskinsertedats"`
	Tenantid           pgtype.UUID          `json:"tenantid"`
}

type FailTaskInternalFailureRow 

type FailTaskInternalFailureRow struct {
	ID         int64              `json:"id"`
	InsertedAt pgtype.Timestamptz `json:"inserted_at"`
	RetryCount int32              `json:"retry_count"`
}

type FetchWorkflowRunIdsParams 

type FetchWorkflowRunIdsParams struct {
	Tenantid               pgtype.UUID        `json:"tenantid"`
	Statuses               []string           `json:"statuses"`
	WorkflowIds            []pgtype.UUID      `json:"workflowIds"`
	Since                  pgtype.Timestamptz `json:"since"`
	Until                  pgtype.Timestamptz `json:"until"`
	Keys                   []string           `json:"keys"`
	Values                 []string           `json:"values"`
	Listworkflowrunsoffset int32              `json:"listworkflowrunsoffset"`
	Listworkflowrunslimit  int32              `json:"listworkflowrunslimit"`
	ParentTaskExternalId   pgtype.UUID        `json:"parentTaskExternalId"`
}

type FetchWorkflowRunIdsRow 

type FetchWorkflowRunIdsRow struct {
	ID         int64              `json:"id"`
	InsertedAt pgtype.Timestamptz `json:"inserted_at"`
	Kind       V1RunKind          `json:"kind"`
	ExternalID pgtype.UUID        `json:"external_id"`
}

type FlattenExternalIdsParams 

type FlattenExternalIdsParams struct {
	Externalids []pgtype.UUID `json:"externalids"`
	Tenantid    pgtype.UUID   `json:"tenantid"`
}

type FlattenExternalIdsRow 

type FlattenExternalIdsRow struct {
	ID                    int64              `json:"id"`
	InsertedAt            pgtype.Timestamptz `json:"inserted_at"`
	RetryCount            int32              `json:"retry_count"`
	ExternalID            pgtype.UUID        `json:"external_id"`
	WorkflowRunID         pgtype.UUID        `json:"workflow_run_id"`
	AdditionalMetadata    []byte             `json:"additional_metadata"`
	DagID                 pgtype.Int8        `json:"dag_id"`
	DagInsertedAt         pgtype.Timestamptz `json:"dag_inserted_at"`
	ParentTaskID          pgtype.Int8        `json:"parent_task_id"`
	ChildIndex            pgtype.Int8        `json:"child_index"`
	ChildKey              pgtype.Text        `json:"child_key"`
	WorkflowRunExternalID pgtype.UUID        `json:"workflow_run_external_id"`
}

type FlattenTasksByExternalIdsParams 

type FlattenTasksByExternalIdsParams struct {
	Externalids []pgtype.UUID `json:"externalids"`
	Tenantid    pgtype.UUID   `json:"tenantid"`
}

type FlattenTasksByExternalIdsRow 

type FlattenTasksByExternalIdsRow struct {
	TenantID   pgtype.UUID        `json:"tenant_id"`
	ID         int64              `json:"id"`
	InsertedAt pgtype.Timestamptz `json:"inserted_at"`
	RetryCount int32              `json:"retry_count"`
}

type GetDAGDataParams 

type GetDAGDataParams struct {
	Dagids         []int64              `json:"dagids"`
	Daginsertedats []pgtype.Timestamptz `json:"daginsertedats"`
}

type GetDAGDataRow 

type GetDAGDataRow struct {
	DagID              int64              `json:"dag_id"`
	DagInsertedAt      pgtype.Timestamptz `json:"dag_inserted_at"`
	Input              []byte             `json:"input"`
	AdditionalMetadata []byte             `json:"additional_metadata"`
	DagID_2            interface{}        `json:"dag_id_2"`
	DagInsertedAt_2    interface{}        `json:"dag_inserted_at_2"`
}

type GetDesiredLabelsRow 

type GetDesiredLabelsRow struct {
	Key        string                `json:"key"`
	StrValue   pgtype.Text           `json:"strValue"`
	IntValue   pgtype.Int4           `json:"intValue"`
	Required   bool                  `json:"required"`
	Weight     int32                 `json:"weight"`
	Comparator WorkerLabelComparator `json:"comparator"`
	StepId     pgtype.UUID           `json:"stepId"`
}

type GetGroupKeyRun 

type GetGroupKeyRun struct {
	ID                pgtype.UUID      `json:"id"`
	CreatedAt         pgtype.Timestamp `json:"createdAt"`
	UpdatedAt         pgtype.Timestamp `json:"updatedAt"`
	DeletedAt         pgtype.Timestamp `json:"deletedAt"`
	TenantId          pgtype.UUID      `json:"tenantId"`
	WorkerId          pgtype.UUID      `json:"workerId"`
	TickerId          pgtype.UUID      `json:"tickerId"`
	Status            StepRunStatus    `json:"status"`
	Input             []byte           `json:"input"`
	Output            pgtype.Text      `json:"output"`
	RequeueAfter      pgtype.Timestamp `json:"requeueAfter"`
	Error             pgtype.Text      `json:"error"`
	StartedAt         pgtype.Timestamp `json:"startedAt"`
	FinishedAt        pgtype.Timestamp `json:"finishedAt"`
	TimeoutAt         pgtype.Timestamp `json:"timeoutAt"`
	CancelledAt       pgtype.Timestamp `json:"cancelledAt"`
	CancelledReason   pgtype.Text      `json:"cancelledReason"`
	CancelledError    pgtype.Text      `json:"cancelledError"`
	WorkflowRunId     pgtype.UUID      `json:"workflowRunId"`
	ScheduleTimeoutAt pgtype.Timestamp `json:"scheduleTimeoutAt"`
}

type GetLeasesToAcquireParams 

type GetLeasesToAcquireParams struct {
	Tenantid    pgtype.UUID `json:"tenantid"`
	Kind        LeaseKind   `json:"kind"`
	Resourceids []string    `json:"resourceids"`
}

type GetMinUnprocessedQueueItemIdParams 

type GetMinUnprocessedQueueItemIdParams struct {
	Tenantid pgtype.UUID `json:"tenantid"`
	Queue    string      `json:"queue"`
}

type GetQueuedCountsRow 

type GetQueuedCountsRow struct {
	Queue string `json:"queue"`
	Count int64  `json:"count"`
}

type GetSatisfiedMatchConditionsParams 

type GetSatisfiedMatchConditionsParams struct {
	Matchids     []int64  `json:"matchids"`
	Conditionids []int64  `json:"conditionids"`
	Datas        [][]byte `json:"datas"`
}

type GetTaskPointMetricsParams 

type GetTaskPointMetricsParams struct {
	Interval      pgtype.Interval    `json:"interval"`
	Tenantid      pgtype.UUID        `json:"tenantid"`
	Createdafter  pgtype.Timestamptz `json:"createdafter"`
	Createdbefore pgtype.Timestamptz `json:"createdbefore"`
}

type GetTaskPointMetricsRow 

type GetTaskPointMetricsRow struct {
	Bucket2        pgtype.Timestamptz `json:"bucket_2"`
	CompletedCount int64              `json:"completed_count"`
	FailedCount    int64              `json:"failed_count"`
}

type GetTenantStatusMetricsParams 

type GetTenantStatusMetricsParams struct {
	Tenantid             pgtype.UUID        `json:"tenantid"`
	Createdafter         pgtype.Timestamptz `json:"createdafter"`
	WorkflowIds          []pgtype.UUID      `json:"workflowIds"`
	ParentTaskExternalId pgtype.UUID        `json:"parentTaskExternalId"`
}

type GetTenantStatusMetricsRow 

type GetTenantStatusMetricsRow struct {
	TenantID       pgtype.UUID `json:"tenant_id"`
	TotalQueued    int64       `json:"total_queued"`
	TotalRunning   int64       `json:"total_running"`
	TotalCompleted int64       `json:"total_completed"`
	TotalCancelled int64       `json:"total_cancelled"`
	TotalFailed    int64       `json:"total_failed"`
}

type GetWorkerByIdRow 

type GetWorkerByIdRow struct {
	Worker         Worker      `json:"worker"`
	WebhookUrl     pgtype.Text `json:"webhookUrl"`
	RemainingSlots int32       `json:"remainingSlots"`
}

type GetWorkflowRunIdFromDagIdInsertedAtParams 

type GetWorkflowRunIdFromDagIdInsertedAtParams struct {
	Dagid         int64              `json:"dagid"`
	Daginsertedat pgtype.Timestamptz `json:"daginsertedat"`
}

type InsertLogLineParams 

type InsertLogLineParams struct {
	TenantID       pgtype.UUID        `json:"tenant_id"`
	TaskID         int64              `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz `json:"task_inserted_at"`
	Message        string             `json:"message"`
	Metadata       []byte             `json:"metadata"`
}

type InternalQueue 

type InternalQueue string
const (
	InternalQueueWORKERSEMAPHORECOUNT InternalQueue = "WORKER_SEMAPHORE_COUNT"
	InternalQueueSTEPRUNUPDATE        InternalQueue = "STEP_RUN_UPDATE"
	InternalQueueWORKFLOWRUNUPDATE    InternalQueue = "WORKFLOW_RUN_UPDATE"
	InternalQueueWORKFLOWRUNPAUSED    InternalQueue = "WORKFLOW_RUN_PAUSED"
	InternalQueueSTEPRUNUPDATEV2      InternalQueue = "STEP_RUN_UPDATE_V2"
)

func (*InternalQueue) Scan 

func (e *InternalQueue) Scan(src interface{}) error

type InternalQueueItem 

type InternalQueueItem struct {
	ID        int64         `json:"id"`
	Queue     InternalQueue `json:"queue"`
	IsQueued  bool          `json:"isQueued"`
	Data      []byte        `json:"data"`
	TenantId  pgtype.UUID   `json:"tenantId"`
	Priority  int32         `json:"priority"`
	UniqueKey pgtype.Text   `json:"uniqueKey"`
}

type InviteLinkStatus 

type InviteLinkStatus string
const (
	InviteLinkStatusPENDING  InviteLinkStatus = "PENDING"
	InviteLinkStatusACCEPTED InviteLinkStatus = "ACCEPTED"
	InviteLinkStatusREJECTED InviteLinkStatus = "REJECTED"
)

func (*InviteLinkStatus) Scan 

func (e *InviteLinkStatus) Scan(src interface{}) error

type Job 

type Job struct {
	ID                pgtype.UUID      `json:"id"`
	CreatedAt         pgtype.Timestamp `json:"createdAt"`
	UpdatedAt         pgtype.Timestamp `json:"updatedAt"`
	DeletedAt         pgtype.Timestamp `json:"deletedAt"`
	TenantId          pgtype.UUID      `json:"tenantId"`
	WorkflowVersionId pgtype.UUID      `json:"workflowVersionId"`
	Name              string           `json:"name"`
	Description       pgtype.Text      `json:"description"`
	Timeout           pgtype.Text      `json:"timeout"`
	Kind              JobKind          `json:"kind"`
}

type JobKind 

type JobKind string
const (
	JobKindDEFAULT   JobKind = "DEFAULT"
	JobKindONFAILURE JobKind = "ON_FAILURE"
)

func (*JobKind) Scan 

func (e *JobKind) Scan(src interface{}) error

type JobRun 

type JobRun struct {
	ID              pgtype.UUID      `json:"id"`
	CreatedAt       pgtype.Timestamp `json:"createdAt"`
	UpdatedAt       pgtype.Timestamp `json:"updatedAt"`
	DeletedAt       pgtype.Timestamp `json:"deletedAt"`
	TenantId        pgtype.UUID      `json:"tenantId"`
	JobId           pgtype.UUID      `json:"jobId"`
	TickerId        pgtype.UUID      `json:"tickerId"`
	Status          JobRunStatus     `json:"status"`
	Result          []byte           `json:"result"`
	StartedAt       pgtype.Timestamp `json:"startedAt"`
	FinishedAt      pgtype.Timestamp `json:"finishedAt"`
	TimeoutAt       pgtype.Timestamp `json:"timeoutAt"`
	CancelledAt     pgtype.Timestamp `json:"cancelledAt"`
	CancelledReason pgtype.Text      `json:"cancelledReason"`
	CancelledError  pgtype.Text      `json:"cancelledError"`
	WorkflowRunId   pgtype.UUID      `json:"workflowRunId"`
}

type JobRunLookupData 

type JobRunLookupData struct {
	ID        pgtype.UUID      `json:"id"`
	CreatedAt pgtype.Timestamp `json:"createdAt"`
	UpdatedAt pgtype.Timestamp `json:"updatedAt"`
	DeletedAt pgtype.Timestamp `json:"deletedAt"`
	JobRunId  pgtype.UUID      `json:"jobRunId"`
	TenantId  pgtype.UUID      `json:"tenantId"`
	Data      []byte           `json:"data"`
}

type JobRunStatus 

type JobRunStatus string
const (
	JobRunStatusPENDING   JobRunStatus = "PENDING"
	JobRunStatusRUNNING   JobRunStatus = "RUNNING"
	JobRunStatusSUCCEEDED JobRunStatus = "SUCCEEDED"
	JobRunStatusFAILED    JobRunStatus = "FAILED"
	JobRunStatusCANCELLED JobRunStatus = "CANCELLED"
	JobRunStatusBACKOFF   JobRunStatus = "BACKOFF"
)

func (*JobRunStatus) Scan 

func (e *JobRunStatus) Scan(src interface{}) error

type Lease 

type Lease struct {
	ID         int64            `json:"id"`
	ExpiresAt  pgtype.Timestamp `json:"expiresAt"`
	TenantId   pgtype.UUID      `json:"tenantId"`
	ResourceId string           `json:"resourceId"`
	Kind       LeaseKind        `json:"kind"`
}

type LeaseKind 

type LeaseKind string
const (
	LeaseKindWORKER              LeaseKind = "WORKER"
	LeaseKindQUEUE               LeaseKind = "QUEUE"
	LeaseKindCONCURRENCYSTRATEGY LeaseKind = "CONCURRENCY_STRATEGY"
)

func (*LeaseKind) Scan 

func (e *LeaseKind) Scan(src interface{}) error

type LimitResource 

type LimitResource string
const (
	LimitResourceWORKFLOWRUN LimitResource = "WORKFLOW_RUN"
	LimitResourceEVENT       LimitResource = "EVENT"
	LimitResourceWORKER      LimitResource = "WORKER"
	LimitResourceCRON        LimitResource = "CRON"
	LimitResourceSCHEDULE    LimitResource = "SCHEDULE"
)

func (*LimitResource) Scan 

func (e *LimitResource) Scan(src interface{}) error

type ListActionsForWorkersParams 

type ListActionsForWorkersParams struct {
	Tenantid  pgtype.UUID   `json:"tenantid"`
	Workerids []pgtype.UUID `json:"workerids"`
}

type ListActionsForWorkersRow 

type ListActionsForWorkersRow struct {
	WorkerId pgtype.UUID `json:"workerId"`
	ActionId pgtype.Text `json:"actionId"`
}

type ListActiveWorkersRow 

type ListActiveWorkersRow struct {
	ID      pgtype.UUID `json:"id"`
	MaxRuns int32       `json:"maxRuns"`
}

type ListAllTasksInDagsParams 

type ListAllTasksInDagsParams struct {
	Tenantid pgtype.UUID `json:"tenantid"`
	Dagids   []int64     `json:"dagids"`
}

type ListAllTasksInDagsRow 

type ListAllTasksInDagsRow struct {
	ID             int64              `json:"id"`
	InsertedAt     pgtype.Timestamptz `json:"inserted_at"`
	RetryCount     int32              `json:"retry_count"`
	DagID          pgtype.Int8        `json:"dag_id"`
	DagInsertedAt  pgtype.Timestamptz `json:"dag_inserted_at"`
	StepReadableID string             `json:"step_readable_id"`
	StepID         pgtype.UUID        `json:"step_id"`
	WorkflowID     pgtype.UUID        `json:"workflow_id"`
	ExternalID     pgtype.UUID        `json:"external_id"`
}

type ListAvailableSlotsForWorkersParams 

type ListAvailableSlotsForWorkersParams struct {
	Tenantid  pgtype.UUID   `json:"tenantid"`
	Workerids []pgtype.UUID `json:"workerids"`
}

type ListAvailableSlotsForWorkersRow 

type ListAvailableSlotsForWorkersRow struct {
	ID             pgtype.UUID `json:"id"`
	AvailableSlots int32       `json:"availableSlots"`
}

type ListConcurrencyStrategiesByStepIdParams 

type ListConcurrencyStrategiesByStepIdParams struct {
	Tenantid pgtype.UUID   `json:"tenantid"`
	Stepids  []pgtype.UUID `json:"stepids"`
}

type ListLogLinesParams 

type ListLogLinesParams struct {
	Tenantid       pgtype.UUID        `json:"tenantid"`
	Taskid         int64              `json:"taskid"`
	Taskinsertedat pgtype.Timestamptz `json:"taskinsertedat"`
	Search         pgtype.Text        `json:"search"`
	Offset         interface{}        `json:"offset"`
	Limit          interface{}        `json:"limit"`
}

type ListManyWorkerLabelsRow 

type ListManyWorkerLabelsRow struct {
	ID        int64            `json:"id"`
	Key       string           `json:"key"`
	IntValue  pgtype.Int4      `json:"intValue"`
	StrValue  pgtype.Text      `json:"strValue"`
	CreatedAt pgtype.Timestamp `json:"createdAt"`
	UpdatedAt pgtype.Timestamp `json:"updatedAt"`
	WorkerId  pgtype.UUID      `json:"workerId"`
}

type ListMatchConditionsForEventParams 

type ListMatchConditionsForEventParams struct {
	Tenantid           pgtype.UUID   `json:"tenantid"`
	Eventtype          V1EventType   `json:"eventtype"`
	Eventkeys          []string      `json:"eventkeys"`
	Eventresourcehints []pgtype.Text `json:"eventresourcehints"`
}

type ListMatchConditionsForEventRow 

type ListMatchConditionsForEventRow struct {
	V1MatchID         int64              `json:"v1_match_id"`
	ID                int64              `json:"id"`
	RegisteredAt      pgtype.Timestamptz `json:"registered_at"`
	EventType         V1EventType        `json:"event_type"`
	EventKey          string             `json:"event_key"`
	EventResourceHint pgtype.Text        `json:"event_resource_hint"`
	ReadableDataKey   string             `json:"readable_data_key"`
	Expression        pgtype.Text        `json:"expression"`
}

type ListMatchingSignalEventsParams 

type ListMatchingSignalEventsParams struct {
	Tenantid        pgtype.UUID          `json:"tenantid"`
	Eventtype       V1TaskEventType      `json:"eventtype"`
	Taskids         []int64              `json:"taskids"`
	Taskinsertedats []pgtype.Timestamptz `json:"taskinsertedats"`
	Eventkeys       []string             `json:"eventkeys"`
}

type ListMatchingTaskEventsParams 

type ListMatchingTaskEventsParams struct {
	Tenantid        pgtype.UUID   `json:"tenantid"`
	Taskexternalids []pgtype.UUID `json:"taskexternalids"`
	Eventtypes      [][]string    `json:"eventtypes"`
}

type ListMatchingTaskEventsRow 

type ListMatchingTaskEventsRow struct {
	ExternalID     pgtype.UUID        `json:"external_id"`
	ID             int64              `json:"id"`
	TenantID       pgtype.UUID        `json:"tenant_id"`
	TaskID         int64              `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz `json:"task_inserted_at"`
	RetryCount     int32              `json:"retry_count"`
	EventType      V1TaskEventType    `json:"event_type"`
	EventKey       pgtype.Text        `json:"event_key"`
	CreatedAt      pgtype.Timestamp   `json:"created_at"`
	Data           []byte             `json:"data"`
}

type ListOLAPPartitionsBeforeDateRow 

type ListOLAPPartitionsBeforeDateRow struct {
	ParentTable   string `json:"parent_table"`
	PartitionName string `json:"partition_name"`
}

type ListPartitionsBeforeDateRow 

type ListPartitionsBeforeDateRow struct {
	ParentTable   string `json:"parent_table"`
	PartitionName string `json:"partition_name"`
}

type ListQueueItemsForQueueParams 

type ListQueueItemsForQueueParams struct {
	Tenantid pgtype.UUID `json:"tenantid"`
	Queue    string      `json:"queue"`
	GtId     pgtype.Int8 `json:"gtId"`
	Limit    pgtype.Int4 `json:"limit"`
}

type ListRateLimitsForStepsParams 

type ListRateLimitsForStepsParams struct {
	Stepids  []pgtype.UUID `json:"stepids"`
	Tenantid pgtype.UUID   `json:"tenantid"`
}

type ListRateLimitsForTenantNoMutateParams 

type ListRateLimitsForTenantNoMutateParams struct {
	Tenantid pgtype.UUID `json:"tenantid"`
	Search   pgtype.Text `json:"search"`
	Offset   interface{} `json:"offset"`
	Limit    interface{} `json:"limit"`
}

type ListRateLimitsForTenantNoMutateRow 

type ListRateLimitsForTenantNoMutateRow struct {
	TenantId   pgtype.UUID      `json:"tenantId"`
	Key        string           `json:"key"`
	LimitValue int32            `json:"limitValue"`
	Value      int32            `json:"value"`
	Window     string           `json:"window"`
	LastRefill pgtype.Timestamp `json:"lastRefill"`
}

type ListRateLimitsForTenantWithMutateRow 

type ListRateLimitsForTenantWithMutateRow struct {
	TenantId     pgtype.UUID      `json:"tenantId"`
	Key          string           `json:"key"`
	LimitValue   int32            `json:"limitValue"`
	Value        int32            `json:"value"`
	Window       string           `json:"window"`
	LastRefill   pgtype.Timestamp `json:"lastRefill"`
	NextRefillAt pgtype.Timestamp `json:"nextRefillAt"`
}

type ListSemaphoreSlotsWithStateForWorkerParams 

type ListSemaphoreSlotsWithStateForWorkerParams struct {
	Tenantid pgtype.UUID `json:"tenantid"`
	Workerid pgtype.UUID `json:"workerid"`
	Limit    pgtype.Int4 `json:"limit"`
}

type ListSemaphoreSlotsWithStateForWorkerRow 

type ListSemaphoreSlotsWithStateForWorkerRow struct {
	TaskID                 int64              `json:"task_id"`
	TaskInsertedAt         pgtype.Timestamptz `json:"task_inserted_at"`
	RetryCount             int32              `json:"retry_count"`
	WorkerID               pgtype.UUID        `json:"worker_id"`
	TenantID               pgtype.UUID        `json:"tenant_id"`
	TimeoutAt              pgtype.Timestamp   `json:"timeout_at"`
	ID                     int64              `json:"id"`
	InsertedAt             pgtype.Timestamptz `json:"inserted_at"`
	TenantID_2             pgtype.UUID        `json:"tenant_id_2"`
	Queue                  string             `json:"queue"`
	ActionID               string             `json:"action_id"`
	StepID                 pgtype.UUID        `json:"step_id"`
	StepReadableID         string             `json:"step_readable_id"`
	WorkflowID             pgtype.UUID        `json:"workflow_id"`
	WorkflowVersionID      pgtype.UUID        `json:"workflow_version_id"`
	WorkflowRunID          pgtype.UUID        `json:"workflow_run_id"`
	ScheduleTimeout        string             `json:"schedule_timeout"`
	StepTimeout            pgtype.Text        `json:"step_timeout"`
	Priority               pgtype.Int4        `json:"priority"`
	Sticky                 V1StickyStrategy   `json:"sticky"`
	DesiredWorkerID        pgtype.UUID        `json:"desired_worker_id"`
	ExternalID             pgtype.UUID        `json:"external_id"`
	DisplayName            string             `json:"display_name"`
	Input                  []byte             `json:"input"`
	RetryCount_2           int32              `json:"retry_count_2"`
	InternalRetryCount     int32              `json:"internal_retry_count"`
	AppRetryCount          int32              `json:"app_retry_count"`
	StepIndex              int64              `json:"step_index"`
	AdditionalMetadata     []byte             `json:"additional_metadata"`
	DagID                  pgtype.Int8        `json:"dag_id"`
	DagInsertedAt          pgtype.Timestamptz `json:"dag_inserted_at"`
	ParentTaskExternalID   pgtype.UUID        `json:"parent_task_external_id"`
	ParentTaskID           pgtype.Int8        `json:"parent_task_id"`
	ParentTaskInsertedAt   pgtype.Timestamptz `json:"parent_task_inserted_at"`
	ChildIndex             pgtype.Int8        `json:"child_index"`
	ChildKey               pgtype.Text        `json:"child_key"`
	InitialState           V1TaskInitialState `json:"initial_state"`
	InitialStateReason     pgtype.Text        `json:"initial_state_reason"`
	ConcurrencyStrategyIds []int64            `json:"concurrency_strategy_ids"`
	ConcurrencyKeys        []string           `json:"concurrency_keys"`
	RetryBackoffFactor     pgtype.Float8      `json:"retry_backoff_factor"`
	RetryMaxBackoff        pgtype.Int4        `json:"retry_max_backoff"`
}

type ListStepsByIdsParams 

type ListStepsByIdsParams struct {
	Ids      []pgtype.UUID `json:"ids"`
	Tenantid pgtype.UUID   `json:"tenantid"`
}

type ListStepsByIdsRow 

type ListStepsByIdsRow struct {
	ID                    pgtype.UUID        `json:"id"`
	CreatedAt             pgtype.Timestamp   `json:"createdAt"`
	UpdatedAt             pgtype.Timestamp   `json:"updatedAt"`
	DeletedAt             pgtype.Timestamp   `json:"deletedAt"`
	ReadableId            pgtype.Text        `json:"readableId"`
	TenantId              pgtype.UUID        `json:"tenantId"`
	JobId                 pgtype.UUID        `json:"jobId"`
	ActionId              string             `json:"actionId"`
	Timeout               pgtype.Text        `json:"timeout"`
	CustomUserData        []byte             `json:"customUserData"`
	Retries               int32              `json:"retries"`
	RetryBackoffFactor    pgtype.Float8      `json:"retryBackoffFactor"`
	RetryMaxBackoff       pgtype.Int4        `json:"retryMaxBackoff"`
	ScheduleTimeout       string             `json:"scheduleTimeout"`
	WorkflowVersionId     pgtype.UUID        `json:"workflowVersionId"`
	WorkflowVersionSticky NullStickyStrategy `json:"workflowVersionSticky"`
	WorkflowName          string             `json:"workflowName"`
	WorkflowId            pgtype.UUID        `json:"workflowId"`
	ExprCount             int64              `json:"exprCount"`
	ConcurrencyCount      int64              `json:"concurrencyCount"`
}

type ListStepsByWorkflowVersionIdsParams 

type ListStepsByWorkflowVersionIdsParams struct {
	Ids      []pgtype.UUID `json:"ids"`
	Tenantid pgtype.UUID   `json:"tenantid"`
}

type ListStepsByWorkflowVersionIdsRow 

type ListStepsByWorkflowVersionIdsRow struct {
	ID                 pgtype.UUID      `json:"id"`
	CreatedAt          pgtype.Timestamp `json:"createdAt"`
	UpdatedAt          pgtype.Timestamp `json:"updatedAt"`
	DeletedAt          pgtype.Timestamp `json:"deletedAt"`
	ReadableId         pgtype.Text      `json:"readableId"`
	TenantId           pgtype.UUID      `json:"tenantId"`
	JobId              pgtype.UUID      `json:"jobId"`
	ActionId           string           `json:"actionId"`
	Timeout            pgtype.Text      `json:"timeout"`
	CustomUserData     []byte           `json:"customUserData"`
	Retries            int32            `json:"retries"`
	RetryBackoffFactor pgtype.Float8    `json:"retryBackoffFactor"`
	RetryMaxBackoff    pgtype.Int4      `json:"retryMaxBackoff"`
	ScheduleTimeout    string           `json:"scheduleTimeout"`
	WorkflowVersionId  pgtype.UUID      `json:"workflowVersionId"`
	WorkflowName       string           `json:"workflowName"`
	WorkflowId         pgtype.UUID      `json:"workflowId"`
	JobKind            JobKind          `json:"jobKind"`
	Parents            []pgtype.UUID    `json:"parents"`
}

type ListTaskEventsForWorkflowRunParams 

type ListTaskEventsForWorkflowRunParams struct {
	Workflowrunid pgtype.UUID `json:"workflowrunid"`
	Tenantid      pgtype.UUID `json:"tenantid"`
}

type ListTaskEventsForWorkflowRunRow 

type ListTaskEventsForWorkflowRunRow struct {
	TenantID               pgtype.UUID          `json:"tenant_id"`
	TaskID                 int64                `json:"task_id"`
	TaskInsertedAt         pgtype.Timestamptz   `json:"task_inserted_at"`
	RetryCount             int32                `json:"retry_count"`
	EventType              V1EventTypeOlap      `json:"event_type"`
	TimeFirstSeen          pgtype.Timestamptz   `json:"time_first_seen"`
	TimeLastSeen           pgtype.Timestamptz   `json:"time_last_seen"`
	Count                  int64                `json:"count"`
	ID                     int64                `json:"id"`
	EventTimestamp         pgtype.Timestamptz   `json:"event_timestamp"`
	ReadableStatus         V1ReadableStatusOlap `json:"readable_status"`
	ErrorMessage           pgtype.Text          `json:"error_message"`
	Output                 []byte               `json:"output"`
	WorkerID               pgtype.UUID          `json:"worker_id"`
	AdditionalEventData    pgtype.Text          `json:"additional__event_data"`
	AdditionalEventMessage pgtype.Text          `json:"additional__event_message"`
	DisplayName            string               `json:"display_name"`
	TaskExternalID         pgtype.UUID          `json:"task_external_id"`
}

type ListTaskEventsParams 

type ListTaskEventsParams struct {
	Tenantid       pgtype.UUID        `json:"tenantid"`
	Taskid         int64              `json:"taskid"`
	Taskinsertedat pgtype.Timestamptz `json:"taskinsertedat"`
}

type ListTaskEventsRow 

type ListTaskEventsRow struct {
	TenantID               pgtype.UUID          `json:"tenant_id"`
	TaskID                 int64                `json:"task_id"`
	TaskInsertedAt         pgtype.Timestamptz   `json:"task_inserted_at"`
	RetryCount             int32                `json:"retry_count"`
	EventType              V1EventTypeOlap      `json:"event_type"`
	TimeFirstSeen          interface{}          `json:"time_first_seen"`
	TimeLastSeen           interface{}          `json:"time_last_seen"`
	Count                  int64                `json:"count"`
	ID                     int64                `json:"id"`
	EventTimestamp         pgtype.Timestamptz   `json:"event_timestamp"`
	ReadableStatus         V1ReadableStatusOlap `json:"readable_status"`
	ErrorMessage           pgtype.Text          `json:"error_message"`
	Output                 []byte               `json:"output"`
	WorkerID               pgtype.UUID          `json:"worker_id"`
	AdditionalEventData    pgtype.Text          `json:"additional__event_data"`
	AdditionalEventMessage pgtype.Text          `json:"additional__event_message"`
}

type ListTaskExpressionEvalsParams 

type ListTaskExpressionEvalsParams struct {
	Taskids         []int64              `json:"taskids"`
	Taskinsertedats []pgtype.Timestamptz `json:"taskinsertedats"`
}

type ListTaskMetasParams 

type ListTaskMetasParams struct {
	TenantID pgtype.UUID `json:"tenant_id"`
	Ids      []int64     `json:"ids"`
}

type ListTaskMetasRow 

type ListTaskMetasRow struct {
	ID         int64              `json:"id"`
	InsertedAt pgtype.Timestamptz `json:"inserted_at"`
	ExternalID pgtype.UUID        `json:"external_id"`
	RetryCount int32              `json:"retry_count"`
	WorkflowID pgtype.UUID        `json:"workflow_id"`
}

type ListTasksByDAGIdsParams 

type ListTasksByDAGIdsParams struct {
	Dagids   []pgtype.UUID `json:"dagids"`
	Tenantid pgtype.UUID   `json:"tenantid"`
}

type ListTasksByDAGIdsRow 

type ListTasksByDAGIdsRow struct {
	DagID          int64              `json:"dag_id"`
	DagInsertedAt  pgtype.Timestamptz `json:"dag_inserted_at"`
	TaskID         int64              `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz `json:"task_inserted_at"`
	DagExternalID  pgtype.UUID        `json:"dag_external_id"`
}

type ListTasksByExternalIdsParams 

type ListTasksByExternalIdsParams struct {
	Externalids []pgtype.UUID `json:"externalids"`
	Tenantid    pgtype.UUID   `json:"tenantid"`
}

type ListTasksByExternalIdsRow 

type ListTasksByExternalIdsRow struct {
	TenantID   pgtype.UUID        `json:"tenant_id"`
	TaskID     pgtype.Int8        `json:"task_id"`
	InsertedAt pgtype.Timestamptz `json:"inserted_at"`
}

type ListTasksForReplayParams 

type ListTasksForReplayParams struct {
	Taskids         []int64              `json:"taskids"`
	Taskinsertedats []pgtype.Timestamptz `json:"taskinsertedats"`
	Tenantid        pgtype.UUID          `json:"tenantid"`
}

type ListTasksForReplayRow 

type ListTasksForReplayRow struct {
	ID                   int64              `json:"id"`
	InsertedAt           pgtype.Timestamptz `json:"inserted_at"`
	RetryCount           int32              `json:"retry_count"`
	DagID                pgtype.Int8        `json:"dag_id"`
	DagInsertedAt        pgtype.Timestamptz `json:"dag_inserted_at"`
	StepReadableID       string             `json:"step_readable_id"`
	StepID               pgtype.UUID        `json:"step_id"`
	WorkflowID           pgtype.UUID        `json:"workflow_id"`
	ExternalID           pgtype.UUID        `json:"external_id"`
	AdditionalMetadata   []byte             `json:"additional_metadata"`
	ParentTaskExternalID pgtype.UUID        `json:"parent_task_external_id"`
	ParentTaskID         pgtype.Int8        `json:"parent_task_id"`
	ParentTaskInsertedAt pgtype.Timestamptz `json:"parent_task_inserted_at"`
	StepIndex            int64              `json:"step_index"`
	ChildIndex           pgtype.Int8        `json:"child_index"`
	ChildKey             pgtype.Text        `json:"child_key"`
	JobKind              JobKind            `json:"jobKind"`
	Parents              []pgtype.UUID      `json:"parents"`
}

type ListTasksOlapParams 

type ListTasksOlapParams struct {
	Tenantid    pgtype.UUID        `json:"tenantid"`
	Since       pgtype.Timestamptz `json:"since"`
	Statuses    []string           `json:"statuses"`
	Until       pgtype.Timestamptz `json:"until"`
	WorkflowIds []pgtype.UUID      `json:"workflowIds"`
	WorkerId    pgtype.UUID        `json:"workerId"`
	Keys        []string           `json:"keys"`
	Values      []string           `json:"values"`
	Taskoffset  int32              `json:"taskoffset"`
	Tasklimit   int32              `json:"tasklimit"`
}

type ListTasksOlapRow 

type ListTasksOlapRow struct {
	ID         int64              `json:"id"`
	InsertedAt pgtype.Timestamptz `json:"inserted_at"`
}

type ListTasksParams 

type ListTasksParams struct {
	TenantID pgtype.UUID `json:"tenant_id"`
	Ids      []int64     `json:"ids"`
}

type ListWorkersWithSlotCountParams 

type ListWorkersWithSlotCountParams struct {
	Tenantid           pgtype.UUID      `json:"tenantid"`
	ActionId           pgtype.Text      `json:"actionId"`
	LastHeartbeatAfter pgtype.Timestamp `json:"lastHeartbeatAfter"`
	Assignable         pgtype.Bool      `json:"assignable"`
}

type ListWorkersWithSlotCountRow 

type ListWorkersWithSlotCountRow struct {
	Worker         Worker      `json:"worker"`
	WebhookUrl     pgtype.Text `json:"webhookUrl"`
	WebhookId      pgtype.UUID `json:"webhookId"`
	RemainingSlots int32       `json:"remainingSlots"`
}

type ListWorkflowNamesByIdsRow 

type ListWorkflowNamesByIdsRow struct {
	ID   pgtype.UUID `json:"id"`
	Name string      `json:"name"`
}

type ListWorkflowRunDisplayNamesParams 

type ListWorkflowRunDisplayNamesParams struct {
	Externalids []pgtype.UUID `json:"externalids"`
	Tenantid    pgtype.UUID   `json:"tenantid"`
}

type ListWorkflowRunDisplayNamesRow 

type ListWorkflowRunDisplayNamesRow struct {
	ExternalID  pgtype.UUID        `json:"external_id"`
	DisplayName string             `json:"display_name"`
	InsertedAt  pgtype.Timestamptz `json:"inserted_at"`
}

type ListWorkflowsByNamesParams 

type ListWorkflowsByNamesParams struct {
	Tenantid      pgtype.UUID `json:"tenantid"`
	Workflownames []string    `json:"workflownames"`
}

type ListWorkflowsByNamesRow 

type ListWorkflowsByNamesRow struct {
	WorkflowId        pgtype.UUID `json:"workflowId"`
	WorkflowVersionId pgtype.UUID `json:"workflowVersionId"`
	WorkflowName      string      `json:"workflowName"`
}

type ListWorkflowsForEventsParams 

type ListWorkflowsForEventsParams struct {
	Eventkeys []string    `json:"eventkeys"`
	Tenantid  pgtype.UUID `json:"tenantid"`
}

type ListWorkflowsForEventsRow 

type ListWorkflowsForEventsRow struct {
	WorkflowVersionId pgtype.UUID `json:"workflowVersionId"`
	WorkflowId        pgtype.UUID `json:"workflowId"`
	WorkflowName      string      `json:"workflowName"`
	EventKey          string      `json:"eventKey"`
}

type LockDAGsForReplayParams 

type LockDAGsForReplayParams struct {
	Dagids   []int64     `json:"dagids"`
	Tenantid pgtype.UUID `json:"tenantid"`
}

type LockSignalCreatedEventsParams 

type LockSignalCreatedEventsParams struct {
	Tenantid        pgtype.UUID          `json:"tenantid"`
	Taskids         []int64              `json:"taskids"`
	Taskinsertedats []pgtype.Timestamptz `json:"taskinsertedats"`
	Eventkeys       []string             `json:"eventkeys"`
}

type LockSignalCreatedEventsRow 

type LockSignalCreatedEventsRow struct {
	ID       int64       `json:"id"`
	EventKey pgtype.Text `json:"event_key"`
	Data     []byte      `json:"data"`
}

type LogLine 

type LogLine struct {
	ID        int64            `json:"id"`
	CreatedAt pgtype.Timestamp `json:"createdAt"`
	TenantId  pgtype.UUID      `json:"tenantId"`
	StepRunId pgtype.UUID      `json:"stepRunId"`
	Message   string           `json:"message"`
	Level     LogLineLevel     `json:"level"`
	Metadata  []byte           `json:"metadata"`
}

type LogLineLevel 

type LogLineLevel string
const (
	LogLineLevelDEBUG LogLineLevel = "DEBUG"
	LogLineLevelINFO  LogLineLevel = "INFO"
	LogLineLevelWARN  LogLineLevel = "WARN"
	LogLineLevelERROR LogLineLevel = "ERROR"
)

func (*LogLineLevel) Scan 

func (e *LogLineLevel) Scan(src interface{}) error

type LookupExternalIdsParams 

type LookupExternalIdsParams struct {
	Externalids []pgtype.UUID `json:"externalids"`
	Tenantid    pgtype.UUID   `json:"tenantid"`
}

type ManualSlotReleaseParams 

type ManualSlotReleaseParams struct {
	Externalid pgtype.UUID `json:"externalid"`
	Tenantid   pgtype.UUID `json:"tenantid"`
}

type MessageQueue 

type MessageQueue struct {
	Name                string           `json:"name"`
	LastActive          pgtype.Timestamp `json:"lastActive"`
	Durable             bool             `json:"durable"`
	AutoDeleted         bool             `json:"autoDeleted"`
	Exclusive           bool             `json:"exclusive"`
	ExclusiveConsumerId pgtype.UUID      `json:"exclusiveConsumerId"`
}

type MessageQueueItem 

type MessageQueueItem struct {
	ID        int64                  `json:"id"`
	Payload   []byte                 `json:"payload"`
	ReadAfter pgtype.Timestamp       `json:"readAfter"`
	ExpiresAt pgtype.Timestamp       `json:"expiresAt"`
	QueueId   pgtype.Text            `json:"queueId"`
	Status    MessageQueueItemStatus `json:"status"`
}

type MessageQueueItemStatus 

type MessageQueueItemStatus string
const (
	MessageQueueItemStatusPENDING  MessageQueueItemStatus = "PENDING"
	MessageQueueItemStatusASSIGNED MessageQueueItemStatus = "ASSIGNED"
)

func (*MessageQueueItemStatus) Scan 

func (e *MessageQueueItemStatus) Scan(src interface{}) error

type NullConcurrencyLimitStrategy 

type NullConcurrencyLimitStrategy struct {
	ConcurrencyLimitStrategy ConcurrencyLimitStrategy `json:"ConcurrencyLimitStrategy"`
	Valid                    bool                     `json:"valid"` // Valid is true if ConcurrencyLimitStrategy is not NULL
}

func (*NullConcurrencyLimitStrategy) Scan 

func (ns *NullConcurrencyLimitStrategy) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullConcurrencyLimitStrategy) Value 

func (ns NullConcurrencyLimitStrategy) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullInternalQueue 

type NullInternalQueue struct {
	InternalQueue InternalQueue `json:"InternalQueue"`
	Valid         bool          `json:"valid"` // Valid is true if InternalQueue is not NULL
}

func (*NullInternalQueue) Scan 

func (ns *NullInternalQueue) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullInternalQueue) Value 

func (ns NullInternalQueue) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullInviteLinkStatus 

type NullInviteLinkStatus struct {
	InviteLinkStatus InviteLinkStatus `json:"InviteLinkStatus"`
	Valid            bool             `json:"valid"` // Valid is true if InviteLinkStatus is not NULL
}

func (*NullInviteLinkStatus) Scan 

func (ns *NullInviteLinkStatus) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullInviteLinkStatus) Value 

func (ns NullInviteLinkStatus) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullJobKind 

type NullJobKind struct {
	JobKind JobKind `json:"JobKind"`
	Valid   bool    `json:"valid"` // Valid is true if JobKind is not NULL
}

func (*NullJobKind) Scan 

func (ns *NullJobKind) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullJobKind) Value 

func (ns NullJobKind) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullJobRunStatus 

type NullJobRunStatus struct {
	JobRunStatus JobRunStatus `json:"JobRunStatus"`
	Valid        bool         `json:"valid"` // Valid is true if JobRunStatus is not NULL
}

func (*NullJobRunStatus) Scan 

func (ns *NullJobRunStatus) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullJobRunStatus) Value 

func (ns NullJobRunStatus) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullLeaseKind 

type NullLeaseKind struct {
	LeaseKind LeaseKind `json:"LeaseKind"`
	Valid     bool      `json:"valid"` // Valid is true if LeaseKind is not NULL
}

func (*NullLeaseKind) Scan 

func (ns *NullLeaseKind) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullLeaseKind) Value 

func (ns NullLeaseKind) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullLimitResource 

type NullLimitResource struct {
	LimitResource LimitResource `json:"LimitResource"`
	Valid         bool          `json:"valid"` // Valid is true if LimitResource is not NULL
}

func (*NullLimitResource) Scan 

func (ns *NullLimitResource) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullLimitResource) Value 

func (ns NullLimitResource) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullLogLineLevel 

type NullLogLineLevel struct {
	LogLineLevel LogLineLevel `json:"LogLineLevel"`
	Valid        bool         `json:"valid"` // Valid is true if LogLineLevel is not NULL
}

func (*NullLogLineLevel) Scan 

func (ns *NullLogLineLevel) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullLogLineLevel) Value 

func (ns NullLogLineLevel) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullMessageQueueItemStatus 

type NullMessageQueueItemStatus struct {
	MessageQueueItemStatus MessageQueueItemStatus `json:"MessageQueueItemStatus"`
	Valid                  bool                   `json:"valid"` // Valid is true if MessageQueueItemStatus is not NULL
}

func (*NullMessageQueueItemStatus) Scan 

func (ns *NullMessageQueueItemStatus) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullMessageQueueItemStatus) Value 

func (ns NullMessageQueueItemStatus) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullStepExpressionKind 

type NullStepExpressionKind struct {
	StepExpressionKind StepExpressionKind `json:"StepExpressionKind"`
	Valid              bool               `json:"valid"` // Valid is true if StepExpressionKind is not NULL
}

func (*NullStepExpressionKind) Scan 

func (ns *NullStepExpressionKind) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullStepExpressionKind) Value 

func (ns NullStepExpressionKind) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullStepRateLimitKind 

type NullStepRateLimitKind struct {
	StepRateLimitKind StepRateLimitKind `json:"StepRateLimitKind"`
	Valid             bool              `json:"valid"` // Valid is true if StepRateLimitKind is not NULL
}

func (*NullStepRateLimitKind) Scan 

func (ns *NullStepRateLimitKind) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullStepRateLimitKind) Value 

func (ns NullStepRateLimitKind) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullStepRunEventReason 

type NullStepRunEventReason struct {
	StepRunEventReason StepRunEventReason `json:"StepRunEventReason"`
	Valid              bool               `json:"valid"` // Valid is true if StepRunEventReason is not NULL
}

func (*NullStepRunEventReason) Scan 

func (ns *NullStepRunEventReason) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullStepRunEventReason) Value 

func (ns NullStepRunEventReason) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullStepRunEventSeverity 

type NullStepRunEventSeverity struct {
	StepRunEventSeverity StepRunEventSeverity `json:"StepRunEventSeverity"`
	Valid                bool                 `json:"valid"` // Valid is true if StepRunEventSeverity is not NULL
}

func (*NullStepRunEventSeverity) Scan 

func (ns *NullStepRunEventSeverity) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullStepRunEventSeverity) Value 

func (ns NullStepRunEventSeverity) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullStepRunStatus 

type NullStepRunStatus struct {
	StepRunStatus StepRunStatus `json:"StepRunStatus"`
	Valid         bool          `json:"valid"` // Valid is true if StepRunStatus is not NULL
}

func (*NullStepRunStatus) Scan 

func (ns *NullStepRunStatus) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullStepRunStatus) Value 

func (ns NullStepRunStatus) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullStickyStrategy 

type NullStickyStrategy struct {
	StickyStrategy StickyStrategy `json:"StickyStrategy"`
	Valid          bool           `json:"valid"` // Valid is true if StickyStrategy is not NULL
}

func (*NullStickyStrategy) Scan 

func (ns *NullStickyStrategy) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullStickyStrategy) Value 

func (ns NullStickyStrategy) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullTenantMajorEngineVersion 

type NullTenantMajorEngineVersion struct {
	TenantMajorEngineVersion TenantMajorEngineVersion `json:"TenantMajorEngineVersion"`
	Valid                    bool                     `json:"valid"` // Valid is true if TenantMajorEngineVersion is not NULL
}

func (*NullTenantMajorEngineVersion) Scan 

func (ns *NullTenantMajorEngineVersion) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullTenantMajorEngineVersion) Value 

func (ns NullTenantMajorEngineVersion) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullTenantMemberRole 

type NullTenantMemberRole struct {
	TenantMemberRole TenantMemberRole `json:"TenantMemberRole"`
	Valid            bool             `json:"valid"` // Valid is true if TenantMemberRole is not NULL
}

func (*NullTenantMemberRole) Scan 

func (ns *NullTenantMemberRole) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullTenantMemberRole) Value 

func (ns NullTenantMemberRole) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullTenantResourceLimitAlertType 

type NullTenantResourceLimitAlertType struct {
	TenantResourceLimitAlertType TenantResourceLimitAlertType `json:"TenantResourceLimitAlertType"`
	Valid                        bool                         `json:"valid"` // Valid is true if TenantResourceLimitAlertType is not NULL
}

func (*NullTenantResourceLimitAlertType) Scan 

func (ns *NullTenantResourceLimitAlertType) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullTenantResourceLimitAlertType) Value 

func (ns NullTenantResourceLimitAlertType) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1ConcurrencyStrategy 

type NullV1ConcurrencyStrategy struct {
	V1ConcurrencyStrategy V1ConcurrencyStrategy `json:"v1_concurrency_strategy"`
	Valid                 bool                  `json:"valid"` // Valid is true if V1ConcurrencyStrategy is not NULL
}

func (*NullV1ConcurrencyStrategy) Scan 

func (ns *NullV1ConcurrencyStrategy) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1ConcurrencyStrategy) Value 

func (ns NullV1ConcurrencyStrategy) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1EventType 

type NullV1EventType struct {
	V1EventType V1EventType `json:"v1_event_type"`
	Valid       bool        `json:"valid"` // Valid is true if V1EventType is not NULL
}

func (*NullV1EventType) Scan 

func (ns *NullV1EventType) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1EventType) Value 

func (ns NullV1EventType) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1EventTypeOlap 

type NullV1EventTypeOlap struct {
	V1EventTypeOlap V1EventTypeOlap `json:"v1_event_type_olap"`
	Valid           bool            `json:"valid"` // Valid is true if V1EventTypeOlap is not NULL
}

func (*NullV1EventTypeOlap) Scan 

func (ns *NullV1EventTypeOlap) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1EventTypeOlap) Value 

func (ns NullV1EventTypeOlap) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1LogLineLevel 

type NullV1LogLineLevel struct {
	V1LogLineLevel V1LogLineLevel `json:"v1_log_line_level"`
	Valid          bool           `json:"valid"` // Valid is true if V1LogLineLevel is not NULL
}

func (*NullV1LogLineLevel) Scan 

func (ns *NullV1LogLineLevel) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1LogLineLevel) Value 

func (ns NullV1LogLineLevel) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1MatchConditionAction 

type NullV1MatchConditionAction struct {
	V1MatchConditionAction V1MatchConditionAction `json:"v1_match_condition_action"`
	Valid                  bool                   `json:"valid"` // Valid is true if V1MatchConditionAction is not NULL
}

func (*NullV1MatchConditionAction) Scan 

func (ns *NullV1MatchConditionAction) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1MatchConditionAction) Value 

func (ns NullV1MatchConditionAction) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1MatchKind 

type NullV1MatchKind struct {
	V1MatchKind V1MatchKind `json:"v1_match_kind"`
	Valid       bool        `json:"valid"` // Valid is true if V1MatchKind is not NULL
}

func (*NullV1MatchKind) Scan 

func (ns *NullV1MatchKind) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1MatchKind) Value 

func (ns NullV1MatchKind) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1ReadableStatusOlap 

type NullV1ReadableStatusOlap struct {
	V1ReadableStatusOlap V1ReadableStatusOlap `json:"v1_readable_status_olap"`
	Valid                bool                 `json:"valid"` // Valid is true if V1ReadableStatusOlap is not NULL
}

func (*NullV1ReadableStatusOlap) Scan 

func (ns *NullV1ReadableStatusOlap) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1ReadableStatusOlap) Value 

func (ns NullV1ReadableStatusOlap) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1RunKind 

type NullV1RunKind struct {
	V1RunKind V1RunKind `json:"v1_run_kind"`
	Valid     bool      `json:"valid"` // Valid is true if V1RunKind is not NULL
}

func (*NullV1RunKind) Scan 

func (ns *NullV1RunKind) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1RunKind) Value 

func (ns NullV1RunKind) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1StatusKind 

type NullV1StatusKind struct {
	V1StatusKind V1StatusKind `json:"v1_status_kind"`
	Valid        bool         `json:"valid"` // Valid is true if V1StatusKind is not NULL
}

func (*NullV1StatusKind) Scan 

func (ns *NullV1StatusKind) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1StatusKind) Value 

func (ns NullV1StatusKind) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1StickyStrategy 

type NullV1StickyStrategy struct {
	V1StickyStrategy V1StickyStrategy `json:"v1_sticky_strategy"`
	Valid            bool             `json:"valid"` // Valid is true if V1StickyStrategy is not NULL
}

func (*NullV1StickyStrategy) Scan 

func (ns *NullV1StickyStrategy) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1StickyStrategy) Value 

func (ns NullV1StickyStrategy) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1StickyStrategyOlap 

type NullV1StickyStrategyOlap struct {
	V1StickyStrategyOlap V1StickyStrategyOlap `json:"v1_sticky_strategy_olap"`
	Valid                bool                 `json:"valid"` // Valid is true if V1StickyStrategyOlap is not NULL
}

func (*NullV1StickyStrategyOlap) Scan 

func (ns *NullV1StickyStrategyOlap) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1StickyStrategyOlap) Value 

func (ns NullV1StickyStrategyOlap) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1TaskEventType 

type NullV1TaskEventType struct {
	V1TaskEventType V1TaskEventType `json:"v1_task_event_type"`
	Valid           bool            `json:"valid"` // Valid is true if V1TaskEventType is not NULL
}

func (*NullV1TaskEventType) Scan 

func (ns *NullV1TaskEventType) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1TaskEventType) Value 

func (ns NullV1TaskEventType) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullV1TaskInitialState 

type NullV1TaskInitialState struct {
	V1TaskInitialState V1TaskInitialState `json:"v1_task_initial_state"`
	Valid              bool               `json:"valid"` // Valid is true if V1TaskInitialState is not NULL
}

func (*NullV1TaskInitialState) Scan 

func (ns *NullV1TaskInitialState) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullV1TaskInitialState) Value 

func (ns NullV1TaskInitialState) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullVcsProvider 

type NullVcsProvider struct {
	VcsProvider VcsProvider `json:"VcsProvider"`
	Valid       bool        `json:"valid"` // Valid is true if VcsProvider is not NULL
}

func (*NullVcsProvider) Scan 

func (ns *NullVcsProvider) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullVcsProvider) Value 

func (ns NullVcsProvider) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullWebhookWorkerRequestMethod 

type NullWebhookWorkerRequestMethod struct {
	WebhookWorkerRequestMethod WebhookWorkerRequestMethod `json:"WebhookWorkerRequestMethod"`
	Valid                      bool                       `json:"valid"` // Valid is true if WebhookWorkerRequestMethod is not NULL
}

func (*NullWebhookWorkerRequestMethod) Scan 

func (ns *NullWebhookWorkerRequestMethod) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullWebhookWorkerRequestMethod) Value 

func (ns NullWebhookWorkerRequestMethod) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullWorkerLabelComparator 

type NullWorkerLabelComparator struct {
	WorkerLabelComparator WorkerLabelComparator `json:"WorkerLabelComparator"`
	Valid                 bool                  `json:"valid"` // Valid is true if WorkerLabelComparator is not NULL
}

func (*NullWorkerLabelComparator) Scan 

func (ns *NullWorkerLabelComparator) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullWorkerLabelComparator) Value 

func (ns NullWorkerLabelComparator) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullWorkerSDKS 

type NullWorkerSDKS struct {
	WorkerSDKS WorkerSDKS `json:"WorkerSDKS"`
	Valid      bool       `json:"valid"` // Valid is true if WorkerSDKS is not NULL
}

func (*NullWorkerSDKS) Scan 

func (ns *NullWorkerSDKS) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullWorkerSDKS) Value 

func (ns NullWorkerSDKS) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullWorkerType 

type NullWorkerType struct {
	WorkerType WorkerType `json:"WorkerType"`
	Valid      bool       `json:"valid"` // Valid is true if WorkerType is not NULL
}

func (*NullWorkerType) Scan 

func (ns *NullWorkerType) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullWorkerType) Value 

func (ns NullWorkerType) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullWorkflowKind 

type NullWorkflowKind struct {
	WorkflowKind WorkflowKind `json:"WorkflowKind"`
	Valid        bool         `json:"valid"` // Valid is true if WorkflowKind is not NULL
}

func (*NullWorkflowKind) Scan 

func (ns *NullWorkflowKind) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullWorkflowKind) Value 

func (ns NullWorkflowKind) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullWorkflowRunStatus 

type NullWorkflowRunStatus struct {
	WorkflowRunStatus WorkflowRunStatus `json:"WorkflowRunStatus"`
	Valid             bool              `json:"valid"` // Valid is true if WorkflowRunStatus is not NULL
}

func (*NullWorkflowRunStatus) Scan 

func (ns *NullWorkflowRunStatus) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullWorkflowRunStatus) Value 

func (ns NullWorkflowRunStatus) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullWorkflowTriggerCronRefMethods 

type NullWorkflowTriggerCronRefMethods struct {
	WorkflowTriggerCronRefMethods WorkflowTriggerCronRefMethods `json:"WorkflowTriggerCronRefMethods"`
	Valid                         bool                          `json:"valid"` // Valid is true if WorkflowTriggerCronRefMethods is not NULL
}

func (*NullWorkflowTriggerCronRefMethods) Scan 

func (ns *NullWorkflowTriggerCronRefMethods) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullWorkflowTriggerCronRefMethods) Value 

func (ns NullWorkflowTriggerCronRefMethods) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullWorkflowTriggerScheduledRefMethods 

type NullWorkflowTriggerScheduledRefMethods struct {
	WorkflowTriggerScheduledRefMethods WorkflowTriggerScheduledRefMethods `json:"WorkflowTriggerScheduledRefMethods"`
	Valid                              bool                               `json:"valid"` // Valid is true if WorkflowTriggerScheduledRefMethods is not NULL
}

func (*NullWorkflowTriggerScheduledRefMethods) Scan 

func (ns *NullWorkflowTriggerScheduledRefMethods) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullWorkflowTriggerScheduledRefMethods) Value 

func (ns NullWorkflowTriggerScheduledRefMethods) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type PopulateDAGMetadataParams 

type PopulateDAGMetadataParams struct {
	Ids         []int64              `json:"ids"`
	Insertedats []pgtype.Timestamptz `json:"insertedats"`
	Tenantid    pgtype.UUID          `json:"tenantid"`
}

type PopulateDAGMetadataRow 

type PopulateDAGMetadataRow struct {
	DagID              int64                `json:"dag_id"`
	RunID              int64                `json:"run_id"`
	TenantID           pgtype.UUID          `json:"tenant_id"`
	InsertedAt         pgtype.Timestamptz   `json:"inserted_at"`
	ExternalID         pgtype.UUID          `json:"external_id"`
	ReadableStatus     V1ReadableStatusOlap `json:"readable_status"`
	Kind               V1RunKind            `json:"kind"`
	WorkflowID         pgtype.UUID          `json:"workflow_id"`
	DisplayName        string               `json:"display_name"`
	Input              []byte               `json:"input"`
	AdditionalMetadata []byte               `json:"additional_metadata"`
	WorkflowVersionID  pgtype.UUID          `json:"workflow_version_id"`
	CreatedAt          pgtype.Timestamptz   `json:"created_at"`
	StartedAt          pgtype.Timestamptz   `json:"started_at"`
	FinishedAt         pgtype.Timestamptz   `json:"finished_at"`
	ErrorMessage       pgtype.Text          `json:"error_message"`
	Output             []byte               `json:"output"`
}

type PopulateSingleTaskRunDataParams 

type PopulateSingleTaskRunDataParams struct {
	Tenantid       pgtype.UUID        `json:"tenantid"`
	Taskid         int64              `json:"taskid"`
	Taskinsertedat pgtype.Timestamptz `json:"taskinsertedat"`
}

type PopulateSingleTaskRunDataRow 

type PopulateSingleTaskRunDataRow struct {
	TenantID             pgtype.UUID          `json:"tenant_id"`
	ID                   int64                `json:"id"`
	InsertedAt           pgtype.Timestamptz   `json:"inserted_at"`
	ExternalID           pgtype.UUID          `json:"external_id"`
	Queue                string               `json:"queue"`
	ActionID             string               `json:"action_id"`
	StepID               pgtype.UUID          `json:"step_id"`
	WorkflowID           pgtype.UUID          `json:"workflow_id"`
	WorkflowVersionID    pgtype.UUID          `json:"workflow_version_id"`
	WorkflowRunID        pgtype.UUID          `json:"workflow_run_id"`
	ScheduleTimeout      string               `json:"schedule_timeout"`
	StepTimeout          pgtype.Text          `json:"step_timeout"`
	Priority             pgtype.Int4          `json:"priority"`
	Sticky               V1StickyStrategyOlap `json:"sticky"`
	DesiredWorkerID      pgtype.UUID          `json:"desired_worker_id"`
	DisplayName          string               `json:"display_name"`
	Input                []byte               `json:"input"`
	AdditionalMetadata   []byte               `json:"additional_metadata"`
	ReadableStatus       V1ReadableStatusOlap `json:"readable_status"`
	LatestRetryCount     int32                `json:"latest_retry_count"`
	LatestWorkerID       pgtype.UUID          `json:"latest_worker_id"`
	DagID                pgtype.Int8          `json:"dag_id"`
	DagInsertedAt        pgtype.Timestamptz   `json:"dag_inserted_at"`
	ParentTaskExternalID pgtype.UUID          `json:"parent_task_external_id"`
	Status               V1ReadableStatusOlap `json:"status"`
	FinishedAt           pgtype.Timestamptz   `json:"finished_at"`
	StartedAt            pgtype.Timestamptz   `json:"started_at"`
	Output               []byte               `json:"output"`
	ErrorMessage         pgtype.Text          `json:"error_message"`
	SpawnedChildren      pgtype.Int8          `json:"spawned_children"`
}

type PopulateTaskRunDataParams 

type PopulateTaskRunDataParams struct {
	Taskids         []int64              `json:"taskids"`
	Taskinsertedats []pgtype.Timestamptz `json:"taskinsertedats"`
	Tenantid        pgtype.UUID          `json:"tenantid"`
}

type PopulateTaskRunDataRow 

type PopulateTaskRunDataRow struct {
	TenantID           pgtype.UUID          `json:"tenant_id"`
	ID                 int64                `json:"id"`
	InsertedAt         pgtype.Timestamptz   `json:"inserted_at"`
	ExternalID         pgtype.UUID          `json:"external_id"`
	Queue              string               `json:"queue"`
	ActionID           string               `json:"action_id"`
	StepID             pgtype.UUID          `json:"step_id"`
	WorkflowID         pgtype.UUID          `json:"workflow_id"`
	ScheduleTimeout    string               `json:"schedule_timeout"`
	StepTimeout        pgtype.Text          `json:"step_timeout"`
	Priority           pgtype.Int4          `json:"priority"`
	Sticky             V1StickyStrategyOlap `json:"sticky"`
	DisplayName        string               `json:"display_name"`
	AdditionalMetadata []byte               `json:"additional_metadata"`
	Input              []byte               `json:"input"`
	Status             V1ReadableStatusOlap `json:"status"`
	FinishedAt         pgtype.Timestamptz   `json:"finished_at"`
	StartedAt          pgtype.Timestamptz   `json:"started_at"`
	ErrorMessage       pgtype.Text          `json:"error_message"`
	Output             []byte               `json:"output"`
}

type PreflightCheckDAGsForReplayParams 

type PreflightCheckDAGsForReplayParams struct {
	Dagids   []int64     `json:"dagids"`
	Tenantid pgtype.UUID `json:"tenantid"`
}

type PreflightCheckDAGsForReplayRow 

type PreflightCheckDAGsForReplayRow struct {
	ID         int64              `json:"id"`
	ExternalID pgtype.UUID        `json:"external_id"`
	InsertedAt pgtype.Timestamptz `json:"inserted_at"`
	StepCount  int64              `json:"step_count"`
	TaskCount  int64              `json:"task_count"`
}

type PreflightCheckTasksForReplayParams 

type PreflightCheckTasksForReplayParams struct {
	Tenantid        pgtype.UUID          `json:"tenantid"`
	Taskids         []int64              `json:"taskids"`
	Taskinsertedats []pgtype.Timestamptz `json:"taskinsertedats"`
}

type PreflightCheckTasksForReplayRow 

type PreflightCheckTasksForReplayRow struct {
	ID    int64       `json:"id"`
	DagID pgtype.Int8 `json:"dag_id"`
}

type ProcessRetryQueueItemsParams 

type ProcessRetryQueueItemsParams struct {
	Tenantid pgtype.UUID `json:"tenantid"`
	Limit    pgtype.Int4 `json:"limit"`
}

type ProcessTaskReassignmentsParams 

type ProcessTaskReassignmentsParams struct {
	Tenantid           pgtype.UUID `json:"tenantid"`
	Limit              pgtype.Int4 `json:"limit"`
	Maxinternalretries int32       `json:"maxinternalretries"`
}

type ProcessTaskReassignmentsRow 

type ProcessTaskReassignmentsRow struct {
	ID         int64              `json:"id"`
	InsertedAt pgtype.Timestamptz `json:"inserted_at"`
	RetryCount int32              `json:"retry_count"`
	WorkerID   pgtype.UUID        `json:"worker_id"`
	Operation  string             `json:"operation"`
}

type ProcessTaskTimeoutsParams 

type ProcessTaskTimeoutsParams struct {
	Tenantid pgtype.UUID `json:"tenantid"`
	Limit    pgtype.Int4 `json:"limit"`
}

type ProcessTaskTimeoutsRow 

type ProcessTaskTimeoutsRow struct {
	ID            int64              `json:"id"`
	InsertedAt    pgtype.Timestamptz `json:"inserted_at"`
	RetryCount    int32              `json:"retry_count"`
	StepID        pgtype.UUID        `json:"step_id"`
	ExternalID    pgtype.UUID        `json:"external_id"`
	WorkflowRunID pgtype.UUID        `json:"workflow_run_id"`
	WorkerID      pgtype.UUID        `json:"worker_id"`
}

type Queries 

type Queries struct {
}

func New 

func New() *Queries

func (*Queries) AcquireOrExtendLeases 

func (q *Queries) AcquireOrExtendLeases(ctx context.Context, db DBTX, arg AcquireOrExtendLeasesParams) ([]*Lease, error)

Attempts to acquire leases for a set of resources, and extends the leases if we already have them. Returns the acquired leases. On conflict, acquire the lease if the existing lease has expired.

func (*Queries) BulkQueueItems 

func (q *Queries) BulkQueueItems(ctx context.Context, db DBTX, ids []int64) ([]int64, error)

func (*Queries) BulkUpdateRateLimits 

func (q *Queries) BulkUpdateRateLimits(ctx context.Context, db DBTX, arg BulkUpdateRateLimitsParams) ([]*RateLimit, error)

func (*Queries) CheckStrategyActive 

func (q *Queries) CheckStrategyActive(ctx context.Context, db DBTX, arg CheckStrategyActiveParams) (bool, error)

A strategy is active if the workflow is not deleted, and it is attached to the latest workflow version or it has at least one concurrency slot that is not filled.

func (*Queries) ConcurrencyAdvisoryLock 

func (q *Queries) ConcurrencyAdvisoryLock(ctx context.Context, db DBTX, key int64) error

func (*Queries) CountTasks 

func (q *Queries) CountTasks(ctx context.Context, db DBTX, arg CountTasksParams) (int64, error)

func (*Queries) CountWorkflowRuns 

func (q *Queries) CountWorkflowRuns(ctx context.Context, db DBTX, arg CountWorkflowRunsParams) (int64, error)

func (*Queries) CreateDAGData 

func (q *Queries) CreateDAGData(ctx context.Context, db DBTX, arg []CreateDAGDataParams) (int64, error)

func (*Queries) CreateDAGs 

func (q *Queries) CreateDAGs(ctx context.Context, db DBTX, arg CreateDAGsParams) ([]*V1Dag, error)

func (*Queries) CreateDAGsOLAP 

func (q *Queries) CreateDAGsOLAP(ctx context.Context, db DBTX, arg []CreateDAGsOLAPParams) (int64, error)

func (*Queries) CreateMatchConditions 

func (q *Queries) CreateMatchConditions(ctx context.Context, db DBTX, arg []CreateMatchConditionsParams) (int64, error)

func (*Queries) CreateMatchesForDAGTriggers 

func (q *Queries) CreateMatchesForDAGTriggers(ctx context.Context, db DBTX, arg CreateMatchesForDAGTriggersParams) ([]*V1Match, error)

func (*Queries) CreateMatchesForSignalTriggers 

func (q *Queries) CreateMatchesForSignalTriggers(ctx context.Context, db DBTX, arg CreateMatchesForSignalTriggersParams) ([]*V1Match, error)

func (*Queries) CreateOLAPPartitions 

func (q *Queries) CreateOLAPPartitions(ctx context.Context, db DBTX, arg CreateOLAPPartitionsParams) error

func (*Queries) CreatePartitions 

func (q *Queries) CreatePartitions(ctx context.Context, db DBTX, date pgtype.Date) error

func (*Queries) CreateTaskEvents 

func (q *Queries) CreateTaskEvents(ctx context.Context, db DBTX, arg CreateTaskEventsParams) error

We get a FOR UPDATE lock on tasks to prevent concurrent writes to the task events tables for each task

func (*Queries) CreateTaskEventsOLAP 

func (q *Queries) CreateTaskEventsOLAP(ctx context.Context, db DBTX, arg []CreateTaskEventsOLAPParams) (int64, error)

func (*Queries) CreateTaskEventsOLAPTmp 

func (q *Queries) CreateTaskEventsOLAPTmp(ctx context.Context, db DBTX, arg []CreateTaskEventsOLAPTmpParams) (int64, error)

func (*Queries) CreateTaskExpressionEvals 

func (q *Queries) CreateTaskExpressionEvals(ctx context.Context, db DBTX, arg CreateTaskExpressionEvalsParams) error

func (*Queries) CreateTasks 

func (q *Queries) CreateTasks(ctx context.Context, db DBTX, arg CreateTasksParams) ([]*V1Task, error)

func (*Queries) CreateTasksOLAP 

func (q *Queries) CreateTasksOLAP(ctx context.Context, db DBTX, arg []CreateTasksOLAPParams) (int64, error)

func (*Queries) DeleteMatchingSignalEvents 

func (q *Queries) DeleteMatchingSignalEvents(ctx context.Context, db DBTX, arg DeleteMatchingSignalEventsParams) error

func (*Queries) DeleteTasksFromQueue 

func (q *Queries) DeleteTasksFromQueue(ctx context.Context, db DBTX, arg DeleteTasksFromQueueParams) error

func (*Queries) FailTaskAppFailure 

func (q *Queries) FailTaskAppFailure(ctx context.Context, db DBTX, arg FailTaskAppFailureParams) ([]*FailTaskAppFailureRow, error)

Fails a task due to an application-level error

func (*Queries) FailTaskInternalFailure 

func (q *Queries) FailTaskInternalFailure(ctx context.Context, db DBTX, arg FailTaskInternalFailureParams) ([]*FailTaskInternalFailureRow, error)

Fails a task due to an application-level error

func (*Queries) FetchWorkflowRunIds 

func (q *Queries) FetchWorkflowRunIds(ctx context.Context, db DBTX, arg FetchWorkflowRunIdsParams) ([]*FetchWorkflowRunIdsRow, error)

func (*Queries) FlattenExternalIds 

func (q *Queries) FlattenExternalIds(ctx context.Context, db DBTX, arg FlattenExternalIdsParams) ([]*FlattenExternalIdsRow, error)

Union the tasks from the lookup table with the tasks from the DAGs

func (*Queries) FlattenTasksByExternalIds 

func (q *Queries) FlattenTasksByExternalIds(ctx context.Context, db DBTX, arg FlattenTasksByExternalIdsParams) ([]*FlattenTasksByExternalIdsRow, error)

Get retry counts for each task

func (*Queries) GetDAGData 

func (q *Queries) GetDAGData(ctx context.Context, db DBTX, arg GetDAGDataParams) ([]*GetDAGDataRow, error)

func (*Queries) GetDesiredLabels 

func (q *Queries) GetDesiredLabels(ctx context.Context, db DBTX, stepids []pgtype.UUID) ([]*GetDesiredLabelsRow, error)

func (*Queries) GetLeasesToAcquire 

func (q *Queries) GetLeasesToAcquire(ctx context.Context, db DBTX, arg GetLeasesToAcquireParams) error

func (*Queries) GetMinUnprocessedQueueItemId 

func (q *Queries) GetMinUnprocessedQueueItemId(ctx context.Context, db DBTX, arg GetMinUnprocessedQueueItemIdParams) (int64, error)

func (*Queries) GetQueuedCounts 

func (q *Queries) GetQueuedCounts(ctx context.Context, db DBTX, tenantid pgtype.UUID) ([]*GetQueuedCountsRow, error)

func (*Queries) GetSatisfiedMatchConditions 

func (q *Queries) GetSatisfiedMatchConditions(ctx context.Context, db DBTX, arg GetSatisfiedMatchConditionsParams) ([]int64, error)

NOTE: we have to break this into a separate query because CTEs can't see modified rows on the same target table without using RETURNING.

func (*Queries) GetTaskPointMetrics 

func (q *Queries) GetTaskPointMetrics(ctx context.Context, db DBTX, arg GetTaskPointMetricsParams) ([]*GetTaskPointMetricsRow, error)

func (*Queries) GetTenantStatusMetrics 

func (q *Queries) GetTenantStatusMetrics(ctx context.Context, db DBTX, arg GetTenantStatusMetricsParams) (*GetTenantStatusMetricsRow, error)

func (*Queries) GetWorkerById 

func (q *Queries) GetWorkerById(ctx context.Context, db DBTX, id pgtype.UUID) (*GetWorkerByIdRow, error)

func (*Queries) GetWorkflowRunIdFromDagIdInsertedAt 

func (q *Queries) GetWorkflowRunIdFromDagIdInsertedAt(ctx context.Context, db DBTX, arg GetWorkflowRunIdFromDagIdInsertedAtParams) (pgtype.UUID, error)

func (*Queries) InsertLogLine 

func (q *Queries) InsertLogLine(ctx context.Context, db DBTX, arg []InsertLogLineParams) (int64, error)

func (*Queries) ListActionsForWorkers 

func (q *Queries) ListActionsForWorkers(ctx context.Context, db DBTX, arg ListActionsForWorkersParams) ([]*ListActionsForWorkersRow, error)

func (*Queries) ListActiveConcurrencyStrategies 

func (q *Queries) ListActiveConcurrencyStrategies(ctx context.Context, db DBTX, tenantid pgtype.UUID) ([]*V1StepConcurrency, error)

func (*Queries) ListActiveWorkers 

func (q *Queries) ListActiveWorkers(ctx context.Context, db DBTX, tenantid pgtype.UUID) ([]*ListActiveWorkersRow, error)

func (*Queries) ListAllTasksInDags 

func (q *Queries) ListAllTasksInDags(ctx context.Context, db DBTX, arg ListAllTasksInDagsParams) ([]*ListAllTasksInDagsRow, error)

func (*Queries) ListAvailableSlotsForWorkers 

func (q *Queries) ListAvailableSlotsForWorkers(ctx context.Context, db DBTX, arg ListAvailableSlotsForWorkersParams) ([]*ListAvailableSlotsForWorkersRow, error)

subtract the filled slots from the max runs to get the available slots

func (*Queries) ListConcurrencyStrategiesByStepId 

func (q *Queries) ListConcurrencyStrategiesByStepId(ctx context.Context, db DBTX, arg ListConcurrencyStrategiesByStepIdParams) ([]*V1StepConcurrency, error)

func (*Queries) ListLogLines 

func (q *Queries) ListLogLines(ctx context.Context, db DBTX, arg ListLogLinesParams) ([]*V1LogLine, error)

func (*Queries) ListManyWorkerLabels 

func (q *Queries) ListManyWorkerLabels(ctx context.Context, db DBTX, workerids []pgtype.UUID) ([]*ListManyWorkerLabelsRow, error)

func (*Queries) ListMatchConditionsForEvent 

func (q *Queries) ListMatchConditionsForEvent(ctx context.Context, db DBTX, arg ListMatchConditionsForEventParams) ([]*ListMatchConditionsForEventRow, error)

func (*Queries) ListMatchingSignalEvents 

func (q *Queries) ListMatchingSignalEvents(ctx context.Context, db DBTX, arg ListMatchingSignalEventsParams) ([]*V1TaskEvent, error)

func (*Queries) ListMatchingTaskEvents 

func (q *Queries) ListMatchingTaskEvents(ctx context.Context, db DBTX, arg ListMatchingTaskEventsParams) ([]*ListMatchingTaskEventsRow, error)

Lists the task events for the **latest** retry of a task, or task events which intentionally aren't associated with a retry count (if the retry_count = -1).

func (*Queries) ListOLAPPartitionsBeforeDate 

func (q *Queries) ListOLAPPartitionsBeforeDate(ctx context.Context, db DBTX, date pgtype.Date) ([]*ListOLAPPartitionsBeforeDateRow, error)

func (*Queries) ListPartitionsBeforeDate 

func (q *Queries) ListPartitionsBeforeDate(ctx context.Context, db DBTX, date pgtype.Date) ([]*ListPartitionsBeforeDateRow, error)

func (*Queries) ListQueueItemsForQueue 

func (q *Queries) ListQueueItemsForQueue(ctx context.Context, db DBTX, arg ListQueueItemsForQueueParams) ([]*V1QueueItem, error)

func (*Queries) ListQueues 

func (q *Queries) ListQueues(ctx context.Context, db DBTX, tenantid pgtype.UUID) ([]*V1Queue, error)

func (*Queries) ListRateLimitsForSteps 

func (q *Queries) ListRateLimitsForSteps(ctx context.Context, db DBTX, arg ListRateLimitsForStepsParams) ([]*StepRateLimit, error)

func (*Queries) ListRateLimitsForTenantNoMutate 

func (q *Queries) ListRateLimitsForTenantNoMutate(ctx context.Context, db DBTX, arg ListRateLimitsForTenantNoMutateParams) ([]*ListRateLimitsForTenantNoMutateRow, error)

Returns the same results as ListRateLimitsForTenantWithMutate but does not update the rate limit values

func (*Queries) ListRateLimitsForTenantWithMutate 

func (q *Queries) ListRateLimitsForTenantWithMutate(ctx context.Context, db DBTX, tenantid pgtype.UUID) ([]*ListRateLimitsForTenantWithMutateRow, error)

func (*Queries) ListSemaphoreSlotsWithStateForWorker 

func (q *Queries) ListSemaphoreSlotsWithStateForWorker(ctx context.Context, db DBTX, arg ListSemaphoreSlotsWithStateForWorkerParams) ([]*ListSemaphoreSlotsWithStateForWorkerRow, error)

func (*Queries) ListStepExpressions 

func (q *Queries) ListStepExpressions(ctx context.Context, db DBTX, stepids []pgtype.UUID) ([]*StepExpression, error)

func (*Queries) ListStepsByIds 

func (q *Queries) ListStepsByIds(ctx context.Context, db DBTX, arg ListStepsByIdsParams) ([]*ListStepsByIdsRow, error)

func (*Queries) ListStepsByWorkflowVersionIds 

func (q *Queries) ListStepsByWorkflowVersionIds(ctx context.Context, db DBTX, arg ListStepsByWorkflowVersionIdsParams) ([]*ListStepsByWorkflowVersionIdsRow, error)

func (*Queries) ListTaskEvents 

func (q *Queries) ListTaskEvents(ctx context.Context, db DBTX, arg ListTaskEventsParams) ([]*ListTaskEventsRow, error)

func (*Queries) ListTaskEventsForWorkflowRun 

func (q *Queries) ListTaskEventsForWorkflowRun(ctx context.Context, db DBTX, arg ListTaskEventsForWorkflowRunParams) ([]*ListTaskEventsForWorkflowRunRow, error)

func (*Queries) ListTaskExpressionEvals 

func (q *Queries) ListTaskExpressionEvals(ctx context.Context, db DBTX, arg ListTaskExpressionEvalsParams) ([]*V1TaskExpressionEval, error)

func (*Queries) ListTaskMetas 

func (q *Queries) ListTaskMetas(ctx context.Context, db DBTX, arg ListTaskMetasParams) ([]*ListTaskMetasRow, error)

func (*Queries) ListTasks 

func (q *Queries) ListTasks(ctx context.Context, db DBTX, arg ListTasksParams) ([]*V1Task, error)

func (*Queries) ListTasksByDAGIds 

func (q *Queries) ListTasksByDAGIds(ctx context.Context, db DBTX, arg ListTasksByDAGIdsParams) ([]*ListTasksByDAGIdsRow, error)

func (*Queries) ListTasksByExternalIds 

func (q *Queries) ListTasksByExternalIds(ctx context.Context, db DBTX, arg ListTasksByExternalIdsParams) ([]*ListTasksByExternalIdsRow, error)

func (*Queries) ListTasksForReplay 

func (q *Queries) ListTasksForReplay(ctx context.Context, db DBTX, arg ListTasksForReplayParams) ([]*ListTasksForReplayRow, error)

Lists tasks for replay by recursively selecting all tasks that are children of the input tasks, then locks the tasks for replay.

func (*Queries) ListTasksOlap 

func (q *Queries) ListTasksOlap(ctx context.Context, db DBTX, arg ListTasksOlapParams) ([]*ListTasksOlapRow, error)

func (*Queries) ListWorkersWithSlotCount 

func (q *Queries) ListWorkersWithSlotCount(ctx context.Context, db DBTX, arg ListWorkersWithSlotCountParams) ([]*ListWorkersWithSlotCountRow, error)

func (*Queries) ListWorkflowNamesByIds 

func (q *Queries) ListWorkflowNamesByIds(ctx context.Context, db DBTX, ids []pgtype.UUID) ([]*ListWorkflowNamesByIdsRow, error)

func (*Queries) ListWorkflowRunDisplayNames 

func (q *Queries) ListWorkflowRunDisplayNames(ctx context.Context, db DBTX, arg ListWorkflowRunDisplayNamesParams) ([]*ListWorkflowRunDisplayNamesRow, error)

func (*Queries) ListWorkflowsByNames 

func (q *Queries) ListWorkflowsByNames(ctx context.Context, db DBTX, arg ListWorkflowsByNamesParams) ([]*ListWorkflowsByNamesRow, error)

func (*Queries) ListWorkflowsForEvents 

func (q *Queries) ListWorkflowsForEvents(ctx context.Context, db DBTX, arg ListWorkflowsForEventsParams) ([]*ListWorkflowsForEventsRow, error)

Get all of the latest workflow versions select the workflow versions that have the event trigger

func (*Queries) LockDAGsForReplay 

func (q *Queries) LockDAGsForReplay(ctx context.Context, db DBTX, arg LockDAGsForReplayParams) ([]int64, error)

Locks a list of DAGs for replay. Returns successfully locked DAGs which can be replayed. We skip locked tasks because replays are the only thing that can lock a DAG for updates

func (*Queries) LockSignalCreatedEvents 

func (q *Queries) LockSignalCreatedEvents(ctx context.Context, db DBTX, arg LockSignalCreatedEventsParams) ([]*LockSignalCreatedEventsRow, error)

Places a lock on the SIGNAL_CREATED events to make sure concurrent operations don't modify the events.

func (*Queries) LookupExternalIds 

func (q *Queries) LookupExternalIds(ctx context.Context, db DBTX, arg LookupExternalIdsParams) ([]*V1LookupTable, error)

func (*Queries) ManualSlotRelease 

func (q *Queries) ManualSlotRelease(ctx context.Context, db DBTX, arg ManualSlotReleaseParams) (*V1TaskRuntime, error)

func (*Queries) PopulateDAGMetadata 

func (q *Queries) PopulateDAGMetadata(ctx context.Context, db DBTX, arg PopulateDAGMetadataParams) ([]*PopulateDAGMetadataRow, error)

func (*Queries) PopulateSingleTaskRunData 

func (q *Queries) PopulateSingleTaskRunData(ctx context.Context, db DBTX, arg PopulateSingleTaskRunDataParams) (*PopulateSingleTaskRunDataRow, error)

func (*Queries) PopulateTaskRunData 

func (q *Queries) PopulateTaskRunData(ctx context.Context, db DBTX, arg PopulateTaskRunDataParams) ([]*PopulateTaskRunDataRow, error)

func (*Queries) PreflightCheckDAGsForReplay 

func (q *Queries) PreflightCheckDAGsForReplay(ctx context.Context, db DBTX, arg PreflightCheckDAGsForReplayParams) ([]*PreflightCheckDAGsForReplayRow, error)

Checks whether DAGs can be replayed by ensuring that the length of the tasks which have been written match the length of steps in the DAG. This assumes that we have a lock on DAGs so concurrent replays don't interfere with each other. It also does not check for whether the tasks are running, as that's checked in a different query. It returns DAGs which cannot be replayed.

func (*Queries) PreflightCheckTasksForReplay 

func (q *Queries) PreflightCheckTasksForReplay(ctx context.Context, db DBTX, arg PreflightCheckTasksForReplayParams) ([]*PreflightCheckTasksForReplayRow, error)

Checks whether tasks can be replayed by ensuring that they don't have any active runtimes, concurrency slots, or retry queue items. Returns the tasks which cannot be replayed.

func (*Queries) ProcessRetryQueueItems 

func (q *Queries) ProcessRetryQueueItems(ctx context.Context, db DBTX, arg ProcessRetryQueueItemsParams) ([]*V1RetryQueueItem, error)

func (*Queries) ProcessTaskReassignments 

func (q *Queries) ProcessTaskReassignments(ctx context.Context, db DBTX, arg ProcessTaskReassignmentsParams) ([]*ProcessTaskReassignmentsRow, error)

func (*Queries) ProcessTaskTimeouts 

func (q *Queries) ProcessTaskTimeouts(ctx context.Context, db DBTX, arg ProcessTaskTimeoutsParams) ([]*ProcessTaskTimeoutsRow, error)

func (*Queries) ReadDAGByExternalID 

func (q *Queries) ReadDAGByExternalID(ctx context.Context, db DBTX, externalid pgtype.UUID) (*V1DagsOlap, error)

func (*Queries) ReadTaskByExternalID 

func (q *Queries) ReadTaskByExternalID(ctx context.Context, db DBTX, externalid pgtype.UUID) (*ReadTaskByExternalIDRow, error)

func (*Queries) ReadWorkflowRunByExternalId 

func (q *Queries) ReadWorkflowRunByExternalId(ctx context.Context, db DBTX, workflowrunexternalid pgtype.UUID) (*ReadWorkflowRunByExternalIdRow, error)

func (*Queries) RefreshTimeoutBy 

func (q *Queries) RefreshTimeoutBy(ctx context.Context, db DBTX, arg RefreshTimeoutByParams) (*V1TaskRuntime, error)

func (*Queries) ReleaseLeases 

func (q *Queries) ReleaseLeases(ctx context.Context, db DBTX, leaseids []int64) ([]*Lease, error)

Releases a set of leases by their IDs. Returns the released leases.

func (*Queries) ReleaseTasks 

func (q *Queries) ReleaseTasks(ctx context.Context, db DBTX, arg ReleaseTasksParams) ([]*ReleaseTasksRow, error)

func (*Queries) ReplayTasks 

func (q *Queries) ReplayTasks(ctx context.Context, db DBTX, arg ReplayTasksParams) ([]*V1Task, error)

NOTE: at this point, we assume we have a lock on tasks and therefor we can update the tasks

func (*Queries) ResetMatchConditions 

func (q *Queries) ResetMatchConditions(ctx context.Context, db DBTX, arg ResetMatchConditionsParams) ([]int64, error)

NOTE: we have to break this into a separate query because CTEs can't see modified rows on the same target table without using RETURNING.

func (*Queries) RunCancelInProgress 

func (q *Queries) RunCancelInProgress(ctx context.Context, db DBTX, arg RunCancelInProgressParams) ([]*RunCancelInProgressRow, error)

func (*Queries) RunCancelNewest 

func (q *Queries) RunCancelNewest(ctx context.Context, db DBTX, arg RunCancelNewestParams) ([]*RunCancelNewestRow, error)

func (*Queries) RunGroupRoundRobin 

func (q *Queries) RunGroupRoundRobin(ctx context.Context, db DBTX, arg RunGroupRoundRobinParams) ([]*RunGroupRoundRobinRow, error)

func (*Queries) SaveSatisfiedMatchConditions 

func (q *Queries) SaveSatisfiedMatchConditions(ctx context.Context, db DBTX, matchids []int64) ([]*SaveSatisfiedMatchConditionsRow, error)

NOTE: we have to break this into a separate query because CTEs can't see modified rows on the same target table without using RETURNING. Additionally, since we've placed a FOR UPDATE lock in the previous query, we're guaranteeing that only one transaction can update these rows,so this should be concurrency-safe.

func (*Queries) SetConcurrencyStrategyInactive 

func (q *Queries) SetConcurrencyStrategyInactive(ctx context.Context, db DBTX, arg SetConcurrencyStrategyInactiveParams) error

func (*Queries) UpdateDAGStatuses 

func (q *Queries) UpdateDAGStatuses(ctx context.Context, db DBTX, arg UpdateDAGStatusesParams) (*UpdateDAGStatusesRow, error)

func (*Queries) UpdateTaskStatuses 

func (q *Queries) UpdateTaskStatuses(ctx context.Context, db DBTX, arg UpdateTaskStatusesParams) (*UpdateTaskStatusesRow, error)

func (*Queries) UpdateTasksToAssigned 

func (q *Queries) UpdateTasksToAssigned(ctx context.Context, db DBTX, arg UpdateTasksToAssignedParams) ([]*UpdateTasksToAssignedRow, error)

func (*Queries) UpsertQueues 

func (q *Queries) UpsertQueues(ctx context.Context, db DBTX, arg UpsertQueuesParams) error

func (*Queries) UpsertRateLimitsBulk 

func (q *Queries) UpsertRateLimitsBulk(ctx context.Context, db DBTX, arg UpsertRateLimitsBulkParams) error

type Queue 

type Queue struct {
	ID         int64            `json:"id"`
	TenantId   pgtype.UUID      `json:"tenantId"`
	Name       string           `json:"name"`
	LastActive pgtype.Timestamp `json:"lastActive"`
}

type QueueItem 

type QueueItem struct {
	ID                int64              `json:"id"`
	StepRunId         pgtype.UUID        `json:"stepRunId"`
	StepId            pgtype.UUID        `json:"stepId"`
	ActionId          pgtype.Text        `json:"actionId"`
	ScheduleTimeoutAt pgtype.Timestamp   `json:"scheduleTimeoutAt"`
	StepTimeout       pgtype.Text        `json:"stepTimeout"`
	Priority          int32              `json:"priority"`
	IsQueued          bool               `json:"isQueued"`
	TenantId          pgtype.UUID        `json:"tenantId"`
	Queue             string             `json:"queue"`
	Sticky            NullStickyStrategy `json:"sticky"`
	DesiredWorkerId   pgtype.UUID        `json:"desiredWorkerId"`
}

type RateLimit 

type RateLimit struct {
	TenantId   pgtype.UUID      `json:"tenantId"`
	Key        string           `json:"key"`
	LimitValue int32            `json:"limitValue"`
	Value      int32            `json:"value"`
	Window     string           `json:"window"`
	LastRefill pgtype.Timestamp `json:"lastRefill"`
}

type ReadTaskByExternalIDRow 

type ReadTaskByExternalIDRow struct {
	TenantID             pgtype.UUID          `json:"tenant_id"`
	ID                   int64                `json:"id"`
	InsertedAt           pgtype.Timestamptz   `json:"inserted_at"`
	ExternalID           pgtype.UUID          `json:"external_id"`
	Queue                string               `json:"queue"`
	ActionID             string               `json:"action_id"`
	StepID               pgtype.UUID          `json:"step_id"`
	WorkflowID           pgtype.UUID          `json:"workflow_id"`
	WorkflowVersionID    pgtype.UUID          `json:"workflow_version_id"`
	WorkflowRunID        pgtype.UUID          `json:"workflow_run_id"`
	ScheduleTimeout      string               `json:"schedule_timeout"`
	StepTimeout          pgtype.Text          `json:"step_timeout"`
	Priority             pgtype.Int4          `json:"priority"`
	Sticky               V1StickyStrategyOlap `json:"sticky"`
	DesiredWorkerID      pgtype.UUID          `json:"desired_worker_id"`
	DisplayName          string               `json:"display_name"`
	Input                []byte               `json:"input"`
	AdditionalMetadata   []byte               `json:"additional_metadata"`
	ReadableStatus       V1ReadableStatusOlap `json:"readable_status"`
	LatestRetryCount     int32                `json:"latest_retry_count"`
	LatestWorkerID       pgtype.UUID          `json:"latest_worker_id"`
	DagID                pgtype.Int8          `json:"dag_id"`
	DagInsertedAt        pgtype.Timestamptz   `json:"dag_inserted_at"`
	ParentTaskExternalID pgtype.UUID          `json:"parent_task_external_id"`
	Output               []byte               `json:"output"`
	ErrorMessage         pgtype.Text          `json:"error_message"`
}

type ReadWorkflowRunByExternalIdRow 

type ReadWorkflowRunByExternalIdRow struct {
	DagID              pgtype.Int8          `json:"dag_id"`
	TaskID             pgtype.Int8          `json:"task_id"`
	ID                 int64                `json:"id"`
	TenantID           pgtype.UUID          `json:"tenant_id"`
	InsertedAt         pgtype.Timestamptz   `json:"inserted_at"`
	ExternalID         pgtype.UUID          `json:"external_id"`
	ReadableStatus     V1ReadableStatusOlap `json:"readable_status"`
	Kind               V1RunKind            `json:"kind"`
	WorkflowID         pgtype.UUID          `json:"workflow_id"`
	DisplayName        string               `json:"display_name"`
	Input              []byte               `json:"input"`
	AdditionalMetadata []byte               `json:"additional_metadata"`
	WorkflowVersionID  pgtype.UUID          `json:"workflow_version_id"`
	CreatedAt          pgtype.Timestamptz   `json:"created_at"`
	StartedAt          pgtype.Timestamptz   `json:"started_at"`
	FinishedAt         pgtype.Timestamptz   `json:"finished_at"`
	ErrorMessage       pgtype.Text          `json:"error_message"`
	TaskMetadata       []byte               `json:"task_metadata"`
}

type RefreshTimeoutByParams 

type RefreshTimeoutByParams struct {
	IncrementTimeoutBy pgtype.Text `json:"incrementTimeoutBy"`
	Externalid         pgtype.UUID `json:"externalid"`
	Tenantid           pgtype.UUID `json:"tenantid"`
}

type ReleaseTasksParams 

type ReleaseTasksParams struct {
	Taskids         []int64              `json:"taskids"`
	Taskinsertedats []pgtype.Timestamptz `json:"taskinsertedats"`
	Retrycounts     []int32              `json:"retrycounts"`
}

type ReleaseTasksRow 

type ReleaseTasksRow struct {
	Queue                  string             `json:"queue"`
	ID                     int64              `json:"id"`
	InsertedAt             pgtype.Timestamptz `json:"inserted_at"`
	ExternalID             pgtype.UUID        `json:"external_id"`
	StepReadableID         string             `json:"step_readable_id"`
	WorkerID               pgtype.UUID        `json:"worker_id"`
	RetryCount             int32              `json:"retry_count"`
	ConcurrencyStrategyIds []int64            `json:"concurrency_strategy_ids"`
}

type ReplayTasksParams 

type ReplayTasksParams struct {
	Taskids                []int64              `json:"taskids"`
	Taskinsertedats        []pgtype.Timestamptz `json:"taskinsertedats"`
	Inputs                 [][]byte             `json:"inputs"`
	InitialStates          []string             `json:"initialstates"`
	Concurrencystrategyids [][]int64            `json:"concurrencystrategyids"`
	Concurrencykeys        [][]string           `json:"concurrencykeys"`
	InitialStateReasons    []pgtype.Text        `json:"initialStateReasons"`
}

type ResetMatchConditionsParams 

type ResetMatchConditionsParams struct {
	Matchids     []int64  `json:"matchids"`
	Conditionids []int64  `json:"conditionids"`
	Datas        [][]byte `json:"datas"`
}

type RetryQueueItem 

type RetryQueueItem struct {
	ID         int64            `json:"id"`
	RetryAfter pgtype.Timestamp `json:"retryAfter"`
	StepRunId  pgtype.UUID      `json:"stepRunId"`
	TenantId   pgtype.UUID      `json:"tenantId"`
	IsQueued   bool             `json:"isQueued"`
}

type RunCancelInProgressParams 

type RunCancelInProgressParams struct {
	Tenantid   pgtype.UUID `json:"tenantid"`
	Strategyid int64       `json:"strategyid"`
	Maxruns    int32       `json:"maxruns"`
}

type RunCancelInProgressRow 

type RunCancelInProgressRow struct {
	TaskID            int64              `json:"task_id"`
	TaskInsertedAt    pgtype.Timestamptz `json:"task_inserted_at"`
	TaskRetryCount    int32              `json:"task_retry_count"`
	ExternalID        pgtype.UUID        `json:"external_id"`
	TenantID          pgtype.UUID        `json:"tenant_id"`
	WorkflowID        pgtype.UUID        `json:"workflow_id"`
	WorkflowRunID     pgtype.UUID        `json:"workflow_run_id"`
	StrategyID        int64              `json:"strategy_id"`
	Priority          int32              `json:"priority"`
	Key               string             `json:"key"`
	IsFilled          bool               `json:"is_filled"`
	NextStrategyIds   []int64            `json:"next_strategy_ids"`
	NextKeys          []string           `json:"next_keys"`
	QueueToNotify     string             `json:"queue_to_notify"`
	ScheduleTimeoutAt pgtype.Timestamp   `json:"schedule_timeout_at"`
	Operation         string             `json:"operation"`
}

type RunCancelNewestParams 

type RunCancelNewestParams struct {
	Tenantid   pgtype.UUID `json:"tenantid"`
	Strategyid int64       `json:"strategyid"`
	Maxruns    int32       `json:"maxruns"`
}

type RunCancelNewestRow 

type RunCancelNewestRow struct {
	TaskID            int64              `json:"task_id"`
	TaskInsertedAt    pgtype.Timestamptz `json:"task_inserted_at"`
	TaskRetryCount    int32              `json:"task_retry_count"`
	ExternalID        pgtype.UUID        `json:"external_id"`
	TenantID          pgtype.UUID        `json:"tenant_id"`
	WorkflowID        pgtype.UUID        `json:"workflow_id"`
	WorkflowRunID     pgtype.UUID        `json:"workflow_run_id"`
	StrategyID        int64              `json:"strategy_id"`
	Priority          int32              `json:"priority"`
	Key               string             `json:"key"`
	IsFilled          bool               `json:"is_filled"`
	NextStrategyIds   []int64            `json:"next_strategy_ids"`
	NextKeys          []string           `json:"next_keys"`
	QueueToNotify     string             `json:"queue_to_notify"`
	ScheduleTimeoutAt pgtype.Timestamp   `json:"schedule_timeout_at"`
	Operation         string             `json:"operation"`
}

type RunGroupRoundRobinParams 

type RunGroupRoundRobinParams struct {
	Tenantid   pgtype.UUID `json:"tenantid"`
	Strategyid int64       `json:"strategyid"`
	Maxruns    int32       `json:"maxruns"`
}

type RunGroupRoundRobinRow 

type RunGroupRoundRobinRow struct {
	TaskID            int64              `json:"task_id"`
	TaskInsertedAt    pgtype.Timestamptz `json:"task_inserted_at"`
	TaskRetryCount    int32              `json:"task_retry_count"`
	ExternalID        pgtype.UUID        `json:"external_id"`
	TenantID          pgtype.UUID        `json:"tenant_id"`
	WorkflowID        pgtype.UUID        `json:"workflow_id"`
	WorkflowRunID     pgtype.UUID        `json:"workflow_run_id"`
	StrategyID        int64              `json:"strategy_id"`
	Priority          int32              `json:"priority"`
	Key               string             `json:"key"`
	IsFilled          bool               `json:"is_filled"`
	NextStrategyIds   []int64            `json:"next_strategy_ids"`
	NextKeys          []string           `json:"next_keys"`
	QueueToNotify     string             `json:"queue_to_notify"`
	ScheduleTimeoutAt pgtype.Timestamp   `json:"schedule_timeout_at"`
	Operation         string             `json:"operation"`
}

type SNSIntegration 

type SNSIntegration struct {
	ID        pgtype.UUID      `json:"id"`
	CreatedAt pgtype.Timestamp `json:"createdAt"`
	UpdatedAt pgtype.Timestamp `json:"updatedAt"`
	TenantId  pgtype.UUID      `json:"tenantId"`
	TopicArn  string           `json:"topicArn"`
}

type SaveSatisfiedMatchConditionsRow 

type SaveSatisfiedMatchConditionsRow struct {
	ID                            int64              `json:"id"`
	TenantID                      pgtype.UUID        `json:"tenant_id"`
	Kind                          V1MatchKind        `json:"kind"`
	IsSatisfied                   bool               `json:"is_satisfied"`
	SignalTaskID                  pgtype.Int8        `json:"signal_task_id"`
	SignalTaskInsertedAt          pgtype.Timestamptz `json:"signal_task_inserted_at"`
	SignalExternalID              pgtype.UUID        `json:"signal_external_id"`
	SignalKey                     pgtype.Text        `json:"signal_key"`
	TriggerDagID                  pgtype.Int8        `json:"trigger_dag_id"`
	TriggerDagInsertedAt          pgtype.Timestamptz `json:"trigger_dag_inserted_at"`
	TriggerStepID                 pgtype.UUID        `json:"trigger_step_id"`
	TriggerStepIndex              pgtype.Int8        `json:"trigger_step_index"`
	TriggerExternalID             pgtype.UUID        `json:"trigger_external_id"`
	TriggerWorkflowRunID          pgtype.UUID        `json:"trigger_workflow_run_id"`
	TriggerParentTaskExternalID   pgtype.UUID        `json:"trigger_parent_task_external_id"`
	TriggerParentTaskID           pgtype.Int8        `json:"trigger_parent_task_id"`
	TriggerParentTaskInsertedAt   pgtype.Timestamptz `json:"trigger_parent_task_inserted_at"`
	TriggerChildIndex             pgtype.Int8        `json:"trigger_child_index"`
	TriggerChildKey               pgtype.Text        `json:"trigger_child_key"`
	TriggerExistingTaskID         pgtype.Int8        `json:"trigger_existing_task_id"`
	TriggerExistingTaskInsertedAt pgtype.Timestamptz `json:"trigger_existing_task_inserted_at"`
	ID_2                          pgtype.Int8        `json:"id_2"`
	McAggregatedData              []byte             `json:"mc_aggregated_data"`
	McAggregatedData_2            []byte             `json:"mc_aggregated_data_2"`
}

type SchedulerPartition 

type SchedulerPartition struct {
	ID            string           `json:"id"`
	CreatedAt     pgtype.Timestamp `json:"createdAt"`
	UpdatedAt     pgtype.Timestamp `json:"updatedAt"`
	LastHeartbeat pgtype.Timestamp `json:"lastHeartbeat"`
	Name          pgtype.Text      `json:"name"`
}

type SecurityCheckIdent 

type SecurityCheckIdent struct {
	ID pgtype.UUID `json:"id"`
}

type SemaphoreQueueItem 

type SemaphoreQueueItem struct {
	StepRunId pgtype.UUID `json:"stepRunId"`
	WorkerId  pgtype.UUID `json:"workerId"`
	TenantId  pgtype.UUID `json:"tenantId"`
}

type Service 

type Service struct {
	ID          pgtype.UUID      `json:"id"`
	CreatedAt   pgtype.Timestamp `json:"createdAt"`
	UpdatedAt   pgtype.Timestamp `json:"updatedAt"`
	DeletedAt   pgtype.Timestamp `json:"deletedAt"`
	Name        string           `json:"name"`
	Description pgtype.Text      `json:"description"`
	TenantId    pgtype.UUID      `json:"tenantId"`
}

type ServiceToWorker 

type ServiceToWorker struct {
	A pgtype.UUID `json:"A"`
	B pgtype.UUID `json:"B"`
}

type SetConcurrencyStrategyInactiveParams 

type SetConcurrencyStrategyInactiveParams struct {
	Workflowid        pgtype.UUID `json:"workflowid"`
	Workflowversionid pgtype.UUID `json:"workflowversionid"`
	Stepid            pgtype.UUID `json:"stepid"`
	Strategyid        int64       `json:"strategyid"`
}

type SlackAppWebhook 

type SlackAppWebhook struct {
	ID          pgtype.UUID      `json:"id"`
	CreatedAt   pgtype.Timestamp `json:"createdAt"`
	UpdatedAt   pgtype.Timestamp `json:"updatedAt"`
	DeletedAt   pgtype.Timestamp `json:"deletedAt"`
	TenantId    pgtype.UUID      `json:"tenantId"`
	TeamId      string           `json:"teamId"`
	TeamName    string           `json:"teamName"`
	ChannelId   string           `json:"channelId"`
	ChannelName string           `json:"channelName"`
	WebhookURL  []byte           `json:"webhookURL"`
}

type Step 

type Step struct {
	ID                 pgtype.UUID      `json:"id"`
	CreatedAt          pgtype.Timestamp `json:"createdAt"`
	UpdatedAt          pgtype.Timestamp `json:"updatedAt"`
	DeletedAt          pgtype.Timestamp `json:"deletedAt"`
	ReadableId         pgtype.Text      `json:"readableId"`
	TenantId           pgtype.UUID      `json:"tenantId"`
	JobId              pgtype.UUID      `json:"jobId"`
	ActionId           string           `json:"actionId"`
	Timeout            pgtype.Text      `json:"timeout"`
	CustomUserData     []byte           `json:"customUserData"`
	Retries            int32            `json:"retries"`
	RetryBackoffFactor pgtype.Float8    `json:"retryBackoffFactor"`
	RetryMaxBackoff    pgtype.Int4      `json:"retryMaxBackoff"`
	ScheduleTimeout    string           `json:"scheduleTimeout"`
}

type StepDesiredWorkerLabel 

type StepDesiredWorkerLabel struct {
	ID         int64                 `json:"id"`
	CreatedAt  pgtype.Timestamp      `json:"createdAt"`
	UpdatedAt  pgtype.Timestamp      `json:"updatedAt"`
	StepId     pgtype.UUID           `json:"stepId"`
	Key        string                `json:"key"`
	StrValue   pgtype.Text           `json:"strValue"`
	IntValue   pgtype.Int4           `json:"intValue"`
	Required   bool                  `json:"required"`
	Comparator WorkerLabelComparator `json:"comparator"`
	Weight     int32                 `json:"weight"`
}

type StepExpression 

type StepExpression struct {
	Key        string             `json:"key"`
	StepId     pgtype.UUID        `json:"stepId"`
	Expression string             `json:"expression"`
	Kind       StepExpressionKind `json:"kind"`
}

type StepExpressionKind 

type StepExpressionKind string
const (
	StepExpressionKindDYNAMICRATELIMITKEY    StepExpressionKind = "DYNAMIC_RATE_LIMIT_KEY"
	StepExpressionKindDYNAMICRATELIMITVALUE  StepExpressionKind = "DYNAMIC_RATE_LIMIT_VALUE"
	StepExpressionKindDYNAMICRATELIMITUNITS  StepExpressionKind = "DYNAMIC_RATE_LIMIT_UNITS"
	StepExpressionKindDYNAMICRATELIMITWINDOW StepExpressionKind = "DYNAMIC_RATE_LIMIT_WINDOW"
)

func (*StepExpressionKind) Scan 

func (e *StepExpressionKind) Scan(src interface{}) error

type StepOrder 

type StepOrder struct {
	A pgtype.UUID `json:"A"`
	B pgtype.UUID `json:"B"`
}

type StepRateLimit 

type StepRateLimit struct {
	Units        int32             `json:"units"`
	StepId       pgtype.UUID       `json:"stepId"`
	RateLimitKey string            `json:"rateLimitKey"`
	TenantId     pgtype.UUID       `json:"tenantId"`
	Kind         StepRateLimitKind `json:"kind"`
}

type StepRateLimitKind 

type StepRateLimitKind string
const (
	StepRateLimitKindSTATIC  StepRateLimitKind = "STATIC"
	StepRateLimitKindDYNAMIC StepRateLimitKind = "DYNAMIC"
)

func (*StepRateLimitKind) Scan 

func (e *StepRateLimitKind) Scan(src interface{}) error

type StepRun 

type StepRun struct {
	ID                 pgtype.UUID      `json:"id"`
	CreatedAt          pgtype.Timestamp `json:"createdAt"`
	UpdatedAt          pgtype.Timestamp `json:"updatedAt"`
	DeletedAt          pgtype.Timestamp `json:"deletedAt"`
	TenantId           pgtype.UUID      `json:"tenantId"`
	JobRunId           pgtype.UUID      `json:"jobRunId"`
	StepId             pgtype.UUID      `json:"stepId"`
	Order              int64            `json:"order"`
	WorkerId           pgtype.UUID      `json:"workerId"`
	TickerId           pgtype.UUID      `json:"tickerId"`
	Status             StepRunStatus    `json:"status"`
	Input              []byte           `json:"input"`
	Output             []byte           `json:"output"`
	RequeueAfter       pgtype.Timestamp `json:"requeueAfter"`
	ScheduleTimeoutAt  pgtype.Timestamp `json:"scheduleTimeoutAt"`
	Error              pgtype.Text      `json:"error"`
	StartedAt          pgtype.Timestamp `json:"startedAt"`
	FinishedAt         pgtype.Timestamp `json:"finishedAt"`
	TimeoutAt          pgtype.Timestamp `json:"timeoutAt"`
	CancelledAt        pgtype.Timestamp `json:"cancelledAt"`
	CancelledReason    pgtype.Text      `json:"cancelledReason"`
	CancelledError     pgtype.Text      `json:"cancelledError"`
	InputSchema        []byte           `json:"inputSchema"`
	CallerFiles        []byte           `json:"callerFiles"`
	GitRepoBranch      pgtype.Text      `json:"gitRepoBranch"`
	RetryCount         int32            `json:"retryCount"`
	SemaphoreReleased  bool             `json:"semaphoreReleased"`
	Queue              string           `json:"queue"`
	Priority           pgtype.Int4      `json:"priority"`
	InternalRetryCount int32            `json:"internalRetryCount"`
}

type StepRunEvent 

type StepRunEvent struct {
	ID            int64                `json:"id"`
	TimeFirstSeen pgtype.Timestamp     `json:"timeFirstSeen"`
	TimeLastSeen  pgtype.Timestamp     `json:"timeLastSeen"`
	StepRunId     pgtype.UUID          `json:"stepRunId"`
	Reason        StepRunEventReason   `json:"reason"`
	Severity      StepRunEventSeverity `json:"severity"`
	Message       string               `json:"message"`
	Count         int32                `json:"count"`
	Data          []byte               `json:"data"`
	WorkflowRunId pgtype.UUID          `json:"workflowRunId"`
}

type StepRunEventReason 

type StepRunEventReason string
const (
	StepRunEventReasonREQUEUEDNOWORKER             StepRunEventReason = "REQUEUED_NO_WORKER"
	StepRunEventReasonREQUEUEDRATELIMIT            StepRunEventReason = "REQUEUED_RATE_LIMIT"
	StepRunEventReasonSCHEDULINGTIMEDOUT           StepRunEventReason = "SCHEDULING_TIMED_OUT"
	StepRunEventReasonASSIGNED                     StepRunEventReason = "ASSIGNED"
	StepRunEventReasonSTARTED                      StepRunEventReason = "STARTED"
	StepRunEventReasonFINISHED                     StepRunEventReason = "FINISHED"
	StepRunEventReasonFAILED                       StepRunEventReason = "FAILED"
	StepRunEventReasonRETRYING                     StepRunEventReason = "RETRYING"
	StepRunEventReasonCANCELLED                    StepRunEventReason = "CANCELLED"
	StepRunEventReasonTIMEDOUT                     StepRunEventReason = "TIMED_OUT"
	StepRunEventReasonREASSIGNED                   StepRunEventReason = "REASSIGNED"
	StepRunEventReasonSLOTRELEASED                 StepRunEventReason = "SLOT_RELEASED"
	StepRunEventReasonTIMEOUTREFRESHED             StepRunEventReason = "TIMEOUT_REFRESHED"
	StepRunEventReasonRETRIEDBYUSER                StepRunEventReason = "RETRIED_BY_USER"
	StepRunEventReasonSENTTOWORKER                 StepRunEventReason = "SENT_TO_WORKER"
	StepRunEventReasonWORKFLOWRUNGROUPKEYSUCCEEDED StepRunEventReason = "WORKFLOW_RUN_GROUP_KEY_SUCCEEDED"
	StepRunEventReasonWORKFLOWRUNGROUPKEYFAILED    StepRunEventReason = "WORKFLOW_RUN_GROUP_KEY_FAILED"
	StepRunEventReasonRATELIMITERROR               StepRunEventReason = "RATE_LIMIT_ERROR"
	StepRunEventReasonACKNOWLEDGED                 StepRunEventReason = "ACKNOWLEDGED"
)

func (*StepRunEventReason) Scan 

func (e *StepRunEventReason) Scan(src interface{}) error

type StepRunEventSeverity 

type StepRunEventSeverity string
const (
	StepRunEventSeverityINFO     StepRunEventSeverity = "INFO"
	StepRunEventSeverityWARNING  StepRunEventSeverity = "WARNING"
	StepRunEventSeverityCRITICAL StepRunEventSeverity = "CRITICAL"
)

func (*StepRunEventSeverity) Scan 

func (e *StepRunEventSeverity) Scan(src interface{}) error

type StepRunExpressionEval 

type StepRunExpressionEval struct {
	Key       string             `json:"key"`
	StepRunId pgtype.UUID        `json:"stepRunId"`
	ValueStr  pgtype.Text        `json:"valueStr"`
	ValueInt  pgtype.Int4        `json:"valueInt"`
	Kind      StepExpressionKind `json:"kind"`
}

type StepRunOrder 

type StepRunOrder struct {
	A pgtype.UUID `json:"A"`
	B pgtype.UUID `json:"B"`
}

type StepRunResultArchive 

type StepRunResultArchive struct {
	ID              pgtype.UUID      `json:"id"`
	CreatedAt       pgtype.Timestamp `json:"createdAt"`
	UpdatedAt       pgtype.Timestamp `json:"updatedAt"`
	DeletedAt       pgtype.Timestamp `json:"deletedAt"`
	StepRunId       pgtype.UUID      `json:"stepRunId"`
	Order           int64            `json:"order"`
	Input           []byte           `json:"input"`
	Output          []byte           `json:"output"`
	Error           pgtype.Text      `json:"error"`
	StartedAt       pgtype.Timestamp `json:"startedAt"`
	FinishedAt      pgtype.Timestamp `json:"finishedAt"`
	TimeoutAt       pgtype.Timestamp `json:"timeoutAt"`
	CancelledAt     pgtype.Timestamp `json:"cancelledAt"`
	CancelledReason pgtype.Text      `json:"cancelledReason"`
	CancelledError  pgtype.Text      `json:"cancelledError"`
	RetryCount      int32            `json:"retryCount"`
}

type StepRunStatus 

type StepRunStatus string
const (
	StepRunStatusPENDING           StepRunStatus = "PENDING"
	StepRunStatusPENDINGASSIGNMENT StepRunStatus = "PENDING_ASSIGNMENT"
	StepRunStatusASSIGNED          StepRunStatus = "ASSIGNED"
	StepRunStatusRUNNING           StepRunStatus = "RUNNING"
	StepRunStatusSUCCEEDED         StepRunStatus = "SUCCEEDED"
	StepRunStatusFAILED            StepRunStatus = "FAILED"
	StepRunStatusCANCELLED         StepRunStatus = "CANCELLED"
	StepRunStatusCANCELLING        StepRunStatus = "CANCELLING"
	StepRunStatusBACKOFF           StepRunStatus = "BACKOFF"
)

func (*StepRunStatus) Scan 

func (e *StepRunStatus) Scan(src interface{}) error

type StickyStrategy 

type StickyStrategy string
const (
	StickyStrategySOFT StickyStrategy = "SOFT"
	StickyStrategyHARD StickyStrategy = "HARD"
)

func (*StickyStrategy) Scan 

func (e *StickyStrategy) Scan(src interface{}) error

type StreamEvent 

type StreamEvent struct {
	ID        int64            `json:"id"`
	CreatedAt pgtype.Timestamp `json:"createdAt"`
	TenantId  pgtype.UUID      `json:"tenantId"`
	StepRunId pgtype.UUID      `json:"stepRunId"`
	Message   []byte           `json:"message"`
	Metadata  []byte           `json:"metadata"`
}

type Tenant 

type Tenant struct {
	ID                    pgtype.UUID              `json:"id"`
	CreatedAt             pgtype.Timestamp         `json:"createdAt"`
	UpdatedAt             pgtype.Timestamp         `json:"updatedAt"`
	DeletedAt             pgtype.Timestamp         `json:"deletedAt"`
	Version               TenantMajorEngineVersion `json:"version"`
	Name                  string                   `json:"name"`
	Slug                  string                   `json:"slug"`
	AnalyticsOptOut       bool                     `json:"analyticsOptOut"`
	AlertMemberEmails     bool                     `json:"alertMemberEmails"`
	ControllerPartitionId pgtype.Text              `json:"controllerPartitionId"`
	WorkerPartitionId     pgtype.Text              `json:"workerPartitionId"`
	DataRetentionPeriod   string                   `json:"dataRetentionPeriod"`
	SchedulerPartitionId  pgtype.Text              `json:"schedulerPartitionId"`
}

type TenantAlertEmailGroup 

type TenantAlertEmailGroup struct {
	ID        pgtype.UUID      `json:"id"`
	CreatedAt pgtype.Timestamp `json:"createdAt"`
	UpdatedAt pgtype.Timestamp `json:"updatedAt"`
	DeletedAt pgtype.Timestamp `json:"deletedAt"`
	TenantId  pgtype.UUID      `json:"tenantId"`
	Emails    string           `json:"emails"`
}

type TenantAlertingSettings 

type TenantAlertingSettings struct {
	ID                              pgtype.UUID      `json:"id"`
	CreatedAt                       pgtype.Timestamp `json:"createdAt"`
	UpdatedAt                       pgtype.Timestamp `json:"updatedAt"`
	DeletedAt                       pgtype.Timestamp `json:"deletedAt"`
	TenantId                        pgtype.UUID      `json:"tenantId"`
	MaxFrequency                    string           `json:"maxFrequency"`
	LastAlertedAt                   pgtype.Timestamp `json:"lastAlertedAt"`
	TickerId                        pgtype.UUID      `json:"tickerId"`
	EnableExpiringTokenAlerts       bool             `json:"enableExpiringTokenAlerts"`
	EnableWorkflowRunFailureAlerts  bool             `json:"enableWorkflowRunFailureAlerts"`
	EnableTenantResourceLimitAlerts bool             `json:"enableTenantResourceLimitAlerts"`
}
type TenantInviteLink struct {
	ID           pgtype.UUID      `json:"id"`
	CreatedAt    pgtype.Timestamp `json:"createdAt"`
	UpdatedAt    pgtype.Timestamp `json:"updatedAt"`
	TenantId     pgtype.UUID      `json:"tenantId"`
	InviterEmail string           `json:"inviterEmail"`
	InviteeEmail string           `json:"inviteeEmail"`
	Expires      pgtype.Timestamp `json:"expires"`
	Status       InviteLinkStatus `json:"status"`
	Role         TenantMemberRole `json:"role"`
}

type TenantMajorEngineVersion 

type TenantMajorEngineVersion string
const (
	TenantMajorEngineVersionV0 TenantMajorEngineVersion = "V0"
	TenantMajorEngineVersionV1 TenantMajorEngineVersion = "V1"
)

func (*TenantMajorEngineVersion) Scan 

func (e *TenantMajorEngineVersion) Scan(src interface{}) error

type TenantMember 

type TenantMember struct {
	ID        pgtype.UUID      `json:"id"`
	CreatedAt pgtype.Timestamp `json:"createdAt"`
	UpdatedAt pgtype.Timestamp `json:"updatedAt"`
	TenantId  pgtype.UUID      `json:"tenantId"`
	UserId    pgtype.UUID      `json:"userId"`
	Role      TenantMemberRole `json:"role"`
}

type TenantMemberRole 

type TenantMemberRole string
const (
	TenantMemberRoleOWNER  TenantMemberRole = "OWNER"
	TenantMemberRoleADMIN  TenantMemberRole = "ADMIN"
	TenantMemberRoleMEMBER TenantMemberRole = "MEMBER"
)

func (*TenantMemberRole) Scan 

func (e *TenantMemberRole) Scan(src interface{}) error

type TenantResourceLimit 

type TenantResourceLimit struct {
	ID               pgtype.UUID      `json:"id"`
	CreatedAt        pgtype.Timestamp `json:"createdAt"`
	UpdatedAt        pgtype.Timestamp `json:"updatedAt"`
	Resource         LimitResource    `json:"resource"`
	TenantId         pgtype.UUID      `json:"tenantId"`
	LimitValue       int32            `json:"limitValue"`
	AlarmValue       pgtype.Int4      `json:"alarmValue"`
	Value            int32            `json:"value"`
	Window           pgtype.Text      `json:"window"`
	LastRefill       pgtype.Timestamp `json:"lastRefill"`
	CustomValueMeter bool             `json:"customValueMeter"`
}

type TenantResourceLimitAlert 

type TenantResourceLimitAlert struct {
	ID              pgtype.UUID                  `json:"id"`
	CreatedAt       pgtype.Timestamp             `json:"createdAt"`
	UpdatedAt       pgtype.Timestamp             `json:"updatedAt"`
	ResourceLimitId pgtype.UUID                  `json:"resourceLimitId"`
	TenantId        pgtype.UUID                  `json:"tenantId"`
	Resource        LimitResource                `json:"resource"`
	AlertType       TenantResourceLimitAlertType `json:"alertType"`
	Value           int32                        `json:"value"`
	Limit           int32                        `json:"limit"`
}

type TenantResourceLimitAlertType 

type TenantResourceLimitAlertType string
const (
	TenantResourceLimitAlertTypeAlarm     TenantResourceLimitAlertType = "Alarm"
	TenantResourceLimitAlertTypeExhausted TenantResourceLimitAlertType = "Exhausted"
)

func (*TenantResourceLimitAlertType) Scan 

func (e *TenantResourceLimitAlertType) Scan(src interface{}) error

type TenantVcsProvider 

type TenantVcsProvider struct {
	ID          pgtype.UUID      `json:"id"`
	CreatedAt   pgtype.Timestamp `json:"createdAt"`
	UpdatedAt   pgtype.Timestamp `json:"updatedAt"`
	DeletedAt   pgtype.Timestamp `json:"deletedAt"`
	TenantId    pgtype.UUID      `json:"tenantId"`
	VcsProvider VcsProvider      `json:"vcsProvider"`
	Config      []byte           `json:"config"`
}

type TenantWorkerPartition 

type TenantWorkerPartition struct {
	ID            string           `json:"id"`
	CreatedAt     pgtype.Timestamp `json:"createdAt"`
	UpdatedAt     pgtype.Timestamp `json:"updatedAt"`
	LastHeartbeat pgtype.Timestamp `json:"lastHeartbeat"`
	Name          pgtype.Text      `json:"name"`
}

type Ticker 

type Ticker struct {
	ID              pgtype.UUID      `json:"id"`
	CreatedAt       pgtype.Timestamp `json:"createdAt"`
	UpdatedAt       pgtype.Timestamp `json:"updatedAt"`
	LastHeartbeatAt pgtype.Timestamp `json:"lastHeartbeatAt"`
	IsActive        bool             `json:"isActive"`
}

type TimeoutQueueItem 

type TimeoutQueueItem struct {
	ID         int64            `json:"id"`
	StepRunId  pgtype.UUID      `json:"stepRunId"`
	RetryCount int32            `json:"retryCount"`
	TimeoutAt  pgtype.Timestamp `json:"timeoutAt"`
	TenantId   pgtype.UUID      `json:"tenantId"`
	IsQueued   bool             `json:"isQueued"`
}

type UpdateDAGStatusesParams 

type UpdateDAGStatusesParams struct {
	Partitionnumber int32       `json:"partitionnumber"`
	Tenantid        pgtype.UUID `json:"tenantid"`
	Eventlimit      int32       `json:"eventlimit"`
}

type UpdateDAGStatusesRow 

type UpdateDAGStatusesRow struct {
	Count            int64                `json:"count"`
	DagIds           []int64              `json:"dag_ids"`
	DagInsertedAts   []pgtype.Timestamptz `json:"dag_inserted_ats"`
	ReadableStatuses []string             `json:"readable_statuses"`
	ExternalIds      []pgtype.UUID        `json:"external_ids"`
}

type UpdateTaskStatusesParams 

type UpdateTaskStatusesParams struct {
	Partitionnumber int32       `json:"partitionnumber"`
	Tenantid        pgtype.UUID `json:"tenantid"`
	Eventlimit      int32       `json:"eventlimit"`
}

type UpdateTaskStatusesRow 

type UpdateTaskStatusesRow struct {
	Count            int64                `json:"count"`
	TaskIds          []int64              `json:"task_ids"`
	TaskInsertedAts  []pgtype.Timestamptz `json:"task_inserted_ats"`
	ReadableStatuses []string             `json:"readable_statuses"`
	ExternalIds      []pgtype.UUID        `json:"external_ids"`
}

type UpdateTasksToAssignedParams 

type UpdateTasksToAssignedParams struct {
	Taskids   []int64       `json:"taskids"`
	Workerids []pgtype.UUID `json:"workerids"`
	Tenantid  pgtype.UUID   `json:"tenantid"`
}

type UpdateTasksToAssignedRow 

type UpdateTasksToAssignedRow struct {
	TaskID   int64       `json:"task_id"`
	WorkerID pgtype.UUID `json:"worker_id"`
}

type UpsertQueuesParams 

type UpsertQueuesParams struct {
	TenantID pgtype.UUID `json:"tenant_id"`
	Names    []string    `json:"names"`
}

type UpsertRateLimitsBulkParams 

type UpsertRateLimitsBulkParams struct {
	Tenantid    pgtype.UUID `json:"tenantid"`
	Keys        []string    `json:"keys"`
	Limitvalues []int32     `json:"limitvalues"`
	Windows     []string    `json:"windows"`
}

type User 

type User struct {
	ID            pgtype.UUID      `json:"id"`
	CreatedAt     pgtype.Timestamp `json:"createdAt"`
	UpdatedAt     pgtype.Timestamp `json:"updatedAt"`
	DeletedAt     pgtype.Timestamp `json:"deletedAt"`
	Email         string           `json:"email"`
	EmailVerified bool             `json:"emailVerified"`
	Name          pgtype.Text      `json:"name"`
}

type UserOAuth 

type UserOAuth struct {
	ID             pgtype.UUID      `json:"id"`
	CreatedAt      pgtype.Timestamp `json:"createdAt"`
	UpdatedAt      pgtype.Timestamp `json:"updatedAt"`
	UserId         pgtype.UUID      `json:"userId"`
	Provider       string           `json:"provider"`
	ProviderUserId string           `json:"providerUserId"`
	ExpiresAt      pgtype.Timestamp `json:"expiresAt"`
	AccessToken    []byte           `json:"accessToken"`
	RefreshToken   []byte           `json:"refreshToken"`
}

type UserPassword 

type UserPassword struct {
	Hash   string      `json:"hash"`
	UserId pgtype.UUID `json:"userId"`
}

type UserSession 

type UserSession struct {
	ID        pgtype.UUID      `json:"id"`
	CreatedAt pgtype.Timestamp `json:"createdAt"`
	UpdatedAt pgtype.Timestamp `json:"updatedAt"`
	UserId    pgtype.UUID      `json:"userId"`
	Data      []byte           `json:"data"`
	ExpiresAt pgtype.Timestamp `json:"expiresAt"`
}

type V1ConcurrencySlot 

type V1ConcurrencySlot struct {
	TaskID            int64              `json:"task_id"`
	TaskInsertedAt    pgtype.Timestamptz `json:"task_inserted_at"`
	TaskRetryCount    int32              `json:"task_retry_count"`
	ExternalID        pgtype.UUID        `json:"external_id"`
	TenantID          pgtype.UUID        `json:"tenant_id"`
	WorkflowID        pgtype.UUID        `json:"workflow_id"`
	WorkflowRunID     pgtype.UUID        `json:"workflow_run_id"`
	StrategyID        int64              `json:"strategy_id"`
	Priority          int32              `json:"priority"`
	Key               string             `json:"key"`
	IsFilled          bool               `json:"is_filled"`
	NextStrategyIds   []int64            `json:"next_strategy_ids"`
	NextKeys          []string           `json:"next_keys"`
	QueueToNotify     string             `json:"queue_to_notify"`
	ScheduleTimeoutAt pgtype.Timestamp   `json:"schedule_timeout_at"`
}

type V1ConcurrencyStrategy 

type V1ConcurrencyStrategy string
const (
	V1ConcurrencyStrategyNONE             V1ConcurrencyStrategy = "NONE"
	V1ConcurrencyStrategyGROUPROUNDROBIN  V1ConcurrencyStrategy = "GROUP_ROUND_ROBIN"
	V1ConcurrencyStrategyCANCELINPROGRESS V1ConcurrencyStrategy = "CANCEL_IN_PROGRESS"
	V1ConcurrencyStrategyCANCELNEWEST     V1ConcurrencyStrategy = "CANCEL_NEWEST"
)

func (*V1ConcurrencyStrategy) Scan 

func (e *V1ConcurrencyStrategy) Scan(src interface{}) error

type V1Dag 

type V1Dag struct {
	ID                   int64              `json:"id"`
	InsertedAt           pgtype.Timestamptz `json:"inserted_at"`
	TenantID             pgtype.UUID        `json:"tenant_id"`
	ExternalID           pgtype.UUID        `json:"external_id"`
	DisplayName          string             `json:"display_name"`
	WorkflowID           pgtype.UUID        `json:"workflow_id"`
	WorkflowVersionID    pgtype.UUID        `json:"workflow_version_id"`
	ParentTaskExternalID pgtype.UUID        `json:"parent_task_external_id"`
}

type V1DagData 

type V1DagData struct {
	DagID              int64              `json:"dag_id"`
	DagInsertedAt      pgtype.Timestamptz `json:"dag_inserted_at"`
	Input              []byte             `json:"input"`
	AdditionalMetadata []byte             `json:"additional_metadata"`
}

type V1DagToTask 

type V1DagToTask struct {
	DagID          int64              `json:"dag_id"`
	DagInsertedAt  pgtype.Timestamptz `json:"dag_inserted_at"`
	TaskID         int64              `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz `json:"task_inserted_at"`
}

type V1DagToTaskOlap 

type V1DagToTaskOlap struct {
	DagID          int64              `json:"dag_id"`
	DagInsertedAt  pgtype.Timestamptz `json:"dag_inserted_at"`
	TaskID         int64              `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz `json:"task_inserted_at"`
}

type V1DagsOlap 

type V1DagsOlap struct {
	ID                   int64                `json:"id"`
	InsertedAt           pgtype.Timestamptz   `json:"inserted_at"`
	TenantID             pgtype.UUID          `json:"tenant_id"`
	ExternalID           pgtype.UUID          `json:"external_id"`
	DisplayName          string               `json:"display_name"`
	WorkflowID           pgtype.UUID          `json:"workflow_id"`
	WorkflowVersionID    pgtype.UUID          `json:"workflow_version_id"`
	ReadableStatus       V1ReadableStatusOlap `json:"readable_status"`
	Input                []byte               `json:"input"`
	AdditionalMetadata   []byte               `json:"additional_metadata"`
	ParentTaskExternalID pgtype.UUID          `json:"parent_task_external_id"`
}

type V1EventType 

type V1EventType string
const (
	V1EventTypeUSER     V1EventType = "USER"
	V1EventTypeINTERNAL V1EventType = "INTERNAL"
)

func (*V1EventType) Scan 

func (e *V1EventType) Scan(src interface{}) error

type V1EventTypeOlap 

type V1EventTypeOlap string
const (
	V1EventTypeOlapRETRYING           V1EventTypeOlap = "RETRYING"
	V1EventTypeOlapREASSIGNED         V1EventTypeOlap = "REASSIGNED"
	V1EventTypeOlapRETRIEDBYUSER      V1EventTypeOlap = "RETRIED_BY_USER"
	V1EventTypeOlapCREATED            V1EventTypeOlap = "CREATED"
	V1EventTypeOlapQUEUED             V1EventTypeOlap = "QUEUED"
	V1EventTypeOlapREQUEUEDNOWORKER   V1EventTypeOlap = "REQUEUED_NO_WORKER"
	V1EventTypeOlapREQUEUEDRATELIMIT  V1EventTypeOlap = "REQUEUED_RATE_LIMIT"
	V1EventTypeOlapASSIGNED           V1EventTypeOlap = "ASSIGNED"
	V1EventTypeOlapACKNOWLEDGED       V1EventTypeOlap = "ACKNOWLEDGED"
	V1EventTypeOlapSENTTOWORKER       V1EventTypeOlap = "SENT_TO_WORKER"
	V1EventTypeOlapSLOTRELEASED       V1EventTypeOlap = "SLOT_RELEASED"
	V1EventTypeOlapSTARTED            V1EventTypeOlap = "STARTED"
	V1EventTypeOlapTIMEOUTREFRESHED   V1EventTypeOlap = "TIMEOUT_REFRESHED"
	V1EventTypeOlapSCHEDULINGTIMEDOUT V1EventTypeOlap = "SCHEDULING_TIMED_OUT"
	V1EventTypeOlapFINISHED           V1EventTypeOlap = "FINISHED"
	V1EventTypeOlapFAILED             V1EventTypeOlap = "FAILED"
	V1EventTypeOlapCANCELLED          V1EventTypeOlap = "CANCELLED"
	V1EventTypeOlapTIMEDOUT           V1EventTypeOlap = "TIMED_OUT"
	V1EventTypeOlapRATELIMITERROR     V1EventTypeOlap = "RATE_LIMIT_ERROR"
	V1EventTypeOlapSKIPPED            V1EventTypeOlap = "SKIPPED"
)

func (*V1EventTypeOlap) Scan 

func (e *V1EventTypeOlap) Scan(src interface{}) error

type V1LogLine 

type V1LogLine struct {
	ID             int64              `json:"id"`
	CreatedAt      pgtype.Timestamptz `json:"created_at"`
	TenantID       pgtype.UUID        `json:"tenant_id"`
	TaskID         int64              `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz `json:"task_inserted_at"`
	Message        string             `json:"message"`
	Level          V1LogLineLevel     `json:"level"`
	Metadata       []byte             `json:"metadata"`
}

type V1LogLineLevel 

type V1LogLineLevel string
const (
	V1LogLineLevelDEBUG V1LogLineLevel = "DEBUG"
	V1LogLineLevelINFO  V1LogLineLevel = "INFO"
	V1LogLineLevelWARN  V1LogLineLevel = "WARN"
	V1LogLineLevelERROR V1LogLineLevel = "ERROR"
)

func (*V1LogLineLevel) Scan 

func (e *V1LogLineLevel) Scan(src interface{}) error

type V1LookupTable 

type V1LookupTable struct {
	TenantID   pgtype.UUID        `json:"tenant_id"`
	ExternalID pgtype.UUID        `json:"external_id"`
	TaskID     pgtype.Int8        `json:"task_id"`
	DagID      pgtype.Int8        `json:"dag_id"`
	InsertedAt pgtype.Timestamptz `json:"inserted_at"`
}

type V1LookupTableOlap 

type V1LookupTableOlap struct {
	TenantID   pgtype.UUID        `json:"tenant_id"`
	ExternalID pgtype.UUID        `json:"external_id"`
	TaskID     pgtype.Int8        `json:"task_id"`
	DagID      pgtype.Int8        `json:"dag_id"`
	InsertedAt pgtype.Timestamptz `json:"inserted_at"`
}

type V1Match 

type V1Match struct {
	ID                            int64              `json:"id"`
	TenantID                      pgtype.UUID        `json:"tenant_id"`
	Kind                          V1MatchKind        `json:"kind"`
	IsSatisfied                   bool               `json:"is_satisfied"`
	SignalTaskID                  pgtype.Int8        `json:"signal_task_id"`
	SignalTaskInsertedAt          pgtype.Timestamptz `json:"signal_task_inserted_at"`
	SignalExternalID              pgtype.UUID        `json:"signal_external_id"`
	SignalKey                     pgtype.Text        `json:"signal_key"`
	TriggerDagID                  pgtype.Int8        `json:"trigger_dag_id"`
	TriggerDagInsertedAt          pgtype.Timestamptz `json:"trigger_dag_inserted_at"`
	TriggerStepID                 pgtype.UUID        `json:"trigger_step_id"`
	TriggerStepIndex              pgtype.Int8        `json:"trigger_step_index"`
	TriggerExternalID             pgtype.UUID        `json:"trigger_external_id"`
	TriggerWorkflowRunID          pgtype.UUID        `json:"trigger_workflow_run_id"`
	TriggerParentTaskExternalID   pgtype.UUID        `json:"trigger_parent_task_external_id"`
	TriggerParentTaskID           pgtype.Int8        `json:"trigger_parent_task_id"`
	TriggerParentTaskInsertedAt   pgtype.Timestamptz `json:"trigger_parent_task_inserted_at"`
	TriggerChildIndex             pgtype.Int8        `json:"trigger_child_index"`
	TriggerChildKey               pgtype.Text        `json:"trigger_child_key"`
	TriggerExistingTaskID         pgtype.Int8        `json:"trigger_existing_task_id"`
	TriggerExistingTaskInsertedAt pgtype.Timestamptz `json:"trigger_existing_task_inserted_at"`
}

type V1MatchCondition 

type V1MatchCondition struct {
	V1MatchID         int64                  `json:"v1_match_id"`
	ID                int64                  `json:"id"`
	TenantID          pgtype.UUID            `json:"tenant_id"`
	RegisteredAt      pgtype.Timestamptz     `json:"registered_at"`
	EventType         V1EventType            `json:"event_type"`
	EventKey          string                 `json:"event_key"`
	EventResourceHint pgtype.Text            `json:"event_resource_hint"`
	ReadableDataKey   string                 `json:"readable_data_key"`
	IsSatisfied       bool                   `json:"is_satisfied"`
	Action            V1MatchConditionAction `json:"action"`
	OrGroupID         pgtype.UUID            `json:"or_group_id"`
	Expression        pgtype.Text            `json:"expression"`
	Data              []byte                 `json:"data"`
}

type V1MatchConditionAction 

type V1MatchConditionAction string
const (
	V1MatchConditionActionCREATE V1MatchConditionAction = "CREATE"
	V1MatchConditionActionQUEUE  V1MatchConditionAction = "QUEUE"
	V1MatchConditionActionCANCEL V1MatchConditionAction = "CANCEL"
	V1MatchConditionActionSKIP   V1MatchConditionAction = "SKIP"
)

func (*V1MatchConditionAction) Scan 

func (e *V1MatchConditionAction) Scan(src interface{}) error

type V1MatchKind 

type V1MatchKind string
const (
	V1MatchKindTRIGGER V1MatchKind = "TRIGGER"
	V1MatchKindSIGNAL  V1MatchKind = "SIGNAL"
)

func (*V1MatchKind) Scan 

func (e *V1MatchKind) Scan(src interface{}) error

type V1Queue 

type V1Queue struct {
	TenantID   pgtype.UUID      `json:"tenant_id"`
	Name       string           `json:"name"`
	LastActive pgtype.Timestamp `json:"last_active"`
}

type V1QueueItem 

type V1QueueItem struct {
	ID                int64              `json:"id"`
	TenantID          pgtype.UUID        `json:"tenant_id"`
	Queue             string             `json:"queue"`
	TaskID            int64              `json:"task_id"`
	TaskInsertedAt    pgtype.Timestamptz `json:"task_inserted_at"`
	ExternalID        pgtype.UUID        `json:"external_id"`
	ActionID          string             `json:"action_id"`
	StepID            pgtype.UUID        `json:"step_id"`
	WorkflowID        pgtype.UUID        `json:"workflow_id"`
	WorkflowRunID     pgtype.UUID        `json:"workflow_run_id"`
	ScheduleTimeoutAt pgtype.Timestamp   `json:"schedule_timeout_at"`
	StepTimeout       pgtype.Text        `json:"step_timeout"`
	Priority          int32              `json:"priority"`
	Sticky            V1StickyStrategy   `json:"sticky"`
	DesiredWorkerID   pgtype.UUID        `json:"desired_worker_id"`
	RetryCount        int32              `json:"retry_count"`
}

type V1ReadableStatusOlap 

type V1ReadableStatusOlap string
const (
	V1ReadableStatusOlapQUEUED    V1ReadableStatusOlap = "QUEUED"
	V1ReadableStatusOlapRUNNING   V1ReadableStatusOlap = "RUNNING"
	V1ReadableStatusOlapCANCELLED V1ReadableStatusOlap = "CANCELLED"
	V1ReadableStatusOlapFAILED    V1ReadableStatusOlap = "FAILED"
	V1ReadableStatusOlapCOMPLETED V1ReadableStatusOlap = "COMPLETED"
)

func (*V1ReadableStatusOlap) Scan 

func (e *V1ReadableStatusOlap) Scan(src interface{}) error

type V1RetryQueueItem 

type V1RetryQueueItem struct {
	TaskID         int64              `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz `json:"task_inserted_at"`
	TaskRetryCount int32              `json:"task_retry_count"`
	RetryAfter     pgtype.Timestamptz `json:"retry_after"`
	TenantID       pgtype.UUID        `json:"tenant_id"`
}

type V1RunKind 

type V1RunKind string
const (
	V1RunKindTASK V1RunKind = "TASK"
	V1RunKindDAG  V1RunKind = "DAG"
)

func (*V1RunKind) Scan 

func (e *V1RunKind) Scan(src interface{}) error

type V1RunsOlap 

type V1RunsOlap struct {
	TenantID             pgtype.UUID          `json:"tenant_id"`
	ID                   int64                `json:"id"`
	InsertedAt           pgtype.Timestamptz   `json:"inserted_at"`
	ExternalID           pgtype.UUID          `json:"external_id"`
	ReadableStatus       V1ReadableStatusOlap `json:"readable_status"`
	Kind                 V1RunKind            `json:"kind"`
	WorkflowID           pgtype.UUID          `json:"workflow_id"`
	WorkflowVersionID    pgtype.UUID          `json:"workflow_version_id"`
	AdditionalMetadata   []byte               `json:"additional_metadata"`
	ParentTaskExternalID pgtype.UUID          `json:"parent_task_external_id"`
}

type V1StatusKind 

type V1StatusKind string
const (
	V1StatusKindTASK V1StatusKind = "TASK"
	V1StatusKindDAG  V1StatusKind = "DAG"
)

func (*V1StatusKind) Scan 

func (e *V1StatusKind) Scan(src interface{}) error

type V1StatusesOlap 

type V1StatusesOlap struct {
	ExternalID     pgtype.UUID          `json:"external_id"`
	InsertedAt     pgtype.Timestamptz   `json:"inserted_at"`
	TenantID       pgtype.UUID          `json:"tenant_id"`
	WorkflowID     pgtype.UUID          `json:"workflow_id"`
	Kind           V1RunKind            `json:"kind"`
	ReadableStatus V1ReadableStatusOlap `json:"readable_status"`
}

type V1StepConcurrency 

type V1StepConcurrency struct {
	ID                int64                 `json:"id"`
	WorkflowID        pgtype.UUID           `json:"workflow_id"`
	WorkflowVersionID pgtype.UUID           `json:"workflow_version_id"`
	StepID            pgtype.UUID           `json:"step_id"`
	IsActive          bool                  `json:"is_active"`
	Strategy          V1ConcurrencyStrategy `json:"strategy"`
	Expression        string                `json:"expression"`
	TenantID          pgtype.UUID           `json:"tenant_id"`
	MaxConcurrency    int32                 `json:"max_concurrency"`
}

type V1StickyStrategy 

type V1StickyStrategy string
const (
	V1StickyStrategyNONE V1StickyStrategy = "NONE"
	V1StickyStrategySOFT V1StickyStrategy = "SOFT"
	V1StickyStrategyHARD V1StickyStrategy = "HARD"
)

func (*V1StickyStrategy) Scan 

func (e *V1StickyStrategy) Scan(src interface{}) error

type V1StickyStrategyOlap 

type V1StickyStrategyOlap string
const (
	V1StickyStrategyOlapNONE V1StickyStrategyOlap = "NONE"
	V1StickyStrategyOlapSOFT V1StickyStrategyOlap = "SOFT"
	V1StickyStrategyOlapHARD V1StickyStrategyOlap = "HARD"
)

func (*V1StickyStrategyOlap) Scan 

func (e *V1StickyStrategyOlap) Scan(src interface{}) error

type V1Task 

type V1Task struct {
	ID                     int64              `json:"id"`
	InsertedAt             pgtype.Timestamptz `json:"inserted_at"`
	TenantID               pgtype.UUID        `json:"tenant_id"`
	Queue                  string             `json:"queue"`
	ActionID               string             `json:"action_id"`
	StepID                 pgtype.UUID        `json:"step_id"`
	StepReadableID         string             `json:"step_readable_id"`
	WorkflowID             pgtype.UUID        `json:"workflow_id"`
	WorkflowVersionID      pgtype.UUID        `json:"workflow_version_id"`
	WorkflowRunID          pgtype.UUID        `json:"workflow_run_id"`
	ScheduleTimeout        string             `json:"schedule_timeout"`
	StepTimeout            pgtype.Text        `json:"step_timeout"`
	Priority               pgtype.Int4        `json:"priority"`
	Sticky                 V1StickyStrategy   `json:"sticky"`
	DesiredWorkerID        pgtype.UUID        `json:"desired_worker_id"`
	ExternalID             pgtype.UUID        `json:"external_id"`
	DisplayName            string             `json:"display_name"`
	Input                  []byte             `json:"input"`
	RetryCount             int32              `json:"retry_count"`
	InternalRetryCount     int32              `json:"internal_retry_count"`
	AppRetryCount          int32              `json:"app_retry_count"`
	StepIndex              int64              `json:"step_index"`
	AdditionalMetadata     []byte             `json:"additional_metadata"`
	DagID                  pgtype.Int8        `json:"dag_id"`
	DagInsertedAt          pgtype.Timestamptz `json:"dag_inserted_at"`
	ParentTaskExternalID   pgtype.UUID        `json:"parent_task_external_id"`
	ParentTaskID           pgtype.Int8        `json:"parent_task_id"`
	ParentTaskInsertedAt   pgtype.Timestamptz `json:"parent_task_inserted_at"`
	ChildIndex             pgtype.Int8        `json:"child_index"`
	ChildKey               pgtype.Text        `json:"child_key"`
	InitialState           V1TaskInitialState `json:"initial_state"`
	InitialStateReason     pgtype.Text        `json:"initial_state_reason"`
	ConcurrencyStrategyIds []int64            `json:"concurrency_strategy_ids"`
	ConcurrencyKeys        []string           `json:"concurrency_keys"`
	RetryBackoffFactor     pgtype.Float8      `json:"retry_backoff_factor"`
	RetryMaxBackoff        pgtype.Int4        `json:"retry_max_backoff"`
}

type V1TaskEvent 

type V1TaskEvent struct {
	ID             int64              `json:"id"`
	TenantID       pgtype.UUID        `json:"tenant_id"`
	TaskID         int64              `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz `json:"task_inserted_at"`
	RetryCount     int32              `json:"retry_count"`
	EventType      V1TaskEventType    `json:"event_type"`
	EventKey       pgtype.Text        `json:"event_key"`
	CreatedAt      pgtype.Timestamp   `json:"created_at"`
	Data           []byte             `json:"data"`
}

type V1TaskEventType 

type V1TaskEventType string
const (
	V1TaskEventTypeCOMPLETED       V1TaskEventType = "COMPLETED"
	V1TaskEventTypeFAILED          V1TaskEventType = "FAILED"
	V1TaskEventTypeCANCELLED       V1TaskEventType = "CANCELLED"
	V1TaskEventTypeSIGNALCREATED   V1TaskEventType = "SIGNAL_CREATED"
	V1TaskEventTypeSIGNALCOMPLETED V1TaskEventType = "SIGNAL_COMPLETED"
)

func (*V1TaskEventType) Scan 

func (e *V1TaskEventType) Scan(src interface{}) error

type V1TaskEventsOlap 

type V1TaskEventsOlap struct {
	TenantID               pgtype.UUID          `json:"tenant_id"`
	ID                     int64                `json:"id"`
	InsertedAt             pgtype.Timestamptz   `json:"inserted_at"`
	TaskID                 int64                `json:"task_id"`
	TaskInsertedAt         pgtype.Timestamptz   `json:"task_inserted_at"`
	EventType              V1EventTypeOlap      `json:"event_type"`
	WorkflowID             pgtype.UUID          `json:"workflow_id"`
	EventTimestamp         pgtype.Timestamptz   `json:"event_timestamp"`
	ReadableStatus         V1ReadableStatusOlap `json:"readable_status"`
	RetryCount             int32                `json:"retry_count"`
	ErrorMessage           pgtype.Text          `json:"error_message"`
	Output                 []byte               `json:"output"`
	WorkerID               pgtype.UUID          `json:"worker_id"`
	AdditionalEventData    pgtype.Text          `json:"additional__event_data"`
	AdditionalEventMessage pgtype.Text          `json:"additional__event_message"`
}

type V1TaskEventsOlapTmp 

type V1TaskEventsOlapTmp struct {
	TenantID       pgtype.UUID          `json:"tenant_id"`
	RequeueAfter   pgtype.Timestamptz   `json:"requeue_after"`
	RequeueRetries int32                `json:"requeue_retries"`
	ID             int64                `json:"id"`
	TaskID         int64                `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz   `json:"task_inserted_at"`
	EventType      V1EventTypeOlap      `json:"event_type"`
	ReadableStatus V1ReadableStatusOlap `json:"readable_status"`
	RetryCount     int32                `json:"retry_count"`
	WorkerID       pgtype.UUID          `json:"worker_id"`
}

type V1TaskExpressionEval 

type V1TaskExpressionEval struct {
	Key            string             `json:"key"`
	TaskID         int64              `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz `json:"task_inserted_at"`
	ValueStr       pgtype.Text        `json:"value_str"`
	ValueInt       pgtype.Int4        `json:"value_int"`
	Kind           StepExpressionKind `json:"kind"`
}

type V1TaskInitialState 

type V1TaskInitialState string
const (
	V1TaskInitialStateQUEUED    V1TaskInitialState = "QUEUED"
	V1TaskInitialStateCANCELLED V1TaskInitialState = "CANCELLED"
	V1TaskInitialStateSKIPPED   V1TaskInitialState = "SKIPPED"
	V1TaskInitialStateFAILED    V1TaskInitialState = "FAILED"
)

func (*V1TaskInitialState) Scan 

func (e *V1TaskInitialState) Scan(src interface{}) error

type V1TaskRuntime 

type V1TaskRuntime struct {
	TaskID         int64              `json:"task_id"`
	TaskInsertedAt pgtype.Timestamptz `json:"task_inserted_at"`
	RetryCount     int32              `json:"retry_count"`
	WorkerID       pgtype.UUID        `json:"worker_id"`
	TenantID       pgtype.UUID        `json:"tenant_id"`
	TimeoutAt      pgtype.Timestamp   `json:"timeout_at"`
}

type V1TaskStatusUpdatesTmp 

type V1TaskStatusUpdatesTmp struct {
	TenantID       pgtype.UUID        `json:"tenant_id"`
	RequeueAfter   pgtype.Timestamptz `json:"requeue_after"`
	RequeueRetries int32              `json:"requeue_retries"`
	ID             int64              `json:"id"`
	DagID          int64              `json:"dag_id"`
	DagInsertedAt  pgtype.Timestamptz `json:"dag_inserted_at"`
}

type V1TasksOlap 

type V1TasksOlap struct {
	TenantID             pgtype.UUID          `json:"tenant_id"`
	ID                   int64                `json:"id"`
	InsertedAt           pgtype.Timestamptz   `json:"inserted_at"`
	ExternalID           pgtype.UUID          `json:"external_id"`
	Queue                string               `json:"queue"`
	ActionID             string               `json:"action_id"`
	StepID               pgtype.UUID          `json:"step_id"`
	WorkflowID           pgtype.UUID          `json:"workflow_id"`
	WorkflowVersionID    pgtype.UUID          `json:"workflow_version_id"`
	WorkflowRunID        pgtype.UUID          `json:"workflow_run_id"`
	ScheduleTimeout      string               `json:"schedule_timeout"`
	StepTimeout          pgtype.Text          `json:"step_timeout"`
	Priority             pgtype.Int4          `json:"priority"`
	Sticky               V1StickyStrategyOlap `json:"sticky"`
	DesiredWorkerID      pgtype.UUID          `json:"desired_worker_id"`
	DisplayName          string               `json:"display_name"`
	Input                []byte               `json:"input"`
	AdditionalMetadata   []byte               `json:"additional_metadata"`
	ReadableStatus       V1ReadableStatusOlap `json:"readable_status"`
	LatestRetryCount     int32                `json:"latest_retry_count"`
	LatestWorkerID       pgtype.UUID          `json:"latest_worker_id"`
	DagID                pgtype.Int8          `json:"dag_id"`
	DagInsertedAt        pgtype.Timestamptz   `json:"dag_inserted_at"`
	ParentTaskExternalID pgtype.UUID          `json:"parent_task_external_id"`
}

type VcsProvider 

type VcsProvider string
const (
	VcsProviderGITHUB VcsProvider = "GITHUB"
)

func (*VcsProvider) Scan 

func (e *VcsProvider) Scan(src interface{}) error

type WebhookWorker 

type WebhookWorker struct {
	ID         pgtype.UUID      `json:"id"`
	CreatedAt  pgtype.Timestamp `json:"createdAt"`
	UpdatedAt  pgtype.Timestamp `json:"updatedAt"`
	Name       string           `json:"name"`
	Secret     string           `json:"secret"`
	Url        string           `json:"url"`
	TokenValue pgtype.Text      `json:"tokenValue"`
	Deleted    bool             `json:"deleted"`
	TokenId    pgtype.UUID      `json:"tokenId"`
	TenantId   pgtype.UUID      `json:"tenantId"`
}

type WebhookWorkerRequest 

type WebhookWorkerRequest struct {
	ID              pgtype.UUID                `json:"id"`
	CreatedAt       pgtype.Timestamp           `json:"createdAt"`
	WebhookWorkerId pgtype.UUID                `json:"webhookWorkerId"`
	Method          WebhookWorkerRequestMethod `json:"method"`
	StatusCode      int32                      `json:"statusCode"`
}

type WebhookWorkerRequestMethod 

type WebhookWorkerRequestMethod string
const (
	WebhookWorkerRequestMethodGET  WebhookWorkerRequestMethod = "GET"
	WebhookWorkerRequestMethodPOST WebhookWorkerRequestMethod = "POST"
	WebhookWorkerRequestMethodPUT  WebhookWorkerRequestMethod = "PUT"
)

func (*WebhookWorkerRequestMethod) Scan 

func (e *WebhookWorkerRequestMethod) Scan(src interface{}) error

type WebhookWorkerWorkflow 

type WebhookWorkerWorkflow struct {
	ID              pgtype.UUID `json:"id"`
	WebhookWorkerId pgtype.UUID `json:"webhookWorkerId"`
	WorkflowId      pgtype.UUID `json:"workflowId"`
}

type Worker 

type Worker struct {
	ID                      pgtype.UUID      `json:"id"`
	CreatedAt               pgtype.Timestamp `json:"createdAt"`
	UpdatedAt               pgtype.Timestamp `json:"updatedAt"`
	DeletedAt               pgtype.Timestamp `json:"deletedAt"`
	TenantId                pgtype.UUID      `json:"tenantId"`
	LastHeartbeatAt         pgtype.Timestamp `json:"lastHeartbeatAt"`
	Name                    string           `json:"name"`
	DispatcherId            pgtype.UUID      `json:"dispatcherId"`
	MaxRuns                 int32            `json:"maxRuns"`
	IsActive                bool             `json:"isActive"`
	LastListenerEstablished pgtype.Timestamp `json:"lastListenerEstablished"`
	IsPaused                bool             `json:"isPaused"`
	Type                    WorkerType       `json:"type"`
	WebhookId               pgtype.UUID      `json:"webhookId"`
	Language                NullWorkerSDKS   `json:"language"`
	LanguageVersion         pgtype.Text      `json:"languageVersion"`
	Os                      pgtype.Text      `json:"os"`
	RuntimeExtra            pgtype.Text      `json:"runtimeExtra"`
	SdkVersion              pgtype.Text      `json:"sdkVersion"`
}

type WorkerAssignEvent 

type WorkerAssignEvent struct {
	ID               int64       `json:"id"`
	WorkerId         pgtype.UUID `json:"workerId"`
	AssignedStepRuns []byte      `json:"assignedStepRuns"`
}

type WorkerLabel 

type WorkerLabel struct {
	ID        int64            `json:"id"`
	CreatedAt pgtype.Timestamp `json:"createdAt"`
	UpdatedAt pgtype.Timestamp `json:"updatedAt"`
	WorkerId  pgtype.UUID      `json:"workerId"`
	Key       string           `json:"key"`
	StrValue  pgtype.Text      `json:"strValue"`
	IntValue  pgtype.Int4      `json:"intValue"`
}

type WorkerLabelComparator 

type WorkerLabelComparator string
const (
	WorkerLabelComparatorEQUAL              WorkerLabelComparator = "EQUAL"
	WorkerLabelComparatorNOTEQUAL           WorkerLabelComparator = "NOT_EQUAL"
	WorkerLabelComparatorGREATERTHAN        WorkerLabelComparator = "GREATER_THAN"
	WorkerLabelComparatorGREATERTHANOREQUAL WorkerLabelComparator = "GREATER_THAN_OR_EQUAL"
	WorkerLabelComparatorLESSTHAN           WorkerLabelComparator = "LESS_THAN"
	WorkerLabelComparatorLESSTHANOREQUAL    WorkerLabelComparator = "LESS_THAN_OR_EQUAL"
)

func (*WorkerLabelComparator) Scan 

func (e *WorkerLabelComparator) Scan(src interface{}) error

type WorkerSDKS 

type WorkerSDKS string
const (
	WorkerSDKSUNKNOWN    WorkerSDKS = "UNKNOWN"
	WorkerSDKSGO         WorkerSDKS = "GO"
	WorkerSDKSPYTHON     WorkerSDKS = "PYTHON"
	WorkerSDKSTYPESCRIPT WorkerSDKS = "TYPESCRIPT"
)

func (*WorkerSDKS) Scan 

func (e *WorkerSDKS) Scan(src interface{}) error

type WorkerType 

type WorkerType string
const (
	WorkerTypeWEBHOOK    WorkerType = "WEBHOOK"
	WorkerTypeMANAGED    WorkerType = "MANAGED"
	WorkerTypeSELFHOSTED WorkerType = "SELFHOSTED"
)

func (*WorkerType) Scan 

func (e *WorkerType) Scan(src interface{}) error

type Workflow 

type Workflow struct {
	ID          pgtype.UUID      `json:"id"`
	CreatedAt   pgtype.Timestamp `json:"createdAt"`
	UpdatedAt   pgtype.Timestamp `json:"updatedAt"`
	DeletedAt   pgtype.Timestamp `json:"deletedAt"`
	TenantId    pgtype.UUID      `json:"tenantId"`
	Name        string           `json:"name"`
	Description pgtype.Text      `json:"description"`
	IsPaused    pgtype.Bool      `json:"isPaused"`
}

type WorkflowConcurrency 

type WorkflowConcurrency struct {
	ID                         pgtype.UUID              `json:"id"`
	CreatedAt                  pgtype.Timestamp         `json:"createdAt"`
	UpdatedAt                  pgtype.Timestamp         `json:"updatedAt"`
	WorkflowVersionId          pgtype.UUID              `json:"workflowVersionId"`
	GetConcurrencyGroupId      pgtype.UUID              `json:"getConcurrencyGroupId"`
	MaxRuns                    int32                    `json:"maxRuns"`
	LimitStrategy              ConcurrencyLimitStrategy `json:"limitStrategy"`
	ConcurrencyGroupExpression pgtype.Text              `json:"concurrencyGroupExpression"`
}

type WorkflowKind 

type WorkflowKind string
const (
	WorkflowKindFUNCTION WorkflowKind = "FUNCTION"
	WorkflowKindDURABLE  WorkflowKind = "DURABLE"
	WorkflowKindDAG      WorkflowKind = "DAG"
)

func (*WorkflowKind) Scan 

func (e *WorkflowKind) Scan(src interface{}) error

type WorkflowRun 

type WorkflowRun struct {
	CreatedAt          pgtype.Timestamp  `json:"createdAt"`
	UpdatedAt          pgtype.Timestamp  `json:"updatedAt"`
	DeletedAt          pgtype.Timestamp  `json:"deletedAt"`
	TenantId           pgtype.UUID       `json:"tenantId"`
	WorkflowVersionId  pgtype.UUID       `json:"workflowVersionId"`
	Status             WorkflowRunStatus `json:"status"`
	Error              pgtype.Text       `json:"error"`
	StartedAt          pgtype.Timestamp  `json:"startedAt"`
	FinishedAt         pgtype.Timestamp  `json:"finishedAt"`
	ConcurrencyGroupId pgtype.Text       `json:"concurrencyGroupId"`
	DisplayName        pgtype.Text       `json:"displayName"`
	ID                 pgtype.UUID       `json:"id"`
	ChildIndex         pgtype.Int4       `json:"childIndex"`
	ChildKey           pgtype.Text       `json:"childKey"`
	ParentId           pgtype.UUID       `json:"parentId"`
	ParentStepRunId    pgtype.UUID       `json:"parentStepRunId"`
	AdditionalMetadata []byte            `json:"additionalMetadata"`
	Duration           pgtype.Int8       `json:"duration"`
	Priority           pgtype.Int4       `json:"priority"`
	InsertOrder        pgtype.Int4       `json:"insertOrder"`
}

type WorkflowRunDedupe 

type WorkflowRunDedupe struct {
	ID            int64            `json:"id"`
	CreatedAt     pgtype.Timestamp `json:"createdAt"`
	UpdatedAt     pgtype.Timestamp `json:"updatedAt"`
	TenantId      pgtype.UUID      `json:"tenantId"`
	WorkflowId    pgtype.UUID      `json:"workflowId"`
	WorkflowRunId pgtype.UUID      `json:"workflowRunId"`
	Value         string           `json:"value"`
}

type WorkflowRunStatus 

type WorkflowRunStatus string
const (
	WorkflowRunStatusPENDING    WorkflowRunStatus = "PENDING"
	WorkflowRunStatusRUNNING    WorkflowRunStatus = "RUNNING"
	WorkflowRunStatusSUCCEEDED  WorkflowRunStatus = "SUCCEEDED"
	WorkflowRunStatusFAILED     WorkflowRunStatus = "FAILED"
	WorkflowRunStatusQUEUED     WorkflowRunStatus = "QUEUED"
	WorkflowRunStatusCANCELLING WorkflowRunStatus = "CANCELLING"
	WorkflowRunStatusCANCELLED  WorkflowRunStatus = "CANCELLED"
	WorkflowRunStatusBACKOFF    WorkflowRunStatus = "BACKOFF"
)

func (*WorkflowRunStatus) Scan 

func (e *WorkflowRunStatus) Scan(src interface{}) error

type WorkflowRunStickyState 

type WorkflowRunStickyState struct {
	ID              int64            `json:"id"`
	CreatedAt       pgtype.Timestamp `json:"createdAt"`
	UpdatedAt       pgtype.Timestamp `json:"updatedAt"`
	TenantId        pgtype.UUID      `json:"tenantId"`
	WorkflowRunId   pgtype.UUID      `json:"workflowRunId"`
	DesiredWorkerId pgtype.UUID      `json:"desiredWorkerId"`
	Strategy        StickyStrategy   `json:"strategy"`
}

type WorkflowRunTriggeredBy 

type WorkflowRunTriggeredBy struct {
	ID           pgtype.UUID      `json:"id"`
	CreatedAt    pgtype.Timestamp `json:"createdAt"`
	UpdatedAt    pgtype.Timestamp `json:"updatedAt"`
	DeletedAt    pgtype.Timestamp `json:"deletedAt"`
	TenantId     pgtype.UUID      `json:"tenantId"`
	EventId      pgtype.UUID      `json:"eventId"`
	CronParentId pgtype.UUID      `json:"cronParentId"`
	CronSchedule pgtype.Text      `json:"cronSchedule"`
	ScheduledId  pgtype.UUID      `json:"scheduledId"`
	Input        []byte           `json:"input"`
	ParentId     pgtype.UUID      `json:"parentId"`
	CronName     pgtype.Text      `json:"cronName"`
}

type WorkflowTag 

type WorkflowTag struct {
	ID        pgtype.UUID      `json:"id"`
	CreatedAt pgtype.Timestamp `json:"createdAt"`
	UpdatedAt pgtype.Timestamp `json:"updatedAt"`
	TenantId  pgtype.UUID      `json:"tenantId"`
	Name      string           `json:"name"`
	Color     string           `json:"color"`
}

type WorkflowToWorkflowTag 

type WorkflowToWorkflowTag struct {
	A pgtype.UUID `json:"A"`
	B pgtype.UUID `json:"B"`
}

type WorkflowTriggerCronRef 

type WorkflowTriggerCronRef struct {
	ParentId           pgtype.UUID                   `json:"parentId"`
	Cron               string                        `json:"cron"`
	TickerId           pgtype.UUID                   `json:"tickerId"`
	Input              []byte                        `json:"input"`
	Enabled            bool                          `json:"enabled"`
	AdditionalMetadata []byte                        `json:"additionalMetadata"`
	CreatedAt          pgtype.Timestamp              `json:"createdAt"`
	DeletedAt          pgtype.Timestamp              `json:"deletedAt"`
	UpdatedAt          pgtype.Timestamp              `json:"updatedAt"`
	Name               pgtype.Text                   `json:"name"`
	ID                 pgtype.UUID                   `json:"id"`
	Method             WorkflowTriggerCronRefMethods `json:"method"`
}

type WorkflowTriggerCronRefMethods 

type WorkflowTriggerCronRefMethods string
const (
	WorkflowTriggerCronRefMethodsDEFAULT WorkflowTriggerCronRefMethods = "DEFAULT"
	WorkflowTriggerCronRefMethodsAPI     WorkflowTriggerCronRefMethods = "API"
)

func (*WorkflowTriggerCronRefMethods) Scan 

func (e *WorkflowTriggerCronRefMethods) Scan(src interface{}) error

type WorkflowTriggerEventRef 

type WorkflowTriggerEventRef struct {
	ParentId pgtype.UUID `json:"parentId"`
	EventKey string      `json:"eventKey"`
}

type WorkflowTriggerScheduledRef 

type WorkflowTriggerScheduledRef struct {
	ID                  pgtype.UUID                        `json:"id"`
	ParentId            pgtype.UUID                        `json:"parentId"`
	TriggerAt           pgtype.Timestamp                   `json:"triggerAt"`
	TickerId            pgtype.UUID                        `json:"tickerId"`
	Input               []byte                             `json:"input"`
	ChildIndex          pgtype.Int4                        `json:"childIndex"`
	ChildKey            pgtype.Text                        `json:"childKey"`
	ParentStepRunId     pgtype.UUID                        `json:"parentStepRunId"`
	ParentWorkflowRunId pgtype.UUID                        `json:"parentWorkflowRunId"`
	AdditionalMetadata  []byte                             `json:"additionalMetadata"`
	CreatedAt           pgtype.Timestamp                   `json:"createdAt"`
	DeletedAt           pgtype.Timestamp                   `json:"deletedAt"`
	UpdatedAt           pgtype.Timestamp                   `json:"updatedAt"`
	Method              WorkflowTriggerScheduledRefMethods `json:"method"`
}

type WorkflowTriggerScheduledRefMethods 

type WorkflowTriggerScheduledRefMethods string
const (
	WorkflowTriggerScheduledRefMethodsDEFAULT WorkflowTriggerScheduledRefMethods = "DEFAULT"
	WorkflowTriggerScheduledRefMethodsAPI     WorkflowTriggerScheduledRefMethods = "API"
)

func (*WorkflowTriggerScheduledRefMethods) Scan 

func (e *WorkflowTriggerScheduledRefMethods) Scan(src interface{}) error

type WorkflowTriggers 

type WorkflowTriggers struct {
	ID                pgtype.UUID      `json:"id"`
	CreatedAt         pgtype.Timestamp `json:"createdAt"`
	UpdatedAt         pgtype.Timestamp `json:"updatedAt"`
	DeletedAt         pgtype.Timestamp `json:"deletedAt"`
	WorkflowVersionId pgtype.UUID      `json:"workflowVersionId"`
	TenantId          pgtype.UUID      `json:"tenantId"`
}

type WorkflowVersion 

type WorkflowVersion struct {
	ID              pgtype.UUID        `json:"id"`
	CreatedAt       pgtype.Timestamp   `json:"createdAt"`
	UpdatedAt       pgtype.Timestamp   `json:"updatedAt"`
	DeletedAt       pgtype.Timestamp   `json:"deletedAt"`
	Version         pgtype.Text        `json:"version"`
	Order           int64              `json:"order"`
	WorkflowId      pgtype.UUID        `json:"workflowId"`
	Checksum        string             `json:"checksum"`
	ScheduleTimeout string             `json:"scheduleTimeout"`
	OnFailureJobId  pgtype.UUID        `json:"onFailureJobId"`
	Sticky          NullStickyStrategy `json:"sticky"`
	Kind            WorkflowKind       `json:"kind"`
	DefaultPriority pgtype.Int4        `json:"defaultPriority"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.