package exec

import "context"

// Sealed invoker objects for scheduled-message, task, Workflow, and workspace operations.

type invokeScheduledMessageCreateObject struct {
	idempotencyReceiptInvoker
}

func (inv invokeScheduledMessageCreateObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body scheduledMessageCreateRequest) (actionResult[scheduledMessageRecord], error) {
	request := actionScopedJSON[scheduledMessageCreateRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (scheduledMessageHandler{idempotency: transport}).create(ctx, request)
}

type invokeScheduledMessageDeleteObject struct {
	naturalMutationInvoker
}

func (inv invokeScheduledMessageDeleteObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body scheduledMessageIDRequest) (actionResult[scheduledMessageDeleteResult], error) {
	request := actionScopedJSON[scheduledMessageIDRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (scheduledMessageHandler{natural: transport}).delete(ctx, request)
}

type invokeScheduledMessageGetObject struct {
	remoteReadInvoker
}

func (inv invokeScheduledMessageGetObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body scheduledMessageIDRequest) (actionResult[scheduledMessageRecord], error) {
	request := actionScopedJSON[scheduledMessageIDRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (scheduledMessageHandler{read: transport}).get(ctx, request)
}

type invokeScheduledMessageListObject struct {
	remoteReadInvoker
}

func (inv invokeScheduledMessageListObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body scheduledMessageListRequest) (actionResult[scheduledMessageListResult], error) {
	request := actionScopedJSON[scheduledMessageListRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (scheduledMessageHandler{read: transport}).list(ctx, request)
}

type invokeScheduledMessagePauseObject struct {
	naturalMutationInvoker
}

func (inv invokeScheduledMessagePauseObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body scheduledMessageIDRequest) (actionResult[scheduledMessageRecord], error) {
	request := actionScopedJSON[scheduledMessageIDRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (scheduledMessageHandler{natural: transport}).pause(ctx, request)
}

type invokeScheduledMessageResumeObject struct {
	naturalMutationInvoker
}

func (inv invokeScheduledMessageResumeObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body scheduledMessageIDRequest) (actionResult[scheduledMessageRecord], error) {
	request := actionScopedJSON[scheduledMessageIDRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (scheduledMessageHandler{natural: transport}).resume(ctx, request)
}

type invokeScheduledMessageRunsObject struct {
	remoteReadInvoker
}

func (inv invokeScheduledMessageRunsObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body scheduledMessageRunsRequest) (actionResult[scheduledMessageRunsResult], error) {
	request := actionScopedJSON[scheduledMessageRunsRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (scheduledMessageHandler{read: transport}).runs(ctx, request)
}

type invokeScheduledMessageUpdateObject struct {
	idempotencyReceiptInvoker
}

func (inv invokeScheduledMessageUpdateObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body scheduledMessageUpdateRequest) (actionResult[scheduledMessageRecord], error) {
	request := actionScopedJSON[scheduledMessageUpdateRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (scheduledMessageHandler{idempotency: transport}).update(ctx, request)
}

type invokeScheduledMessageValidateObject struct {
	remoteReadInvoker
}

func (inv invokeScheduledMessageValidateObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body scheduledMessageValidateRequest) (actionResult[scheduledMessageValidationResult], error) {
	request := actionScopedJSON[scheduledMessageValidateRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (scheduledMessageHandler{read: transport}).validate(ctx, request)
}

type invokeTaskCheckpointObject struct {
	naturalMutationInvoker
}

func (inv invokeTaskCheckpointObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body taskCheckpointRequest) (actionResult[taskMutationResult], error) {
	request := actionScopedJSON[taskCheckpointRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (taskHandler{natural: transport}).checkpoint(ctx, request)
}

type invokeTaskClaimObject struct {
	naturalMutationInvoker
}

func (inv invokeTaskClaimObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body taskClaimRequest) (actionResult[taskClaimResult], error) {
	request := actionScopedJSON[taskClaimRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (taskHandler{natural: transport}).claim(ctx, request)
}

type invokeTaskCreateObject struct {
	naturalMutationInvoker
}

func (inv invokeTaskCreateObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body taskCreateRequest) (actionResult[taskCreateResult], error) {
	request := actionScopedJSON[taskCreateRequest]{Authorized: authorized, Body: body}
	return (taskHandler{
		natural:     inv.transport,
		turnTargets: inv.transport.turnTargets,
	}).create(ctx, request)
}

type invokeTaskDeleteObject struct {
	naturalMutationInvoker
}

func (inv invokeTaskDeleteObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body taskDeleteRequest) (actionResult[taskDeleteResult], error) {
	request := actionScopedJSON[taskDeleteRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (taskHandler{natural: transport}).delete(ctx, request)
}

type invokeTaskGetObject struct {
	remoteReadInvoker
}

func (inv invokeTaskGetObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body taskGetRequest) (actionResult[taskDetailResult], error) {
	request := actionScopedJSON[taskGetRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (taskHandler{read: transport}).get(ctx, request)
}

type invokeTaskListObject struct {
	remoteReadInvoker
}

func (inv invokeTaskListObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body taskListRequest) (actionResult[taskListResult], error) {
	request := actionScopedJSON[taskListRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (taskHandler{read: transport}).list(ctx, request)
}

type invokeTaskUnclaimObject struct {
	naturalMutationInvoker
}

func (inv invokeTaskUnclaimObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body taskClaimRequest) (actionResult[taskClaimResult], error) {
	request := actionScopedJSON[taskClaimRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (taskHandler{natural: transport}).unclaim(ctx, request)
}

type invokeTaskUpdateObject struct {
	naturalMutationInvoker
}

func (inv invokeTaskUpdateObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body taskUpdateRequest) (actionResult[taskMutationResult], error) {
	request := actionScopedJSON[taskUpdateRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (taskHandler{natural: transport}).update(ctx, request)
}

type invokeWorkflowPlanObject struct {
	workflowReceiptInvoker
}

func (inv invokeWorkflowPlanObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body workflowPlanRequest) (actionResult[workflowPlanResult], error) {
	request := actionScopedJSON[workflowPlanRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (workflowHandler{receipt: transport}).plan(ctx, request)
}

type invokeWorkflowTriggerObject struct {
	workflowReceiptInvoker
}

func (inv invokeWorkflowTriggerObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body workflowTriggerRequest) (actionResult[workflowTriggerResult], error) {
	request := actionScopedJSON[workflowTriggerRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (workflowHandler{receipt: transport}).trigger(ctx, request)
}

type invokeWorkflowRunObject struct {
	workflowReceiptInvoker
}

func (inv invokeWorkflowRunObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body workflowRunRequest) (actionResult[workflowRunResult], error) {
	request := actionScopedJSON[workflowRunRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (workflowHandler{receipt: transport}).run(ctx, request)
}

type invokeWorkflowStepObject struct {
	workflowReceiptInvoker
}

func (inv invokeWorkflowStepObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body workflowStepCommand) (actionResult[workflowStepOutcome], error) {
	request := actionScopedJSON[workflowStepCommand]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (workflowHandler{receipt: transport}).step(ctx, request)
}

type invokeWorkspaceListObject struct {
	remoteReadInvoker
}

func (inv invokeWorkspaceListObject) Invoke(ctx context.Context, authorized runtimeAuthorization, body workspaceListRequest) (actionResult[workspaceListResponse], error) {
	request := actionScopedJSON[workspaceListRequest]{Authorized: authorized, Body: body}
	transport := inv.transport
	return (workspaceHandler{read: transport}).list(ctx, request)
}