// AUTO-GENERATED by scripts/generate.ts from .generated-specs. Do not edit.
import * as S from "@distilled.cloud/core/schema";
import * as API from "@distilled.cloud/core/api";
import * as T from "../traits.ts";
import {
  CloudflareProtocol,
  CloudflarePaginatedProtocol,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.ts";
import { cloudflarePaginate, ResultInfo } from "../pagination.ts";
import { CloudflareError, CloudflareRateLimited } from "../errors.ts";
import * as Retry from "../retry.ts";

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  backlogBytes: "backlog_bytes",
  backlogCount: "backlog_count",
  batchSize: "batch_size",
  bucketName: "bucket_name",
  consumerId: "consumer_id",
  consumersTotalCount: "consumers_total_count",
  contentType: "content_type",
  createdAt: "created_at",
  createdOn: "created_on",
  deadLetterQueue: "dead_letter_queue",
  delaySeconds: "delay_seconds",
  deleteMessagesPermanently: "delete_messages_permanently",
  deliveryDelay: "delivery_delay",
  deliveryPaused: "delivery_paused",
  documentationUrl: "documentation_url",
  leaseId: "lease_id",
  maxConcurrency: "max_concurrency",
  maxRetries: "max_retries",
  maxWaitTimeMs: "max_wait_time_ms",
  messageBacklogCount: "message_backlog_count",
  messageRetentionPeriod: "message_retention_period",
  modelName: "model_name",
  modifiedAt: "modified_at",
  modifiedOn: "modified_on",
  oldestMessageTimestampMs: "oldest_message_timestamp_ms",
  perPage: "per_page",
  producersTotalCount: "producers_total_count",
  queueId: "queue_id",
  queueName: "queue_name",
  resultInfo: "result_info",
  retryDelay: "retry_delay",
  scriptName: ["script_name", "script"],
  startedAt: "started_at",
  timestampMs: "timestamp_ms",
  totalCount: "total_count",
  visibilityTimeoutMs: "visibility_timeout_ms",
  workerName: "worker_name",
  workflowName: "workflow_name",
};

export class ConsumerAlreadyExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<ConsumerAlreadyExists>()(
      "ConsumerAlreadyExists",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 11004 }],
  ) {}

export class ConsumerNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<ConsumerNotFound>()("ConsumerNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 10013 }, { code: 10105 }, { code: 11006 }],
  ) {}

export class Forbidden
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
      code: S.Number,
      message: S.String,
    }),
    [{ status: 403 }],
  ) {}

export class InvalidMessageBody
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<InvalidMessageBody>()("InvalidMessageBody", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 10207 }, { code: 10013 }],
  ) {}

export class InvalidQueueId
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<InvalidQueueId>()("InvalidQueueId", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 10107 }],
  ) {}

export class InvalidQueueName
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<InvalidQueueName>()("InvalidQueueName", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 11003 }],
  ) {}

export class InvalidRequestBody
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<InvalidRequestBody>()("InvalidRequestBody", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 10026 }],
  ) {}

export class InvalidRoute
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<InvalidRoute>()("InvalidRoute", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 7003 }],
  ) {}

export class QueueAlreadyExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<QueueAlreadyExists>()("QueueAlreadyExists", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 11009 }],
  ) {}

export class QueueHandlerMissing
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<QueueHandlerMissing>()("QueueHandlerMissing", {
      code: S.Number,
      message: S.String,
    }),
    [
      { code: 11001 },
      { status: 400, message: { includes: "queue handler is missing" } },
    ],
  ) {}

export class QueueInUseByEventNotification
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<QueueInUseByEventNotification>()(
      "QueueInUseByEventNotification",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 11017 }],
  ) {}

export class QueueInUseByWorkerBinding
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<QueueInUseByWorkerBinding>()(
      "QueueInUseByWorkerBinding",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 11005 }],
  ) {}

export class QueueNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<QueueNotFound>()("QueueNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [
      { code: 11000 },
      { code: 0, message: { includes: "Queue does not exist" } },
      { status: 404, message: { includes: "Queue does not exist" } },
    ],
  ) {}

export class SubscriptionAlreadyExists
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<SubscriptionAlreadyExists>()(
      "SubscriptionAlreadyExists",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [
      {
        status: 405,
        message: { includes: "do not support multiple subscriptions" },
      },
    ],
  ) {}

export class SubscriptionNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<SubscriptionNotFound>()(
      "SubscriptionNotFound",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ status: 404, message: { includes: "No subscription with this ID" } }],
  ) {}

export class UnrecognizedEventType
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<UnrecognizedEventType>()(
      "UnrecognizedEventType",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 0, message: { includes: "Unrecognized event types" } }],
  ) {}

export class WorkerNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<WorkerNotFound>()("WorkerNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 10007 }],
  ) {}

export interface MessagesAckRequestAcksItem {
  /** An ID that represents an "in-flight" message that has been pulled from a Queue. You must hold on to this ID and use it to acknowledge this message. */
  leaseId?: string;
}
export const MessagesAckRequestAcksItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    leaseId: S.optional(S.String.pipe(T.Body("lease_id"))),
  }),
).annotate({
  identifier: "MessagesAckRequestAcksItem",
}) as any as S.Schema<MessagesAckRequestAcksItem>;

export type MessagesAckRequestAcksList = Array<MessagesAckRequestAcksItem>;
export const MessagesAckRequestAcksList = /*@__PURE__*/ S.Array(
  MessagesAckRequestAcksItem,
) as any as S.Schema<MessagesAckRequestAcksList>;

export interface MessagesAckRequestRetriesItem {
  /** The number of seconds to delay before making the message available for another attempt. */
  delaySeconds?: number;
  /** An ID that represents an "in-flight" message that has been pulled from a Queue. You must hold on to this ID and use it to acknowledge this message. */
  leaseId?: string;
}
export const MessagesAckRequestRetriesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    delaySeconds: S.optional(S.Number.pipe(T.Body("delay_seconds"))),
    leaseId: S.optional(S.String.pipe(T.Body("lease_id"))),
  }),
).annotate({
  identifier: "MessagesAckRequestRetriesItem",
}) as any as S.Schema<MessagesAckRequestRetriesItem>;

export type MessagesAckRequestRetriesList =
  Array<MessagesAckRequestRetriesItem>;
export const MessagesAckRequestRetriesList = /*@__PURE__*/ S.Array(
  MessagesAckRequestRetriesItem,
) as any as S.Schema<MessagesAckRequestRetriesList>;

export interface AckMessageRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
  acks?: MessagesAckRequestAcksList;
  retries?: MessagesAckRequestRetriesList;
}
export const AckMessageRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
    acks: S.optional(MessagesAckRequestAcksList),
    retries: S.optional(MessagesAckRequestRetriesList),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/queues/{queue_id}/messages/ack",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "AckMessageRequest",
}) as any as S.Schema<AckMessageRequest>;

export type MessagesAckResponseWarningsMap = {
  [key: string]: string | undefined;
};
export const MessagesAckResponseWarningsMap = /*@__PURE__*/ S.Record(
  S.String,
  S.String,
) as any as S.Schema<MessagesAckResponseWarningsMap>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface AckMessageResponse {
  /** The number of messages that were succesfully acknowledged. */
  ackCount?: number | null;
  /** The number of messages that were succesfully retried. */
  retryCount?: number | null;
  /** Map of lease IDs to warning messages encountered during acknowledgement. */
  warnings?: MessagesAckResponseWarningsMap | null;
}
export const AckMessageResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    ackCount: S.optional(S.NullOr(S.Number)),
    retryCount: S.optional(S.NullOr(S.Number)),
    warnings: S.optional(S.NullOr(MessagesAckResponseWarningsMap)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "AckMessageResponse",
}) as any as S.Schema<AckMessageResponse>;

export type MessagesBulkPushRequestMessagesItemMqQueueMessageTextContentType =
  "text";
export const MessagesBulkPushRequestMessagesItemMqQueueMessageTextContentType =
  /*@__PURE__*/ S.String;

export interface MessagesBulkPushRequestMessagesItemMqQueueMessageText {
  body?: string;
  contentType?:
    | MessagesBulkPushRequestMessagesItemMqQueueMessageTextContentType
    | (string & {});
  /** The number of seconds to wait for attempting to deliver this message to consumers */
  delaySeconds?: number;
}
export const MessagesBulkPushRequestMessagesItemMqQueueMessageText =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      body: S.optional(S.String),
      contentType: S.optional(
        MessagesBulkPushRequestMessagesItemMqQueueMessageTextContentType.pipe(
          T.Body("content_type"),
        ),
      ),
      delaySeconds: S.optional(S.Number.pipe(T.Body("delay_seconds"))),
    }),
  ).annotate({
    identifier: "MessagesBulkPushRequestMessagesItemMqQueueMessageText",
  }) as any as S.Schema<MessagesBulkPushRequestMessagesItemMqQueueMessageText>;

export type MessagesBulkPushRequestMessagesItemMqQueueMessageJsonContentType =
  "json";
export const MessagesBulkPushRequestMessagesItemMqQueueMessageJsonContentType =
  /*@__PURE__*/ S.String;

export interface MessagesBulkPushRequestMessagesItemMqQueueMessageJson {
  body?: unknown;
  contentType?:
    | MessagesBulkPushRequestMessagesItemMqQueueMessageJsonContentType
    | (string & {});
  /** The number of seconds to wait for attempting to deliver this message to consumers */
  delaySeconds?: number;
}
export const MessagesBulkPushRequestMessagesItemMqQueueMessageJson =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      body: S.optional(S.Unknown),
      contentType: S.optional(
        MessagesBulkPushRequestMessagesItemMqQueueMessageJsonContentType.pipe(
          T.Body("content_type"),
        ),
      ),
      delaySeconds: S.optional(S.Number.pipe(T.Body("delay_seconds"))),
    }),
  ).annotate({
    identifier: "MessagesBulkPushRequestMessagesItemMqQueueMessageJson",
  }) as any as S.Schema<MessagesBulkPushRequestMessagesItemMqQueueMessageJson>;

export type MessagesBulkPushRequestMessagesItem =
  | MessagesBulkPushRequestMessagesItemMqQueueMessageText
  | MessagesBulkPushRequestMessagesItemMqQueueMessageJson;
export const MessagesBulkPushRequestMessagesItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["body", "contentType", "delaySeconds"],
    ["body", "contentType", "delaySeconds"],
  ]),
);

export type MessagesBulkPushRequestMessagesList =
  Array<MessagesBulkPushRequestMessagesItem>;
export const MessagesBulkPushRequestMessagesList = /*@__PURE__*/ S.Array(
  MessagesBulkPushRequestMessagesItem,
) as any as S.Schema<MessagesBulkPushRequestMessagesList>;

export interface BulkPushMessagesRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
  /** The number of seconds to wait for attempting to deliver this batch to consumers */
  delaySeconds?: number;
  messages?: MessagesBulkPushRequestMessagesList;
}
export const BulkPushMessagesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
    delaySeconds: S.optional(S.Number.pipe(T.Body("delay_seconds"))),
    messages: S.optional(MessagesBulkPushRequestMessagesList),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/queues/{queue_id}/messages/batch",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "BulkPushMessagesRequest",
}) as any as S.Schema<BulkPushMessagesRequest>;

export interface MessagesBulkPushResponseMetadataMetrics {
  /** The size in bytes of unacknowledged messages in the queue. */
  backlogBytes: number;
  /** The number of unacknowledged messages in the queue. */
  backlogCount: number;
  /** Unix timestamp in milliseconds of the oldest unacknowledged message in the queue. Returns 0 if unknown. */
  oldestMessageTimestampMs: number;
}
export const MessagesBulkPushResponseMetadataMetrics = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      backlogBytes: S.Number.pipe(T.Body("backlog_bytes")),
      backlogCount: S.Number.pipe(T.Body("backlog_count")),
      oldestMessageTimestampMs: S.Number.pipe(
        T.Body("oldest_message_timestamp_ms"),
      ),
    }),
).annotate({
  identifier: "MessagesBulkPushResponseMetadataMetrics",
}) as any as S.Schema<MessagesBulkPushResponseMetadataMetrics>;

export interface MessagesBulkPushResponseMetadata {
  /** Best-effort metrics for the queue. Values may be approximate due to the distributed nature of queues. */
  metrics?: MessagesBulkPushResponseMetadataMetrics | null;
}
export const MessagesBulkPushResponseMetadata = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    metrics: S.optional(S.NullOr(MessagesBulkPushResponseMetadataMetrics)),
  }),
).annotate({
  identifier: "MessagesBulkPushResponseMetadata",
}) as any as S.Schema<MessagesBulkPushResponseMetadata>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface BulkPushMessagesResponse {
  metadata?: MessagesBulkPushResponseMetadata | null;
}
export const BulkPushMessagesResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    metadata: S.optional(S.NullOr(MessagesBulkPushResponseMetadata)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "BulkPushMessagesResponse",
}) as any as S.Schema<BulkPushMessagesResponse>;

export type ConsumersCreateRequestType = "worker" | "http_pull";
export const ConsumersCreateRequestType = /*@__PURE__*/ S.String;

export interface ConsumersCreateRequestSettingsWorker {
  /** The maximum number of messages to include in a batch. */
  batchSize?: number;
  /** Maximum number of concurrent consumers that may consume from this Queue. Set to `null` to automatically opt in to the platform's maximum (recommended). */
  maxConcurrency?: number;
  /** The maximum number of retries */
  maxRetries?: number;
  /** The number of milliseconds to wait for a batch to fill up before attempting to deliver it */
  maxWaitTimeMs?: number;
  /** The number of seconds to delay before making the message available for another attempt. */
  retryDelay?: number;
}
export const ConsumersCreateRequestSettingsWorker = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      batchSize: S.optional(S.Number.pipe(T.Body("batch_size"))),
      maxConcurrency: S.optional(S.Number.pipe(T.Body("max_concurrency"))),
      maxRetries: S.optional(S.Number.pipe(T.Body("max_retries"))),
      maxWaitTimeMs: S.optional(S.Number.pipe(T.Body("max_wait_time_ms"))),
      retryDelay: S.optional(S.Number.pipe(T.Body("retry_delay"))),
    }),
).annotate({
  identifier: "ConsumersCreateRequestSettingsWorker",
}) as any as S.Schema<ConsumersCreateRequestSettingsWorker>;

export interface ConsumersCreateRequestSettingsHTTPPull {
  /** The maximum number of messages to include in a batch. */
  batchSize?: number;
  /** The maximum number of retries */
  maxRetries?: number;
  /** The number of seconds to delay before making the message available for another attempt. */
  retryDelay?: number;
  /** The number of milliseconds that a message is exclusively leased. After the timeout, the message becomes available for another attempt. */
  visibilityTimeoutMs?: number;
}
export const ConsumersCreateRequestSettingsHTTPPull = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      batchSize: S.optional(S.Number.pipe(T.Body("batch_size"))),
      maxRetries: S.optional(S.Number.pipe(T.Body("max_retries"))),
      retryDelay: S.optional(S.Number.pipe(T.Body("retry_delay"))),
      visibilityTimeoutMs: S.optional(
        S.Number.pipe(T.Body("visibility_timeout_ms")),
      ),
    }),
).annotate({
  identifier: "ConsumersCreateRequestSettingsHTTPPull",
}) as any as S.Schema<ConsumersCreateRequestSettingsHTTPPull>;

export type ConsumersCreateRequestSettings =
  | ConsumersCreateRequestSettingsWorker
  | ConsumersCreateRequestSettingsHTTPPull;
export const ConsumersCreateRequestSettings = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "batchSize",
      "maxConcurrency",
      "maxRetries",
      "maxWaitTimeMs",
      "retryDelay",
    ],
    ["batchSize", "maxRetries", "retryDelay", "visibilityTimeoutMs"],
  ]),
);

export interface CreateConsumerRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
  /** Name of a Worker */
  scriptName?: string;
  type: ConsumersCreateRequestType | (string & {});
  deadLetterQueue?: string;
  settings?: ConsumersCreateRequestSettings;
}
export const CreateConsumerRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
    scriptName: S.optional(S.String.pipe(T.Body("script_name"))),
    type: ConsumersCreateRequestType,
    deadLetterQueue: S.optional(S.String.pipe(T.Body("dead_letter_queue"))),
    settings: S.optional(ConsumersCreateRequestSettings),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/queues/{queue_id}/consumers",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateConsumerRequest",
}) as any as S.Schema<CreateConsumerRequest>;

export interface ConsumersCreateResultWorkerSettings {
  /** The maximum number of messages to include in a batch. */
  batchSize?: number | null;
  /** Maximum number of concurrent consumers that may consume from this Queue. Set to `null` to automatically opt in to the platform's maximum (recommended). */
  maxConcurrency?: number | null;
  /** The maximum number of retries */
  maxRetries?: number | null;
  /** The number of milliseconds to wait for a batch to fill up before attempting to deliver it */
  maxWaitTimeMs?: number | null;
  /** The number of seconds to delay before making the message available for another attempt. */
  retryDelay?: number | null;
}
export const ConsumersCreateResultWorkerSettings = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    batchSize: S.optional(S.NullOr(S.Number).pipe(T.Body("batch_size"))),
    maxConcurrency: S.optional(
      S.NullOr(S.Number).pipe(T.Body("max_concurrency")),
    ),
    maxRetries: S.optional(S.NullOr(S.Number).pipe(T.Body("max_retries"))),
    maxWaitTimeMs: S.optional(
      S.NullOr(S.Number).pipe(T.Body("max_wait_time_ms")),
    ),
    retryDelay: S.optional(S.NullOr(S.Number).pipe(T.Body("retry_delay"))),
  }),
).annotate({
  identifier: "ConsumersCreateResultWorkerSettings",
}) as any as S.Schema<ConsumersCreateResultWorkerSettings>;

export type ConsumersCreateResultWorkerType = "worker";
export const ConsumersCreateResultWorkerType = /*@__PURE__*/ S.String;

export interface ConsumersCreateResultWorker {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  /** Name of a Worker */
  scriptName?: string | null;
  settings?: ConsumersCreateResultWorkerSettings | null;
  type?: ConsumersCreateResultWorkerType | null;
}
export const ConsumersCreateResultWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultWorkerSettings)),
    type: S.optional(S.NullOr(ConsumersCreateResultWorkerType)),
  }),
).annotate({
  identifier: "ConsumersCreateResultWorker",
}) as any as S.Schema<ConsumersCreateResultWorker>;

export interface ConsumersCreateResultHTTPPullSettings {
  /** The maximum number of messages to include in a batch. */
  batchSize?: number | null;
  /** The maximum number of retries */
  maxRetries?: number | null;
  /** The number of seconds to delay before making the message available for another attempt. */
  retryDelay?: number | null;
  /** The number of milliseconds that a message is exclusively leased. After the timeout, the message becomes available for another attempt. */
  visibilityTimeoutMs?: number | null;
}
export const ConsumersCreateResultHTTPPullSettings = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      batchSize: S.optional(S.NullOr(S.Number).pipe(T.Body("batch_size"))),
      maxRetries: S.optional(S.NullOr(S.Number).pipe(T.Body("max_retries"))),
      retryDelay: S.optional(S.NullOr(S.Number).pipe(T.Body("retry_delay"))),
      visibilityTimeoutMs: S.optional(
        S.NullOr(S.Number).pipe(T.Body("visibility_timeout_ms")),
      ),
    }),
).annotate({
  identifier: "ConsumersCreateResultHTTPPullSettings",
}) as any as S.Schema<ConsumersCreateResultHTTPPullSettings>;

export type ConsumersCreateResultHTTPPullType = "http_pull";
export const ConsumersCreateResultHTTPPullType = /*@__PURE__*/ S.String;

export interface ConsumersCreateResultHTTPPull {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  settings?: ConsumersCreateResultHTTPPullSettings | null;
  type?: ConsumersCreateResultHTTPPullType | null;
}
export const ConsumersCreateResultHTTPPull = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultHTTPPullSettings)),
    type: S.optional(S.NullOr(ConsumersCreateResultHTTPPullType)),
  }),
).annotate({
  identifier: "ConsumersCreateResultHTTPPull",
}) as any as S.Schema<ConsumersCreateResultHTTPPull>;

export type ConsumersCreateResult =
  | ConsumersCreateResultWorker
  | ConsumersCreateResultHTTPPull;
export const ConsumersCreateResult = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "scriptName",
      "settings",
      "type",
    ],
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "settings",
      "type",
    ],
  ]),
);

export type CreateConsumerResponse = ConsumersCreateResult;
export const CreateConsumerResponse = /*@__PURE__*/ S.suspend(() =>
  ConsumersCreateResult.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "CreateConsumerResponse",
}) as any as S.Schema<CreateConsumerResponse>;

export interface CreateQueueRequest {
  /** A Resource identifier. */
  accountId: string;
  queueName: string;
}
export const CreateQueueRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueName: S.String.pipe(T.Body("queue_name")),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/queues",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateQueueRequest",
}) as any as S.Schema<CreateQueueRequest>;

export type CreateResponseConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;
export const CreateResponseConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;

export type CreateResponseConsumersItemWorkerType = "worker";
export const CreateResponseConsumersItemWorkerType = /*@__PURE__*/ S.String;

export interface CreateResponseConsumersItemWorker {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  /** Name of a Worker */
  scriptName?: string | null;
  settings?: ConsumersCreateResultWorkerSettings | null;
  type?: CreateResponseConsumersItemWorkerType | null;
}
export const CreateResponseConsumersItemWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultWorkerSettings)),
    type: S.optional(S.NullOr(CreateResponseConsumersItemWorkerType)),
  }),
).annotate({
  identifier: "CreateResponseConsumersItemWorker",
}) as any as S.Schema<CreateResponseConsumersItemWorker>;

export type CreateResponseConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;
export const CreateResponseConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;

export type CreateResponseConsumersItemHTTPPullType = "http_pull";
export const CreateResponseConsumersItemHTTPPullType = /*@__PURE__*/ S.String;

export interface CreateResponseConsumersItemHTTPPull {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  settings?: ConsumersCreateResultHTTPPullSettings | null;
  type?: CreateResponseConsumersItemHTTPPullType | null;
}
export const CreateResponseConsumersItemHTTPPull = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultHTTPPullSettings)),
    type: S.optional(S.NullOr(CreateResponseConsumersItemHTTPPullType)),
  }),
).annotate({
  identifier: "CreateResponseConsumersItemHTTPPull",
}) as any as S.Schema<CreateResponseConsumersItemHTTPPull>;

export type CreateResponseConsumersItem =
  | CreateResponseConsumersItemWorker
  | CreateResponseConsumersItemHTTPPull;
export const CreateResponseConsumersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "scriptName",
      "settings",
      "type",
    ],
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "settings",
      "type",
    ],
  ]),
);

export type CreateResponseConsumersList = Array<CreateResponseConsumersItem>;
export const CreateResponseConsumersList = /*@__PURE__*/ S.Array(
  CreateResponseConsumersItem,
) as any as S.Schema<CreateResponseConsumersList>;

export type CreateResponseProducersItemMqWorkerProducerType = "worker";
export const CreateResponseProducersItemMqWorkerProducerType =
  /*@__PURE__*/ S.String;

export interface CreateResponseProducersItemMqWorkerProducer {
  type?: CreateResponseProducersItemMqWorkerProducerType | null;
  scriptName?: string | null;
}
export const CreateResponseProducersItemMqWorkerProducer =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(CreateResponseProducersItemMqWorkerProducerType),
      ),
      scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    }),
  ).annotate({
    identifier: "CreateResponseProducersItemMqWorkerProducer",
  }) as any as S.Schema<CreateResponseProducersItemMqWorkerProducer>;

export type CreateResponseProducersItemMqR2ProducerType = "r2_bucket";
export const CreateResponseProducersItemMqR2ProducerType =
  /*@__PURE__*/ S.String;

export interface CreateResponseProducersItemMqR2Producer {
  bucketName?: string | null;
  type?: CreateResponseProducersItemMqR2ProducerType | null;
}
export const CreateResponseProducersItemMqR2Producer = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      bucketName: S.optional(S.NullOr(S.String).pipe(T.Body("bucket_name"))),
      type: S.optional(S.NullOr(CreateResponseProducersItemMqR2ProducerType)),
    }),
).annotate({
  identifier: "CreateResponseProducersItemMqR2Producer",
}) as any as S.Schema<CreateResponseProducersItemMqR2Producer>;

export type CreateResponseProducersItem =
  | CreateResponseProducersItemMqWorkerProducer
  | CreateResponseProducersItemMqR2Producer;
export const CreateResponseProducersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "scriptName"],
    ["bucketName", "type"],
  ]),
);

export type CreateResponseProducersList = Array<CreateResponseProducersItem>;
export const CreateResponseProducersList = /*@__PURE__*/ S.Array(
  CreateResponseProducersItem,
) as any as S.Schema<CreateResponseProducersList>;

export interface CreateResponseSettings {
  /** Number of seconds to delay delivery of all messages to consumers. */
  deliveryDelay?: number | null;
  /** Indicates if message delivery to consumers is currently paused. */
  deliveryPaused?: boolean | null;
  /** Number of seconds after which an unconsumed message will be delayed. */
  messageRetentionPeriod?: number | null;
}
export const CreateResponseSettings = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    deliveryDelay: S.optional(
      S.NullOr(S.Number).pipe(T.Body("delivery_delay")),
    ),
    deliveryPaused: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("delivery_paused")),
    ),
    messageRetentionPeriod: S.optional(
      S.NullOr(S.Number).pipe(T.Body("message_retention_period")),
    ),
  }),
).annotate({
  identifier: "CreateResponseSettings",
}) as any as S.Schema<CreateResponseSettings>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateQueueResponse {
  consumers?: CreateResponseConsumersList | null;
  consumersTotalCount?: number | null;
  createdOn?: string | null;
  modifiedOn?: string | null;
  producers?: CreateResponseProducersList | null;
  producersTotalCount?: number | null;
  queueId?: string | null;
  queueName?: string | null;
  settings?: CreateResponseSettings | null;
}
export const CreateQueueResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumers: S.optional(S.NullOr(CreateResponseConsumersList)),
    consumersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("consumers_total_count")),
    ),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    producers: S.optional(S.NullOr(CreateResponseProducersList)),
    producersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("producers_total_count")),
    ),
    queueId: S.optional(S.NullOr(S.String).pipe(T.Body("queue_id"))),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(CreateResponseSettings)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateQueueResponse",
}) as any as S.Schema<CreateQueueResponse>;

export type SubscriptionsCreateRequestDestinationType = "queues.queue";
export const SubscriptionsCreateRequestDestinationType = /*@__PURE__*/ S.String;

export interface SubscriptionsCreateRequestDestination {
  /** ID of the target queue */
  queueId: string;
  /** Type of destination */
  type: SubscriptionsCreateRequestDestinationType | (string & {});
}
export const SubscriptionsCreateRequestDestination = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      queueId: S.String.pipe(T.Body("queue_id")),
      type: SubscriptionsCreateRequestDestinationType,
    }),
).annotate({
  identifier: "SubscriptionsCreateRequestDestination",
}) as any as S.Schema<SubscriptionsCreateRequestDestination>;

export type SubscriptionsCreateRequestEventsList = Array<string>;
export const SubscriptionsCreateRequestEventsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<SubscriptionsCreateRequestEventsList>;

export type SubscriptionsCreateRequestSourceMqEventSourceImagesType = "images";
export const SubscriptionsCreateRequestSourceMqEventSourceImagesType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateRequestSourceMqEventSourceImages {
  /** Type of source */
  type?:
    | SubscriptionsCreateRequestSourceMqEventSourceImagesType
    | (string & {});
}
export const SubscriptionsCreateRequestSourceMqEventSourceImages =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(SubscriptionsCreateRequestSourceMqEventSourceImagesType),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateRequestSourceMqEventSourceImages",
  }) as any as S.Schema<SubscriptionsCreateRequestSourceMqEventSourceImages>;

export type SubscriptionsCreateRequestSourceMqEventSourceKVType = "kv";
export const SubscriptionsCreateRequestSourceMqEventSourceKVType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateRequestSourceMqEventSourceKV {
  /** Type of source */
  type?: SubscriptionsCreateRequestSourceMqEventSourceKVType | (string & {});
}
export const SubscriptionsCreateRequestSourceMqEventSourceKV =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(SubscriptionsCreateRequestSourceMqEventSourceKVType),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateRequestSourceMqEventSourceKV",
  }) as any as S.Schema<SubscriptionsCreateRequestSourceMqEventSourceKV>;

export type SubscriptionsCreateRequestSourceMqEventSourceR2Type = "r2";
export const SubscriptionsCreateRequestSourceMqEventSourceR2Type =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateRequestSourceMqEventSourceR2 {
  /** Type of source */
  type?: SubscriptionsCreateRequestSourceMqEventSourceR2Type | (string & {});
}
export const SubscriptionsCreateRequestSourceMqEventSourceR2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(SubscriptionsCreateRequestSourceMqEventSourceR2Type),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateRequestSourceMqEventSourceR2",
  }) as any as S.Schema<SubscriptionsCreateRequestSourceMqEventSourceR2>;

export type SubscriptionsCreateRequestSourceMqEventSourceSuperSlurperType =
  "superSlurper";
export const SubscriptionsCreateRequestSourceMqEventSourceSuperSlurperType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateRequestSourceMqEventSourceSuperSlurper {
  /** Type of source */
  type?:
    | SubscriptionsCreateRequestSourceMqEventSourceSuperSlurperType
    | (string & {});
}
export const SubscriptionsCreateRequestSourceMqEventSourceSuperSlurper =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        SubscriptionsCreateRequestSourceMqEventSourceSuperSlurperType,
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateRequestSourceMqEventSourceSuperSlurper",
  }) as any as S.Schema<SubscriptionsCreateRequestSourceMqEventSourceSuperSlurper>;

export type SubscriptionsCreateRequestSourceMqEventSourceVectorizeType =
  "vectorize";
export const SubscriptionsCreateRequestSourceMqEventSourceVectorizeType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateRequestSourceMqEventSourceVectorize {
  /** Type of source */
  type?:
    | SubscriptionsCreateRequestSourceMqEventSourceVectorizeType
    | (string & {});
}
export const SubscriptionsCreateRequestSourceMqEventSourceVectorize =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        SubscriptionsCreateRequestSourceMqEventSourceVectorizeType,
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateRequestSourceMqEventSourceVectorize",
  }) as any as S.Schema<SubscriptionsCreateRequestSourceMqEventSourceVectorize>;

export type SubscriptionsCreateRequestSourceMqEventSourceWorkersAIModelType =
  "workersAi.model";
export const SubscriptionsCreateRequestSourceMqEventSourceWorkersAIModelType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateRequestSourceMqEventSourceWorkersAIModel {
  /** Name of the Workers AI model */
  modelName?: string;
  /** Type of source */
  type?:
    | SubscriptionsCreateRequestSourceMqEventSourceWorkersAIModelType
    | (string & {});
}
export const SubscriptionsCreateRequestSourceMqEventSourceWorkersAIModel =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      modelName: S.optional(S.String.pipe(T.Body("model_name"))),
      type: S.optional(
        SubscriptionsCreateRequestSourceMqEventSourceWorkersAIModelType,
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateRequestSourceMqEventSourceWorkersAIModel",
  }) as any as S.Schema<SubscriptionsCreateRequestSourceMqEventSourceWorkersAIModel>;

export type SubscriptionsCreateRequestSourceMqEventSourceWorkersBuildsWorkerType =
  "workersBuilds.worker";
export const SubscriptionsCreateRequestSourceMqEventSourceWorkersBuildsWorkerType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateRequestSourceMqEventSourceWorkersBuildsWorker {
  /** Type of source */
  type?:
    | SubscriptionsCreateRequestSourceMqEventSourceWorkersBuildsWorkerType
    | (string & {});
  /** Name of the worker */
  workerName?: string;
}
export const SubscriptionsCreateRequestSourceMqEventSourceWorkersBuildsWorker =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        SubscriptionsCreateRequestSourceMqEventSourceWorkersBuildsWorkerType,
      ),
      workerName: S.optional(S.String.pipe(T.Body("worker_name"))),
    }),
  ).annotate({
    identifier:
      "SubscriptionsCreateRequestSourceMqEventSourceWorkersBuildsWorker",
  }) as any as S.Schema<SubscriptionsCreateRequestSourceMqEventSourceWorkersBuildsWorker>;

export type SubscriptionsCreateRequestSourceMqEventSourceWorkflowsWorkflowType =
  "workflows.workflow";
export const SubscriptionsCreateRequestSourceMqEventSourceWorkflowsWorkflowType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateRequestSourceMqEventSourceWorkflowsWorkflow {
  /** Type of source */
  type?:
    | SubscriptionsCreateRequestSourceMqEventSourceWorkflowsWorkflowType
    | (string & {});
  /** Name of the workflow */
  workflowName?: string;
}
export const SubscriptionsCreateRequestSourceMqEventSourceWorkflowsWorkflow =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        SubscriptionsCreateRequestSourceMqEventSourceWorkflowsWorkflowType,
      ),
      workflowName: S.optional(S.String.pipe(T.Body("workflow_name"))),
    }),
  ).annotate({
    identifier:
      "SubscriptionsCreateRequestSourceMqEventSourceWorkflowsWorkflow",
  }) as any as S.Schema<SubscriptionsCreateRequestSourceMqEventSourceWorkflowsWorkflow>;

export type SubscriptionsCreateRequestSource =
  | SubscriptionsCreateRequestSourceMqEventSourceImages
  | SubscriptionsCreateRequestSourceMqEventSourceKV
  | SubscriptionsCreateRequestSourceMqEventSourceR2
  | SubscriptionsCreateRequestSourceMqEventSourceSuperSlurper
  | SubscriptionsCreateRequestSourceMqEventSourceVectorize
  | SubscriptionsCreateRequestSourceMqEventSourceWorkersAIModel
  | SubscriptionsCreateRequestSourceMqEventSourceWorkersBuildsWorker
  | SubscriptionsCreateRequestSourceMqEventSourceWorkflowsWorkflow;
export const SubscriptionsCreateRequestSource = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["modelName", "type"],
    ["type", "workerName"],
    ["type", "workflowName"],
  ]),
);

export interface CreateSubscriptionRequest {
  /** A Resource identifier. */
  accountId: string;
  /** Destination configuration for the subscription */
  destination?: SubscriptionsCreateRequestDestination;
  /** Whether the subscription is active */
  enabled?: boolean;
  /** List of event types this subscription handles */
  events?: SubscriptionsCreateRequestEventsList;
  /** Name of the subscription */
  name?: string;
  /** Source configuration for the subscription */
  source?: SubscriptionsCreateRequestSource;
}
export const CreateSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    destination: S.optional(SubscriptionsCreateRequestDestination),
    enabled: S.optional(S.Boolean),
    events: S.optional(SubscriptionsCreateRequestEventsList),
    name: S.optional(S.String),
    source: S.optional(SubscriptionsCreateRequestSource),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/event_subscriptions/subscriptions",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateSubscriptionRequest",
}) as any as S.Schema<CreateSubscriptionRequest>;

export type SubscriptionsCreateResponseDestinationType = "queues.queue";
export const SubscriptionsCreateResponseDestinationType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateResponseDestination {
  /** ID of the target queue */
  queueId: string;
  /** Type of destination */
  type: SubscriptionsCreateResponseDestinationType;
}
export const SubscriptionsCreateResponseDestination = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      queueId: S.String.pipe(T.Body("queue_id")),
      type: SubscriptionsCreateResponseDestinationType,
    }),
).annotate({
  identifier: "SubscriptionsCreateResponseDestination",
}) as any as S.Schema<SubscriptionsCreateResponseDestination>;

export type SubscriptionsCreateResponseEventsList = Array<string>;
export const SubscriptionsCreateResponseEventsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<SubscriptionsCreateResponseEventsList>;

export type SubscriptionsCreateResponseSourceMqEventSourceImagesType = "images";
export const SubscriptionsCreateResponseSourceMqEventSourceImagesType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateResponseSourceMqEventSourceImages {
  /** Type of source */
  type?: SubscriptionsCreateResponseSourceMqEventSourceImagesType | null;
}
export const SubscriptionsCreateResponseSourceMqEventSourceImages =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsCreateResponseSourceMqEventSourceImagesType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateResponseSourceMqEventSourceImages",
  }) as any as S.Schema<SubscriptionsCreateResponseSourceMqEventSourceImages>;

export type SubscriptionsCreateResponseSourceMqEventSourceKVType = "kv";
export const SubscriptionsCreateResponseSourceMqEventSourceKVType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateResponseSourceMqEventSourceKV {
  /** Type of source */
  type?: SubscriptionsCreateResponseSourceMqEventSourceKVType | null;
}
export const SubscriptionsCreateResponseSourceMqEventSourceKV =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsCreateResponseSourceMqEventSourceKVType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateResponseSourceMqEventSourceKV",
  }) as any as S.Schema<SubscriptionsCreateResponseSourceMqEventSourceKV>;

export type SubscriptionsCreateResponseSourceMqEventSourceR2Type = "r2";
export const SubscriptionsCreateResponseSourceMqEventSourceR2Type =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateResponseSourceMqEventSourceR2 {
  /** Type of source */
  type?: SubscriptionsCreateResponseSourceMqEventSourceR2Type | null;
}
export const SubscriptionsCreateResponseSourceMqEventSourceR2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsCreateResponseSourceMqEventSourceR2Type),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateResponseSourceMqEventSourceR2",
  }) as any as S.Schema<SubscriptionsCreateResponseSourceMqEventSourceR2>;

export type SubscriptionsCreateResponseSourceMqEventSourceSuperSlurperType =
  "superSlurper";
export const SubscriptionsCreateResponseSourceMqEventSourceSuperSlurperType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateResponseSourceMqEventSourceSuperSlurper {
  /** Type of source */
  type?: SubscriptionsCreateResponseSourceMqEventSourceSuperSlurperType | null;
}
export const SubscriptionsCreateResponseSourceMqEventSourceSuperSlurper =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsCreateResponseSourceMqEventSourceSuperSlurperType,
        ),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateResponseSourceMqEventSourceSuperSlurper",
  }) as any as S.Schema<SubscriptionsCreateResponseSourceMqEventSourceSuperSlurper>;

export type SubscriptionsCreateResponseSourceMqEventSourceVectorizeType =
  "vectorize";
export const SubscriptionsCreateResponseSourceMqEventSourceVectorizeType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateResponseSourceMqEventSourceVectorize {
  /** Type of source */
  type?: SubscriptionsCreateResponseSourceMqEventSourceVectorizeType | null;
}
export const SubscriptionsCreateResponseSourceMqEventSourceVectorize =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsCreateResponseSourceMqEventSourceVectorizeType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateResponseSourceMqEventSourceVectorize",
  }) as any as S.Schema<SubscriptionsCreateResponseSourceMqEventSourceVectorize>;

export type SubscriptionsCreateResponseSourceMqEventSourceWorkersAIModelType =
  "workersAi.model";
export const SubscriptionsCreateResponseSourceMqEventSourceWorkersAIModelType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateResponseSourceMqEventSourceWorkersAIModel {
  /** Name of the Workers AI model */
  modelName?: string | null;
  /** Type of source */
  type?: SubscriptionsCreateResponseSourceMqEventSourceWorkersAIModelType | null;
}
export const SubscriptionsCreateResponseSourceMqEventSourceWorkersAIModel =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      modelName: S.optional(S.NullOr(S.String).pipe(T.Body("model_name"))),
      type: S.optional(
        S.NullOr(
          SubscriptionsCreateResponseSourceMqEventSourceWorkersAIModelType,
        ),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsCreateResponseSourceMqEventSourceWorkersAIModel",
  }) as any as S.Schema<SubscriptionsCreateResponseSourceMqEventSourceWorkersAIModel>;

export type SubscriptionsCreateResponseSourceMqEventSourceWorkersBuildsWorkerType =
  "workersBuilds.worker";
export const SubscriptionsCreateResponseSourceMqEventSourceWorkersBuildsWorkerType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateResponseSourceMqEventSourceWorkersBuildsWorker {
  /** Type of source */
  type?: SubscriptionsCreateResponseSourceMqEventSourceWorkersBuildsWorkerType | null;
  /** Name of the worker */
  workerName?: string | null;
}
export const SubscriptionsCreateResponseSourceMqEventSourceWorkersBuildsWorker =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsCreateResponseSourceMqEventSourceWorkersBuildsWorkerType,
        ),
      ),
      workerName: S.optional(S.NullOr(S.String).pipe(T.Body("worker_name"))),
    }),
  ).annotate({
    identifier:
      "SubscriptionsCreateResponseSourceMqEventSourceWorkersBuildsWorker",
  }) as any as S.Schema<SubscriptionsCreateResponseSourceMqEventSourceWorkersBuildsWorker>;

export type SubscriptionsCreateResponseSourceMqEventSourceWorkflowsWorkflowType =
  "workflows.workflow";
export const SubscriptionsCreateResponseSourceMqEventSourceWorkflowsWorkflowType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsCreateResponseSourceMqEventSourceWorkflowsWorkflow {
  /** Type of source */
  type?: SubscriptionsCreateResponseSourceMqEventSourceWorkflowsWorkflowType | null;
  /** Name of the workflow */
  workflowName?: string | null;
}
export const SubscriptionsCreateResponseSourceMqEventSourceWorkflowsWorkflow =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsCreateResponseSourceMqEventSourceWorkflowsWorkflowType,
        ),
      ),
      workflowName: S.optional(
        S.NullOr(S.String).pipe(T.Body("workflow_name")),
      ),
    }),
  ).annotate({
    identifier:
      "SubscriptionsCreateResponseSourceMqEventSourceWorkflowsWorkflow",
  }) as any as S.Schema<SubscriptionsCreateResponseSourceMqEventSourceWorkflowsWorkflow>;

export type SubscriptionsCreateResponseSource =
  | SubscriptionsCreateResponseSourceMqEventSourceImages
  | SubscriptionsCreateResponseSourceMqEventSourceKV
  | SubscriptionsCreateResponseSourceMqEventSourceR2
  | SubscriptionsCreateResponseSourceMqEventSourceSuperSlurper
  | SubscriptionsCreateResponseSourceMqEventSourceVectorize
  | SubscriptionsCreateResponseSourceMqEventSourceWorkersAIModel
  | SubscriptionsCreateResponseSourceMqEventSourceWorkersBuildsWorker
  | SubscriptionsCreateResponseSourceMqEventSourceWorkflowsWorkflow;
export const SubscriptionsCreateResponseSource = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["modelName", "type"],
    ["type", "workerName"],
    ["type", "workflowName"],
  ]),
);

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateSubscriptionResponse {
  /** Unique identifier for the subscription */
  id: string;
  /** When the subscription was created */
  createdAt: string;
  /** Destination configuration for the subscription */
  destination: SubscriptionsCreateResponseDestination;
  /** Whether the subscription is active */
  enabled: boolean;
  /** List of event types this subscription handles */
  events: SubscriptionsCreateResponseEventsList;
  /** When the subscription was last modified */
  modifiedAt: string;
  /** Name of the subscription */
  name: string;
  /** Source configuration for the subscription */
  source: SubscriptionsCreateResponseSource;
}
export const CreateSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    destination: SubscriptionsCreateResponseDestination,
    enabled: S.Boolean,
    events: SubscriptionsCreateResponseEventsList,
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    source: SubscriptionsCreateResponseSource,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateSubscriptionResponse",
}) as any as S.Schema<CreateSubscriptionResponse>;

export interface DeleteConsumerRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
  /** A Resource identifier. */
  consumerId: string;
}
export const DeleteConsumerRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
    consumerId: S.String.pipe(T.Label("consumer_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/queues/{queue_id}/consumers/{consumer_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteConsumerRequest",
}) as any as S.Schema<DeleteConsumerRequest>;

export interface DeleteConsumerResponse {}
export const DeleteConsumerResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteConsumerResponse",
}) as any as S.Schema<DeleteConsumerResponse>;

export interface DeleteQueueRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
}
export const DeleteQueueRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/queues/{queue_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteQueueRequest",
}) as any as S.Schema<DeleteQueueRequest>;

export interface DeleteQueueResponse {}
export const DeleteQueueResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteQueueResponse",
}) as any as S.Schema<DeleteQueueResponse>;

export interface DeleteSubscriptionRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  subscriptionId: string;
}
export const DeleteSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    subscriptionId: S.String.pipe(T.Label("subscription_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/event_subscriptions/subscriptions/{subscription_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteSubscriptionRequest",
}) as any as S.Schema<DeleteSubscriptionRequest>;

export type SubscriptionsDeleteResponseDestinationType = "queues.queue";
export const SubscriptionsDeleteResponseDestinationType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsDeleteResponseDestination {
  /** ID of the target queue */
  queueId: string;
  /** Type of destination */
  type: SubscriptionsDeleteResponseDestinationType;
}
export const SubscriptionsDeleteResponseDestination = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      queueId: S.String.pipe(T.Body("queue_id")),
      type: SubscriptionsDeleteResponseDestinationType,
    }),
).annotate({
  identifier: "SubscriptionsDeleteResponseDestination",
}) as any as S.Schema<SubscriptionsDeleteResponseDestination>;

export type SubscriptionsDeleteResponseEventsList = Array<string>;
export const SubscriptionsDeleteResponseEventsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<SubscriptionsDeleteResponseEventsList>;

export type SubscriptionsDeleteResponseSourceMqEventSourceImagesType = "images";
export const SubscriptionsDeleteResponseSourceMqEventSourceImagesType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsDeleteResponseSourceMqEventSourceImages {
  /** Type of source */
  type?: SubscriptionsDeleteResponseSourceMqEventSourceImagesType | null;
}
export const SubscriptionsDeleteResponseSourceMqEventSourceImages =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsDeleteResponseSourceMqEventSourceImagesType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsDeleteResponseSourceMqEventSourceImages",
  }) as any as S.Schema<SubscriptionsDeleteResponseSourceMqEventSourceImages>;

export type SubscriptionsDeleteResponseSourceMqEventSourceKVType = "kv";
export const SubscriptionsDeleteResponseSourceMqEventSourceKVType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsDeleteResponseSourceMqEventSourceKV {
  /** Type of source */
  type?: SubscriptionsDeleteResponseSourceMqEventSourceKVType | null;
}
export const SubscriptionsDeleteResponseSourceMqEventSourceKV =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsDeleteResponseSourceMqEventSourceKVType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsDeleteResponseSourceMqEventSourceKV",
  }) as any as S.Schema<SubscriptionsDeleteResponseSourceMqEventSourceKV>;

export type SubscriptionsDeleteResponseSourceMqEventSourceR2Type = "r2";
export const SubscriptionsDeleteResponseSourceMqEventSourceR2Type =
  /*@__PURE__*/ S.String;

export interface SubscriptionsDeleteResponseSourceMqEventSourceR2 {
  /** Type of source */
  type?: SubscriptionsDeleteResponseSourceMqEventSourceR2Type | null;
}
export const SubscriptionsDeleteResponseSourceMqEventSourceR2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsDeleteResponseSourceMqEventSourceR2Type),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsDeleteResponseSourceMqEventSourceR2",
  }) as any as S.Schema<SubscriptionsDeleteResponseSourceMqEventSourceR2>;

export type SubscriptionsDeleteResponseSourceMqEventSourceSuperSlurperType =
  "superSlurper";
export const SubscriptionsDeleteResponseSourceMqEventSourceSuperSlurperType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsDeleteResponseSourceMqEventSourceSuperSlurper {
  /** Type of source */
  type?: SubscriptionsDeleteResponseSourceMqEventSourceSuperSlurperType | null;
}
export const SubscriptionsDeleteResponseSourceMqEventSourceSuperSlurper =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsDeleteResponseSourceMqEventSourceSuperSlurperType,
        ),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsDeleteResponseSourceMqEventSourceSuperSlurper",
  }) as any as S.Schema<SubscriptionsDeleteResponseSourceMqEventSourceSuperSlurper>;

export type SubscriptionsDeleteResponseSourceMqEventSourceVectorizeType =
  "vectorize";
export const SubscriptionsDeleteResponseSourceMqEventSourceVectorizeType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsDeleteResponseSourceMqEventSourceVectorize {
  /** Type of source */
  type?: SubscriptionsDeleteResponseSourceMqEventSourceVectorizeType | null;
}
export const SubscriptionsDeleteResponseSourceMqEventSourceVectorize =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsDeleteResponseSourceMqEventSourceVectorizeType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsDeleteResponseSourceMqEventSourceVectorize",
  }) as any as S.Schema<SubscriptionsDeleteResponseSourceMqEventSourceVectorize>;

export type SubscriptionsDeleteResponseSourceMqEventSourceWorkersAIModelType =
  "workersAi.model";
export const SubscriptionsDeleteResponseSourceMqEventSourceWorkersAIModelType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsDeleteResponseSourceMqEventSourceWorkersAIModel {
  /** Name of the Workers AI model */
  modelName?: string | null;
  /** Type of source */
  type?: SubscriptionsDeleteResponseSourceMqEventSourceWorkersAIModelType | null;
}
export const SubscriptionsDeleteResponseSourceMqEventSourceWorkersAIModel =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      modelName: S.optional(S.NullOr(S.String).pipe(T.Body("model_name"))),
      type: S.optional(
        S.NullOr(
          SubscriptionsDeleteResponseSourceMqEventSourceWorkersAIModelType,
        ),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsDeleteResponseSourceMqEventSourceWorkersAIModel",
  }) as any as S.Schema<SubscriptionsDeleteResponseSourceMqEventSourceWorkersAIModel>;

export type SubscriptionsDeleteResponseSourceMqEventSourceWorkersBuildsWorkerType =
  "workersBuilds.worker";
export const SubscriptionsDeleteResponseSourceMqEventSourceWorkersBuildsWorkerType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsDeleteResponseSourceMqEventSourceWorkersBuildsWorker {
  /** Type of source */
  type?: SubscriptionsDeleteResponseSourceMqEventSourceWorkersBuildsWorkerType | null;
  /** Name of the worker */
  workerName?: string | null;
}
export const SubscriptionsDeleteResponseSourceMqEventSourceWorkersBuildsWorker =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsDeleteResponseSourceMqEventSourceWorkersBuildsWorkerType,
        ),
      ),
      workerName: S.optional(S.NullOr(S.String).pipe(T.Body("worker_name"))),
    }),
  ).annotate({
    identifier:
      "SubscriptionsDeleteResponseSourceMqEventSourceWorkersBuildsWorker",
  }) as any as S.Schema<SubscriptionsDeleteResponseSourceMqEventSourceWorkersBuildsWorker>;

export type SubscriptionsDeleteResponseSourceMqEventSourceWorkflowsWorkflowType =
  "workflows.workflow";
export const SubscriptionsDeleteResponseSourceMqEventSourceWorkflowsWorkflowType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsDeleteResponseSourceMqEventSourceWorkflowsWorkflow {
  /** Type of source */
  type?: SubscriptionsDeleteResponseSourceMqEventSourceWorkflowsWorkflowType | null;
  /** Name of the workflow */
  workflowName?: string | null;
}
export const SubscriptionsDeleteResponseSourceMqEventSourceWorkflowsWorkflow =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsDeleteResponseSourceMqEventSourceWorkflowsWorkflowType,
        ),
      ),
      workflowName: S.optional(
        S.NullOr(S.String).pipe(T.Body("workflow_name")),
      ),
    }),
  ).annotate({
    identifier:
      "SubscriptionsDeleteResponseSourceMqEventSourceWorkflowsWorkflow",
  }) as any as S.Schema<SubscriptionsDeleteResponseSourceMqEventSourceWorkflowsWorkflow>;

export type SubscriptionsDeleteResponseSource =
  | SubscriptionsDeleteResponseSourceMqEventSourceImages
  | SubscriptionsDeleteResponseSourceMqEventSourceKV
  | SubscriptionsDeleteResponseSourceMqEventSourceR2
  | SubscriptionsDeleteResponseSourceMqEventSourceSuperSlurper
  | SubscriptionsDeleteResponseSourceMqEventSourceVectorize
  | SubscriptionsDeleteResponseSourceMqEventSourceWorkersAIModel
  | SubscriptionsDeleteResponseSourceMqEventSourceWorkersBuildsWorker
  | SubscriptionsDeleteResponseSourceMqEventSourceWorkflowsWorkflow;
export const SubscriptionsDeleteResponseSource = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["modelName", "type"],
    ["type", "workerName"],
    ["type", "workflowName"],
  ]),
);

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteSubscriptionResponse {
  /** Unique identifier for the subscription */
  id: string;
  /** When the subscription was created */
  createdAt: string;
  /** Destination configuration for the subscription */
  destination: SubscriptionsDeleteResponseDestination;
  /** Whether the subscription is active */
  enabled: boolean;
  /** List of event types this subscription handles */
  events: SubscriptionsDeleteResponseEventsList;
  /** When the subscription was last modified */
  modifiedAt: string;
  /** Name of the subscription */
  name: string;
  /** Source configuration for the subscription */
  source: SubscriptionsDeleteResponseSource;
}
export const DeleteSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    destination: SubscriptionsDeleteResponseDestination,
    enabled: S.Boolean,
    events: SubscriptionsDeleteResponseEventsList,
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    source: SubscriptionsDeleteResponseSource,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteSubscriptionResponse",
}) as any as S.Schema<DeleteSubscriptionResponse>;

export interface GetConsumerRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
  /** A Resource identifier. */
  consumerId: string;
}
export const GetConsumerRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
    consumerId: S.String.pipe(T.Label("consumer_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/queues/{queue_id}/consumers/{consumer_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetConsumerRequest",
}) as any as S.Schema<GetConsumerRequest>;

export type ConsumersGetResultWorkerSettings =
  ConsumersCreateResultWorkerSettings;
export const ConsumersGetResultWorkerSettings =
  ConsumersCreateResultWorkerSettings;

export type ConsumersGetResultWorkerType = "worker";
export const ConsumersGetResultWorkerType = /*@__PURE__*/ S.String;

export interface ConsumersGetResultWorker {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  /** Name of a Worker */
  scriptName?: string | null;
  settings?: ConsumersCreateResultWorkerSettings | null;
  type?: ConsumersGetResultWorkerType | null;
}
export const ConsumersGetResultWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultWorkerSettings)),
    type: S.optional(S.NullOr(ConsumersGetResultWorkerType)),
  }),
).annotate({
  identifier: "ConsumersGetResultWorker",
}) as any as S.Schema<ConsumersGetResultWorker>;

export type ConsumersGetResultHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;
export const ConsumersGetResultHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;

export type ConsumersGetResultHTTPPullType = "http_pull";
export const ConsumersGetResultHTTPPullType = /*@__PURE__*/ S.String;

export interface ConsumersGetResultHTTPPull {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  settings?: ConsumersCreateResultHTTPPullSettings | null;
  type?: ConsumersGetResultHTTPPullType | null;
}
export const ConsumersGetResultHTTPPull = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultHTTPPullSettings)),
    type: S.optional(S.NullOr(ConsumersGetResultHTTPPullType)),
  }),
).annotate({
  identifier: "ConsumersGetResultHTTPPull",
}) as any as S.Schema<ConsumersGetResultHTTPPull>;

export type ConsumersGetResult =
  | ConsumersGetResultWorker
  | ConsumersGetResultHTTPPull;
export const ConsumersGetResult = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "scriptName",
      "settings",
      "type",
    ],
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "settings",
      "type",
    ],
  ]),
);

export type GetConsumerResponse = ConsumersGetResult;
export const GetConsumerResponse = /*@__PURE__*/ S.suspend(() =>
  ConsumersGetResult.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "GetConsumerResponse",
}) as any as S.Schema<GetConsumerResponse>;

export interface GetMetricsQueueRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
}
export const GetMetricsQueueRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/queues/{queue_id}/metrics",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMetricsQueueRequest",
}) as any as S.Schema<GetMetricsQueueRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetMetricsQueueResponse {
  /** The size in bytes of unacknowledged messages in the queue. */
  backlogBytes: number;
  /** The number of unacknowledged messages in the queue. */
  backlogCount: number;
  /** Unix timestamp in milliseconds of the oldest unacknowledged message in the queue. Returns 0 if unknown. */
  oldestMessageTimestampMs: number;
}
export const GetMetricsQueueResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    backlogBytes: S.Number.pipe(T.Body("backlog_bytes")),
    backlogCount: S.Number.pipe(T.Body("backlog_count")),
    oldestMessageTimestampMs: S.Number.pipe(
      T.Body("oldest_message_timestamp_ms"),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMetricsQueueResponse",
}) as any as S.Schema<GetMetricsQueueResponse>;

export interface GetQueueRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
}
export const GetQueueRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/queues/{queue_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetQueueRequest",
}) as any as S.Schema<GetQueueRequest>;

export type GetResponseConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;
export const GetResponseConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;

export type GetResponseConsumersItemWorkerType = "worker";
export const GetResponseConsumersItemWorkerType = /*@__PURE__*/ S.String;

export interface GetResponseConsumersItemWorker {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  /** Name of a Worker */
  scriptName?: string | null;
  settings?: ConsumersCreateResultWorkerSettings | null;
  type?: GetResponseConsumersItemWorkerType | null;
}
export const GetResponseConsumersItemWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultWorkerSettings)),
    type: S.optional(S.NullOr(GetResponseConsumersItemWorkerType)),
  }),
).annotate({
  identifier: "GetResponseConsumersItemWorker",
}) as any as S.Schema<GetResponseConsumersItemWorker>;

export type GetResponseConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;
export const GetResponseConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;

export type GetResponseConsumersItemHTTPPullType = "http_pull";
export const GetResponseConsumersItemHTTPPullType = /*@__PURE__*/ S.String;

export interface GetResponseConsumersItemHTTPPull {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  settings?: ConsumersCreateResultHTTPPullSettings | null;
  type?: GetResponseConsumersItemHTTPPullType | null;
}
export const GetResponseConsumersItemHTTPPull = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultHTTPPullSettings)),
    type: S.optional(S.NullOr(GetResponseConsumersItemHTTPPullType)),
  }),
).annotate({
  identifier: "GetResponseConsumersItemHTTPPull",
}) as any as S.Schema<GetResponseConsumersItemHTTPPull>;

export type GetResponseConsumersItem =
  | GetResponseConsumersItemWorker
  | GetResponseConsumersItemHTTPPull;
export const GetResponseConsumersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "scriptName",
      "settings",
      "type",
    ],
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "settings",
      "type",
    ],
  ]),
);

export type GetResponseConsumersList = Array<GetResponseConsumersItem>;
export const GetResponseConsumersList = /*@__PURE__*/ S.Array(
  GetResponseConsumersItem,
) as any as S.Schema<GetResponseConsumersList>;

export type GetResponseProducersItemMqWorkerProducerType = "worker";
export const GetResponseProducersItemMqWorkerProducerType =
  /*@__PURE__*/ S.String;

export interface GetResponseProducersItemMqWorkerProducer {
  type?: GetResponseProducersItemMqWorkerProducerType | null;
  scriptName?: string | null;
}
export const GetResponseProducersItemMqWorkerProducer = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      type: S.optional(S.NullOr(GetResponseProducersItemMqWorkerProducerType)),
      scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    }),
).annotate({
  identifier: "GetResponseProducersItemMqWorkerProducer",
}) as any as S.Schema<GetResponseProducersItemMqWorkerProducer>;

export type GetResponseProducersItemMqR2ProducerType = "r2_bucket";
export const GetResponseProducersItemMqR2ProducerType = /*@__PURE__*/ S.String;

export interface GetResponseProducersItemMqR2Producer {
  bucketName?: string | null;
  type?: GetResponseProducersItemMqR2ProducerType | null;
}
export const GetResponseProducersItemMqR2Producer = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      bucketName: S.optional(S.NullOr(S.String).pipe(T.Body("bucket_name"))),
      type: S.optional(S.NullOr(GetResponseProducersItemMqR2ProducerType)),
    }),
).annotate({
  identifier: "GetResponseProducersItemMqR2Producer",
}) as any as S.Schema<GetResponseProducersItemMqR2Producer>;

export type GetResponseProducersItem =
  | GetResponseProducersItemMqWorkerProducer
  | GetResponseProducersItemMqR2Producer;
export const GetResponseProducersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "scriptName"],
    ["bucketName", "type"],
  ]),
);

export type GetResponseProducersList = Array<GetResponseProducersItem>;
export const GetResponseProducersList = /*@__PURE__*/ S.Array(
  GetResponseProducersItem,
) as any as S.Schema<GetResponseProducersList>;

export type GetResponseSettings = CreateResponseSettings;
export const GetResponseSettings = CreateResponseSettings;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetQueueResponse {
  consumers?: GetResponseConsumersList | null;
  consumersTotalCount?: number | null;
  createdOn?: string | null;
  modifiedOn?: string | null;
  producers?: GetResponseProducersList | null;
  producersTotalCount?: number | null;
  queueId?: string | null;
  queueName?: string | null;
  settings?: CreateResponseSettings | null;
}
export const GetQueueResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumers: S.optional(S.NullOr(GetResponseConsumersList)),
    consumersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("consumers_total_count")),
    ),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    producers: S.optional(S.NullOr(GetResponseProducersList)),
    producersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("producers_total_count")),
    ),
    queueId: S.optional(S.NullOr(S.String).pipe(T.Body("queue_id"))),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(CreateResponseSettings)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetQueueResponse",
}) as any as S.Schema<GetQueueResponse>;

export interface GetSubscriptionRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  subscriptionId: string;
}
export const GetSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    subscriptionId: S.String.pipe(T.Label("subscription_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/event_subscriptions/subscriptions/{subscription_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSubscriptionRequest",
}) as any as S.Schema<GetSubscriptionRequest>;

export type SubscriptionsGetResponseDestinationType = "queues.queue";
export const SubscriptionsGetResponseDestinationType = /*@__PURE__*/ S.String;

export interface SubscriptionsGetResponseDestination {
  /** ID of the target queue */
  queueId: string;
  /** Type of destination */
  type: SubscriptionsGetResponseDestinationType;
}
export const SubscriptionsGetResponseDestination = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    queueId: S.String.pipe(T.Body("queue_id")),
    type: SubscriptionsGetResponseDestinationType,
  }),
).annotate({
  identifier: "SubscriptionsGetResponseDestination",
}) as any as S.Schema<SubscriptionsGetResponseDestination>;

export type SubscriptionsGetResponseEventsList = Array<string>;
export const SubscriptionsGetResponseEventsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<SubscriptionsGetResponseEventsList>;

export type SubscriptionsGetResponseSourceMqEventSourceImagesType = "images";
export const SubscriptionsGetResponseSourceMqEventSourceImagesType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsGetResponseSourceMqEventSourceImages {
  /** Type of source */
  type?: SubscriptionsGetResponseSourceMqEventSourceImagesType | null;
}
export const SubscriptionsGetResponseSourceMqEventSourceImages =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsGetResponseSourceMqEventSourceImagesType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsGetResponseSourceMqEventSourceImages",
  }) as any as S.Schema<SubscriptionsGetResponseSourceMqEventSourceImages>;

export type SubscriptionsGetResponseSourceMqEventSourceKVType = "kv";
export const SubscriptionsGetResponseSourceMqEventSourceKVType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsGetResponseSourceMqEventSourceKV {
  /** Type of source */
  type?: SubscriptionsGetResponseSourceMqEventSourceKVType | null;
}
export const SubscriptionsGetResponseSourceMqEventSourceKV =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsGetResponseSourceMqEventSourceKVType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsGetResponseSourceMqEventSourceKV",
  }) as any as S.Schema<SubscriptionsGetResponseSourceMqEventSourceKV>;

export type SubscriptionsGetResponseSourceMqEventSourceR2Type = "r2";
export const SubscriptionsGetResponseSourceMqEventSourceR2Type =
  /*@__PURE__*/ S.String;

export interface SubscriptionsGetResponseSourceMqEventSourceR2 {
  /** Type of source */
  type?: SubscriptionsGetResponseSourceMqEventSourceR2Type | null;
}
export const SubscriptionsGetResponseSourceMqEventSourceR2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsGetResponseSourceMqEventSourceR2Type),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsGetResponseSourceMqEventSourceR2",
  }) as any as S.Schema<SubscriptionsGetResponseSourceMqEventSourceR2>;

export type SubscriptionsGetResponseSourceMqEventSourceSuperSlurperType =
  "superSlurper";
export const SubscriptionsGetResponseSourceMqEventSourceSuperSlurperType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsGetResponseSourceMqEventSourceSuperSlurper {
  /** Type of source */
  type?: SubscriptionsGetResponseSourceMqEventSourceSuperSlurperType | null;
}
export const SubscriptionsGetResponseSourceMqEventSourceSuperSlurper =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsGetResponseSourceMqEventSourceSuperSlurperType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsGetResponseSourceMqEventSourceSuperSlurper",
  }) as any as S.Schema<SubscriptionsGetResponseSourceMqEventSourceSuperSlurper>;

export type SubscriptionsGetResponseSourceMqEventSourceVectorizeType =
  "vectorize";
export const SubscriptionsGetResponseSourceMqEventSourceVectorizeType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsGetResponseSourceMqEventSourceVectorize {
  /** Type of source */
  type?: SubscriptionsGetResponseSourceMqEventSourceVectorizeType | null;
}
export const SubscriptionsGetResponseSourceMqEventSourceVectorize =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsGetResponseSourceMqEventSourceVectorizeType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsGetResponseSourceMqEventSourceVectorize",
  }) as any as S.Schema<SubscriptionsGetResponseSourceMqEventSourceVectorize>;

export type SubscriptionsGetResponseSourceMqEventSourceWorkersAIModelType =
  "workersAi.model";
export const SubscriptionsGetResponseSourceMqEventSourceWorkersAIModelType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsGetResponseSourceMqEventSourceWorkersAIModel {
  /** Name of the Workers AI model */
  modelName?: string | null;
  /** Type of source */
  type?: SubscriptionsGetResponseSourceMqEventSourceWorkersAIModelType | null;
}
export const SubscriptionsGetResponseSourceMqEventSourceWorkersAIModel =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      modelName: S.optional(S.NullOr(S.String).pipe(T.Body("model_name"))),
      type: S.optional(
        S.NullOr(SubscriptionsGetResponseSourceMqEventSourceWorkersAIModelType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsGetResponseSourceMqEventSourceWorkersAIModel",
  }) as any as S.Schema<SubscriptionsGetResponseSourceMqEventSourceWorkersAIModel>;

export type SubscriptionsGetResponseSourceMqEventSourceWorkersBuildsWorkerType =
  "workersBuilds.worker";
export const SubscriptionsGetResponseSourceMqEventSourceWorkersBuildsWorkerType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsGetResponseSourceMqEventSourceWorkersBuildsWorker {
  /** Type of source */
  type?: SubscriptionsGetResponseSourceMqEventSourceWorkersBuildsWorkerType | null;
  /** Name of the worker */
  workerName?: string | null;
}
export const SubscriptionsGetResponseSourceMqEventSourceWorkersBuildsWorker =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsGetResponseSourceMqEventSourceWorkersBuildsWorkerType,
        ),
      ),
      workerName: S.optional(S.NullOr(S.String).pipe(T.Body("worker_name"))),
    }),
  ).annotate({
    identifier:
      "SubscriptionsGetResponseSourceMqEventSourceWorkersBuildsWorker",
  }) as any as S.Schema<SubscriptionsGetResponseSourceMqEventSourceWorkersBuildsWorker>;

export type SubscriptionsGetResponseSourceMqEventSourceWorkflowsWorkflowType =
  "workflows.workflow";
export const SubscriptionsGetResponseSourceMqEventSourceWorkflowsWorkflowType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsGetResponseSourceMqEventSourceWorkflowsWorkflow {
  /** Type of source */
  type?: SubscriptionsGetResponseSourceMqEventSourceWorkflowsWorkflowType | null;
  /** Name of the workflow */
  workflowName?: string | null;
}
export const SubscriptionsGetResponseSourceMqEventSourceWorkflowsWorkflow =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsGetResponseSourceMqEventSourceWorkflowsWorkflowType,
        ),
      ),
      workflowName: S.optional(
        S.NullOr(S.String).pipe(T.Body("workflow_name")),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsGetResponseSourceMqEventSourceWorkflowsWorkflow",
  }) as any as S.Schema<SubscriptionsGetResponseSourceMqEventSourceWorkflowsWorkflow>;

export type SubscriptionsGetResponseSource =
  | SubscriptionsGetResponseSourceMqEventSourceImages
  | SubscriptionsGetResponseSourceMqEventSourceKV
  | SubscriptionsGetResponseSourceMqEventSourceR2
  | SubscriptionsGetResponseSourceMqEventSourceSuperSlurper
  | SubscriptionsGetResponseSourceMqEventSourceVectorize
  | SubscriptionsGetResponseSourceMqEventSourceWorkersAIModel
  | SubscriptionsGetResponseSourceMqEventSourceWorkersBuildsWorker
  | SubscriptionsGetResponseSourceMqEventSourceWorkflowsWorkflow;
export const SubscriptionsGetResponseSource = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["modelName", "type"],
    ["type", "workerName"],
    ["type", "workflowName"],
  ]),
);

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetSubscriptionResponse {
  /** Unique identifier for the subscription */
  id: string;
  /** When the subscription was created */
  createdAt: string;
  /** Destination configuration for the subscription */
  destination: SubscriptionsGetResponseDestination;
  /** Whether the subscription is active */
  enabled: boolean;
  /** List of event types this subscription handles */
  events: SubscriptionsGetResponseEventsList;
  /** When the subscription was last modified */
  modifiedAt: string;
  /** Name of the subscription */
  name: string;
  /** Source configuration for the subscription */
  source: SubscriptionsGetResponseSource;
}
export const GetSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    destination: SubscriptionsGetResponseDestination,
    enabled: S.Boolean,
    events: SubscriptionsGetResponseEventsList,
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    source: SubscriptionsGetResponseSource,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSubscriptionResponse",
}) as any as S.Schema<GetSubscriptionResponse>;

export interface ListConsumersRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
}
export const ListConsumersRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/queues/{queue_id}/consumers",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListConsumersRequest",
}) as any as S.Schema<ListConsumersRequest>;

export type ConsumersListResultItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;
export const ConsumersListResultItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;

export type ConsumersListResultItemWorkerType = "worker";
export const ConsumersListResultItemWorkerType = /*@__PURE__*/ S.String;

export interface ConsumersListResultItemWorker {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  /** Name of a Worker */
  scriptName?: string | null;
  settings?: ConsumersCreateResultWorkerSettings | null;
  type?: ConsumersListResultItemWorkerType | null;
}
export const ConsumersListResultItemWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultWorkerSettings)),
    type: S.optional(S.NullOr(ConsumersListResultItemWorkerType)),
  }),
).annotate({
  identifier: "ConsumersListResultItemWorker",
}) as any as S.Schema<ConsumersListResultItemWorker>;

export type ConsumersListResultItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;
export const ConsumersListResultItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;

export type ConsumersListResultItemHTTPPullType = "http_pull";
export const ConsumersListResultItemHTTPPullType = /*@__PURE__*/ S.String;

export interface ConsumersListResultItemHTTPPull {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  settings?: ConsumersCreateResultHTTPPullSettings | null;
  type?: ConsumersListResultItemHTTPPullType | null;
}
export const ConsumersListResultItemHTTPPull = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultHTTPPullSettings)),
    type: S.optional(S.NullOr(ConsumersListResultItemHTTPPullType)),
  }),
).annotate({
  identifier: "ConsumersListResultItemHTTPPull",
}) as any as S.Schema<ConsumersListResultItemHTTPPull>;

export type ConsumersListResultItem =
  | ConsumersListResultItemWorker
  | ConsumersListResultItemHTTPPull;
export const ConsumersListResultItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "scriptName",
      "settings",
      "type",
    ],
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "settings",
      "type",
    ],
  ]),
);

export type ConsumersListResultList = Array<ConsumersListResultItem>;
export const ConsumersListResultList = /*@__PURE__*/ S.Array(
  ConsumersListResultItem,
) as any as S.Schema<ConsumersListResultList>;

export interface ListConsumersResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: ConsumersListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListConsumersResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: ConsumersListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListConsumersResponse",
}) as any as S.Schema<ListConsumersResponse>;

export interface ListQueuesRequest {
  /** A Resource identifier. */
  accountId: string;
}
export const ListQueuesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/queues",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListQueuesRequest",
}) as any as S.Schema<ListQueuesRequest>;

export type ListResultItemConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;
export const ListResultItemConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;

export type ListResultItemConsumersItemWorkerType = "worker";
export const ListResultItemConsumersItemWorkerType = /*@__PURE__*/ S.String;

export interface ListResultItemConsumersItemWorker {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  /** Name of a Worker */
  scriptName?: string | null;
  settings?: ConsumersCreateResultWorkerSettings | null;
  type?: ListResultItemConsumersItemWorkerType | null;
}
export const ListResultItemConsumersItemWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultWorkerSettings)),
    type: S.optional(S.NullOr(ListResultItemConsumersItemWorkerType)),
  }),
).annotate({
  identifier: "ListResultItemConsumersItemWorker",
}) as any as S.Schema<ListResultItemConsumersItemWorker>;

export type ListResultItemConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;
export const ListResultItemConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;

export type ListResultItemConsumersItemHTTPPullType = "http_pull";
export const ListResultItemConsumersItemHTTPPullType = /*@__PURE__*/ S.String;

export interface ListResultItemConsumersItemHTTPPull {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  settings?: ConsumersCreateResultHTTPPullSettings | null;
  type?: ListResultItemConsumersItemHTTPPullType | null;
}
export const ListResultItemConsumersItemHTTPPull = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultHTTPPullSettings)),
    type: S.optional(S.NullOr(ListResultItemConsumersItemHTTPPullType)),
  }),
).annotate({
  identifier: "ListResultItemConsumersItemHTTPPull",
}) as any as S.Schema<ListResultItemConsumersItemHTTPPull>;

export type ListResultItemConsumersItem =
  | ListResultItemConsumersItemWorker
  | ListResultItemConsumersItemHTTPPull;
export const ListResultItemConsumersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "scriptName",
      "settings",
      "type",
    ],
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "settings",
      "type",
    ],
  ]),
);

export type ListResultItemConsumersList = Array<ListResultItemConsumersItem>;
export const ListResultItemConsumersList = /*@__PURE__*/ S.Array(
  ListResultItemConsumersItem,
) as any as S.Schema<ListResultItemConsumersList>;

export type ListResultItemProducersItemMqWorkerProducerType = "worker";
export const ListResultItemProducersItemMqWorkerProducerType =
  /*@__PURE__*/ S.String;

export interface ListResultItemProducersItemMqWorkerProducer {
  type?: ListResultItemProducersItemMqWorkerProducerType | null;
  scriptName?: string | null;
}
export const ListResultItemProducersItemMqWorkerProducer =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(ListResultItemProducersItemMqWorkerProducerType),
      ),
      scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    }),
  ).annotate({
    identifier: "ListResultItemProducersItemMqWorkerProducer",
  }) as any as S.Schema<ListResultItemProducersItemMqWorkerProducer>;

export type ListResultItemProducersItemMqR2ProducerType = "r2_bucket";
export const ListResultItemProducersItemMqR2ProducerType =
  /*@__PURE__*/ S.String;

export interface ListResultItemProducersItemMqR2Producer {
  bucketName?: string | null;
  type?: ListResultItemProducersItemMqR2ProducerType | null;
}
export const ListResultItemProducersItemMqR2Producer = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      bucketName: S.optional(S.NullOr(S.String).pipe(T.Body("bucket_name"))),
      type: S.optional(S.NullOr(ListResultItemProducersItemMqR2ProducerType)),
    }),
).annotate({
  identifier: "ListResultItemProducersItemMqR2Producer",
}) as any as S.Schema<ListResultItemProducersItemMqR2Producer>;

export type ListResultItemProducersItem =
  | ListResultItemProducersItemMqWorkerProducer
  | ListResultItemProducersItemMqR2Producer;
export const ListResultItemProducersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "scriptName"],
    ["bucketName", "type"],
  ]),
);

export type ListResultItemProducersList = Array<ListResultItemProducersItem>;
export const ListResultItemProducersList = /*@__PURE__*/ S.Array(
  ListResultItemProducersItem,
) as any as S.Schema<ListResultItemProducersList>;

export type ListResultItemSettings = CreateResponseSettings;
export const ListResultItemSettings = CreateResponseSettings;

export interface ListResultItem {
  consumers?: ListResultItemConsumersList | null;
  consumersTotalCount?: number | null;
  createdOn?: string | null;
  modifiedOn?: string | null;
  producers?: ListResultItemProducersList | null;
  producersTotalCount?: number | null;
  queueId?: string | null;
  queueName?: string | null;
  settings?: CreateResponseSettings | null;
}
export const ListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumers: S.optional(S.NullOr(ListResultItemConsumersList)),
    consumersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("consumers_total_count")),
    ),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    producers: S.optional(S.NullOr(ListResultItemProducersList)),
    producersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("producers_total_count")),
    ),
    queueId: S.optional(S.NullOr(S.String).pipe(T.Body("queue_id"))),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(CreateResponseSettings)),
  }),
).annotate({ identifier: "ListResultItem" }) as any as S.Schema<ListResultItem>;

export type ListResultList = Array<ListResultItem>;
export const ListResultList = /*@__PURE__*/ S.Array(
  ListResultItem,
) as any as S.Schema<ListResultList>;

export interface ListQueuesResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: ListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListQueuesResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: ListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListQueuesResponse",
}) as any as S.Schema<ListQueuesResponse>;

export type SubscriptionsListRequestDirection = "asc" | "desc";
export const SubscriptionsListRequestDirection = /*@__PURE__*/ S.String;

export type SubscriptionsListRequestOrder =
  | "created_at"
  | "name"
  | "enabled"
  | "source";
export const SubscriptionsListRequestOrder = /*@__PURE__*/ S.String;

export interface ListSubscriptionsRequest {
  /** A Resource identifier. */
  accountId: string;
  /** Sort direction */
  direction?: SubscriptionsListRequestDirection | (string & {});
  /** Field to sort by */
  order?: SubscriptionsListRequestOrder | (string & {});
  /** Page number for pagination */
  page?: number;
  /** Number of items per page */
  perPage?: number;
}
export const ListSubscriptionsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    direction: S.optional(SubscriptionsListRequestDirection.pipe(T.Query())),
    order: S.optional(SubscriptionsListRequestOrder.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/event_subscriptions/subscriptions",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListSubscriptionsRequest",
}) as any as S.Schema<ListSubscriptionsRequest>;

export type SubscriptionsListResultItemDestinationType = "queues.queue";
export const SubscriptionsListResultItemDestinationType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsListResultItemDestination {
  /** ID of the target queue */
  queueId: string;
  /** Type of destination */
  type: SubscriptionsListResultItemDestinationType;
}
export const SubscriptionsListResultItemDestination = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      queueId: S.String.pipe(T.Body("queue_id")),
      type: SubscriptionsListResultItemDestinationType,
    }),
).annotate({
  identifier: "SubscriptionsListResultItemDestination",
}) as any as S.Schema<SubscriptionsListResultItemDestination>;

export type SubscriptionsListResultItemEventsList = Array<string>;
export const SubscriptionsListResultItemEventsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<SubscriptionsListResultItemEventsList>;

export type SubscriptionsListResultItemSourceMqEventSourceImagesType = "images";
export const SubscriptionsListResultItemSourceMqEventSourceImagesType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsListResultItemSourceMqEventSourceImages {
  /** Type of source */
  type?: SubscriptionsListResultItemSourceMqEventSourceImagesType | null;
}
export const SubscriptionsListResultItemSourceMqEventSourceImages =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsListResultItemSourceMqEventSourceImagesType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsListResultItemSourceMqEventSourceImages",
  }) as any as S.Schema<SubscriptionsListResultItemSourceMqEventSourceImages>;

export type SubscriptionsListResultItemSourceMqEventSourceKVType = "kv";
export const SubscriptionsListResultItemSourceMqEventSourceKVType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsListResultItemSourceMqEventSourceKV {
  /** Type of source */
  type?: SubscriptionsListResultItemSourceMqEventSourceKVType | null;
}
export const SubscriptionsListResultItemSourceMqEventSourceKV =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsListResultItemSourceMqEventSourceKVType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsListResultItemSourceMqEventSourceKV",
  }) as any as S.Schema<SubscriptionsListResultItemSourceMqEventSourceKV>;

export type SubscriptionsListResultItemSourceMqEventSourceR2Type = "r2";
export const SubscriptionsListResultItemSourceMqEventSourceR2Type =
  /*@__PURE__*/ S.String;

export interface SubscriptionsListResultItemSourceMqEventSourceR2 {
  /** Type of source */
  type?: SubscriptionsListResultItemSourceMqEventSourceR2Type | null;
}
export const SubscriptionsListResultItemSourceMqEventSourceR2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsListResultItemSourceMqEventSourceR2Type),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsListResultItemSourceMqEventSourceR2",
  }) as any as S.Schema<SubscriptionsListResultItemSourceMqEventSourceR2>;

export type SubscriptionsListResultItemSourceMqEventSourceSuperSlurperType =
  "superSlurper";
export const SubscriptionsListResultItemSourceMqEventSourceSuperSlurperType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsListResultItemSourceMqEventSourceSuperSlurper {
  /** Type of source */
  type?: SubscriptionsListResultItemSourceMqEventSourceSuperSlurperType | null;
}
export const SubscriptionsListResultItemSourceMqEventSourceSuperSlurper =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsListResultItemSourceMqEventSourceSuperSlurperType,
        ),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsListResultItemSourceMqEventSourceSuperSlurper",
  }) as any as S.Schema<SubscriptionsListResultItemSourceMqEventSourceSuperSlurper>;

export type SubscriptionsListResultItemSourceMqEventSourceVectorizeType =
  "vectorize";
export const SubscriptionsListResultItemSourceMqEventSourceVectorizeType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsListResultItemSourceMqEventSourceVectorize {
  /** Type of source */
  type?: SubscriptionsListResultItemSourceMqEventSourceVectorizeType | null;
}
export const SubscriptionsListResultItemSourceMqEventSourceVectorize =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsListResultItemSourceMqEventSourceVectorizeType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsListResultItemSourceMqEventSourceVectorize",
  }) as any as S.Schema<SubscriptionsListResultItemSourceMqEventSourceVectorize>;

export type SubscriptionsListResultItemSourceMqEventSourceWorkersAIModelType =
  "workersAi.model";
export const SubscriptionsListResultItemSourceMqEventSourceWorkersAIModelType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsListResultItemSourceMqEventSourceWorkersAIModel {
  /** Name of the Workers AI model */
  modelName?: string | null;
  /** Type of source */
  type?: SubscriptionsListResultItemSourceMqEventSourceWorkersAIModelType | null;
}
export const SubscriptionsListResultItemSourceMqEventSourceWorkersAIModel =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      modelName: S.optional(S.NullOr(S.String).pipe(T.Body("model_name"))),
      type: S.optional(
        S.NullOr(
          SubscriptionsListResultItemSourceMqEventSourceWorkersAIModelType,
        ),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsListResultItemSourceMqEventSourceWorkersAIModel",
  }) as any as S.Schema<SubscriptionsListResultItemSourceMqEventSourceWorkersAIModel>;

export type SubscriptionsListResultItemSourceMqEventSourceWorkersBuildsWorkerType =
  "workersBuilds.worker";
export const SubscriptionsListResultItemSourceMqEventSourceWorkersBuildsWorkerType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsListResultItemSourceMqEventSourceWorkersBuildsWorker {
  /** Type of source */
  type?: SubscriptionsListResultItemSourceMqEventSourceWorkersBuildsWorkerType | null;
  /** Name of the worker */
  workerName?: string | null;
}
export const SubscriptionsListResultItemSourceMqEventSourceWorkersBuildsWorker =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsListResultItemSourceMqEventSourceWorkersBuildsWorkerType,
        ),
      ),
      workerName: S.optional(S.NullOr(S.String).pipe(T.Body("worker_name"))),
    }),
  ).annotate({
    identifier:
      "SubscriptionsListResultItemSourceMqEventSourceWorkersBuildsWorker",
  }) as any as S.Schema<SubscriptionsListResultItemSourceMqEventSourceWorkersBuildsWorker>;

export type SubscriptionsListResultItemSourceMqEventSourceWorkflowsWorkflowType =
  "workflows.workflow";
export const SubscriptionsListResultItemSourceMqEventSourceWorkflowsWorkflowType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsListResultItemSourceMqEventSourceWorkflowsWorkflow {
  /** Type of source */
  type?: SubscriptionsListResultItemSourceMqEventSourceWorkflowsWorkflowType | null;
  /** Name of the workflow */
  workflowName?: string | null;
}
export const SubscriptionsListResultItemSourceMqEventSourceWorkflowsWorkflow =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsListResultItemSourceMqEventSourceWorkflowsWorkflowType,
        ),
      ),
      workflowName: S.optional(
        S.NullOr(S.String).pipe(T.Body("workflow_name")),
      ),
    }),
  ).annotate({
    identifier:
      "SubscriptionsListResultItemSourceMqEventSourceWorkflowsWorkflow",
  }) as any as S.Schema<SubscriptionsListResultItemSourceMqEventSourceWorkflowsWorkflow>;

export type SubscriptionsListResultItemSource =
  | SubscriptionsListResultItemSourceMqEventSourceImages
  | SubscriptionsListResultItemSourceMqEventSourceKV
  | SubscriptionsListResultItemSourceMqEventSourceR2
  | SubscriptionsListResultItemSourceMqEventSourceSuperSlurper
  | SubscriptionsListResultItemSourceMqEventSourceVectorize
  | SubscriptionsListResultItemSourceMqEventSourceWorkersAIModel
  | SubscriptionsListResultItemSourceMqEventSourceWorkersBuildsWorker
  | SubscriptionsListResultItemSourceMqEventSourceWorkflowsWorkflow;
export const SubscriptionsListResultItemSource = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["modelName", "type"],
    ["type", "workerName"],
    ["type", "workflowName"],
  ]),
);

export interface SubscriptionsListResultItem {
  /** Unique identifier for the subscription */
  id: string;
  /** When the subscription was created */
  createdAt: string;
  /** Destination configuration for the subscription */
  destination: SubscriptionsListResultItemDestination;
  /** Whether the subscription is active */
  enabled: boolean;
  /** List of event types this subscription handles */
  events: SubscriptionsListResultItemEventsList;
  /** When the subscription was last modified */
  modifiedAt: string;
  /** Name of the subscription */
  name: string;
  /** Source configuration for the subscription */
  source: SubscriptionsListResultItemSource;
}
export const SubscriptionsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    destination: SubscriptionsListResultItemDestination,
    enabled: S.Boolean,
    events: SubscriptionsListResultItemEventsList,
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    source: SubscriptionsListResultItemSource,
  }),
).annotate({
  identifier: "SubscriptionsListResultItem",
}) as any as S.Schema<SubscriptionsListResultItem>;

export type SubscriptionsListResultList = Array<SubscriptionsListResultItem>;
export const SubscriptionsListResultList = /*@__PURE__*/ S.Array(
  SubscriptionsListResultItem,
) as any as S.Schema<SubscriptionsListResultList>;

export interface ListSubscriptionsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: SubscriptionsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListSubscriptionsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: SubscriptionsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListSubscriptionsResponse",
}) as any as S.Schema<ListSubscriptionsResponse>;

export interface EditRequestSettings {
  /** Number of seconds to delay delivery of all messages to consumers. */
  deliveryDelay?: number;
  /** Indicates if message delivery to consumers is currently paused. */
  deliveryPaused?: boolean;
  /** Number of seconds after which an unconsumed message will be delayed. */
  messageRetentionPeriod?: number;
}
export const EditRequestSettings = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    deliveryDelay: S.optional(S.Number.pipe(T.Body("delivery_delay"))),
    deliveryPaused: S.optional(S.Boolean.pipe(T.Body("delivery_paused"))),
    messageRetentionPeriod: S.optional(
      S.Number.pipe(T.Body("message_retention_period")),
    ),
  }),
).annotate({
  identifier: "EditRequestSettings",
}) as any as S.Schema<EditRequestSettings>;

export interface PatchQueueRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
  queueName?: string;
  settings?: EditRequestSettings;
}
export const PatchQueueRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
    queueName: S.optional(S.String.pipe(T.Body("queue_name"))),
    settings: S.optional(EditRequestSettings),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/queues/{queue_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchQueueRequest",
}) as any as S.Schema<PatchQueueRequest>;

export type EditResponseConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;
export const EditResponseConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;

export type EditResponseConsumersItemWorkerType = "worker";
export const EditResponseConsumersItemWorkerType = /*@__PURE__*/ S.String;

export interface EditResponseConsumersItemWorker {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  /** Name of a Worker */
  scriptName?: string | null;
  settings?: ConsumersCreateResultWorkerSettings | null;
  type?: EditResponseConsumersItemWorkerType | null;
}
export const EditResponseConsumersItemWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultWorkerSettings)),
    type: S.optional(S.NullOr(EditResponseConsumersItemWorkerType)),
  }),
).annotate({
  identifier: "EditResponseConsumersItemWorker",
}) as any as S.Schema<EditResponseConsumersItemWorker>;

export type EditResponseConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;
export const EditResponseConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;

export type EditResponseConsumersItemHTTPPullType = "http_pull";
export const EditResponseConsumersItemHTTPPullType = /*@__PURE__*/ S.String;

export interface EditResponseConsumersItemHTTPPull {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  settings?: ConsumersCreateResultHTTPPullSettings | null;
  type?: EditResponseConsumersItemHTTPPullType | null;
}
export const EditResponseConsumersItemHTTPPull = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultHTTPPullSettings)),
    type: S.optional(S.NullOr(EditResponseConsumersItemHTTPPullType)),
  }),
).annotate({
  identifier: "EditResponseConsumersItemHTTPPull",
}) as any as S.Schema<EditResponseConsumersItemHTTPPull>;

export type EditResponseConsumersItem =
  | EditResponseConsumersItemWorker
  | EditResponseConsumersItemHTTPPull;
export const EditResponseConsumersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "scriptName",
      "settings",
      "type",
    ],
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "settings",
      "type",
    ],
  ]),
);

export type EditResponseConsumersList = Array<EditResponseConsumersItem>;
export const EditResponseConsumersList = /*@__PURE__*/ S.Array(
  EditResponseConsumersItem,
) as any as S.Schema<EditResponseConsumersList>;

export type EditResponseProducersItemMqWorkerProducerType = "worker";
export const EditResponseProducersItemMqWorkerProducerType =
  /*@__PURE__*/ S.String;

export interface EditResponseProducersItemMqWorkerProducer {
  type?: EditResponseProducersItemMqWorkerProducerType | null;
  scriptName?: string | null;
}
export const EditResponseProducersItemMqWorkerProducer =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(S.NullOr(EditResponseProducersItemMqWorkerProducerType)),
      scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    }),
  ).annotate({
    identifier: "EditResponseProducersItemMqWorkerProducer",
  }) as any as S.Schema<EditResponseProducersItemMqWorkerProducer>;

export type EditResponseProducersItemMqR2ProducerType = "r2_bucket";
export const EditResponseProducersItemMqR2ProducerType = /*@__PURE__*/ S.String;

export interface EditResponseProducersItemMqR2Producer {
  bucketName?: string | null;
  type?: EditResponseProducersItemMqR2ProducerType | null;
}
export const EditResponseProducersItemMqR2Producer = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      bucketName: S.optional(S.NullOr(S.String).pipe(T.Body("bucket_name"))),
      type: S.optional(S.NullOr(EditResponseProducersItemMqR2ProducerType)),
    }),
).annotate({
  identifier: "EditResponseProducersItemMqR2Producer",
}) as any as S.Schema<EditResponseProducersItemMqR2Producer>;

export type EditResponseProducersItem =
  | EditResponseProducersItemMqWorkerProducer
  | EditResponseProducersItemMqR2Producer;
export const EditResponseProducersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "scriptName"],
    ["bucketName", "type"],
  ]),
);

export type EditResponseProducersList = Array<EditResponseProducersItem>;
export const EditResponseProducersList = /*@__PURE__*/ S.Array(
  EditResponseProducersItem,
) as any as S.Schema<EditResponseProducersList>;

export type EditResponseSettings = CreateResponseSettings;
export const EditResponseSettings = CreateResponseSettings;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchQueueResponse {
  consumers?: EditResponseConsumersList | null;
  consumersTotalCount?: number | null;
  createdOn?: string | null;
  modifiedOn?: string | null;
  producers?: EditResponseProducersList | null;
  producersTotalCount?: number | null;
  queueId?: string | null;
  queueName?: string | null;
  settings?: CreateResponseSettings | null;
}
export const PatchQueueResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumers: S.optional(S.NullOr(EditResponseConsumersList)),
    consumersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("consumers_total_count")),
    ),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    producers: S.optional(S.NullOr(EditResponseProducersList)),
    producersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("producers_total_count")),
    ),
    queueId: S.optional(S.NullOr(S.String).pipe(T.Body("queue_id"))),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(CreateResponseSettings)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchQueueResponse",
}) as any as S.Schema<PatchQueueResponse>;

export type SubscriptionsUpdateRequestDestinationType = "queues.queue";
export const SubscriptionsUpdateRequestDestinationType = /*@__PURE__*/ S.String;

export interface SubscriptionsUpdateRequestDestination {
  /** ID of the target queue */
  queueId: string;
  /** Type of destination */
  type: SubscriptionsUpdateRequestDestinationType | (string & {});
}
export const SubscriptionsUpdateRequestDestination = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      queueId: S.String.pipe(T.Body("queue_id")),
      type: SubscriptionsUpdateRequestDestinationType,
    }),
).annotate({
  identifier: "SubscriptionsUpdateRequestDestination",
}) as any as S.Schema<SubscriptionsUpdateRequestDestination>;

export type SubscriptionsUpdateRequestEventsList = Array<string>;
export const SubscriptionsUpdateRequestEventsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<SubscriptionsUpdateRequestEventsList>;

export interface PatchSubscriptionRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  subscriptionId: string;
  /** Destination configuration for the subscription */
  destination?: SubscriptionsUpdateRequestDestination;
  /** Whether the subscription is active */
  enabled?: boolean;
  /** List of event types this subscription handles */
  events?: SubscriptionsUpdateRequestEventsList;
  /** Name of the subscription */
  name?: string;
}
export const PatchSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    subscriptionId: S.String.pipe(T.Label("subscription_id")),
    destination: S.optional(SubscriptionsUpdateRequestDestination),
    enabled: S.optional(S.Boolean),
    events: S.optional(SubscriptionsUpdateRequestEventsList),
    name: S.optional(S.String),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/accounts/{account_id}/event_subscriptions/subscriptions/{subscription_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchSubscriptionRequest",
}) as any as S.Schema<PatchSubscriptionRequest>;

export type SubscriptionsUpdateResponseDestinationType = "queues.queue";
export const SubscriptionsUpdateResponseDestinationType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsUpdateResponseDestination {
  /** ID of the target queue */
  queueId: string;
  /** Type of destination */
  type: SubscriptionsUpdateResponseDestinationType;
}
export const SubscriptionsUpdateResponseDestination = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      queueId: S.String.pipe(T.Body("queue_id")),
      type: SubscriptionsUpdateResponseDestinationType,
    }),
).annotate({
  identifier: "SubscriptionsUpdateResponseDestination",
}) as any as S.Schema<SubscriptionsUpdateResponseDestination>;

export type SubscriptionsUpdateResponseEventsList = Array<string>;
export const SubscriptionsUpdateResponseEventsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<SubscriptionsUpdateResponseEventsList>;

export type SubscriptionsUpdateResponseSourceMqEventSourceImagesType = "images";
export const SubscriptionsUpdateResponseSourceMqEventSourceImagesType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsUpdateResponseSourceMqEventSourceImages {
  /** Type of source */
  type?: SubscriptionsUpdateResponseSourceMqEventSourceImagesType | null;
}
export const SubscriptionsUpdateResponseSourceMqEventSourceImages =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsUpdateResponseSourceMqEventSourceImagesType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsUpdateResponseSourceMqEventSourceImages",
  }) as any as S.Schema<SubscriptionsUpdateResponseSourceMqEventSourceImages>;

export type SubscriptionsUpdateResponseSourceMqEventSourceKVType = "kv";
export const SubscriptionsUpdateResponseSourceMqEventSourceKVType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsUpdateResponseSourceMqEventSourceKV {
  /** Type of source */
  type?: SubscriptionsUpdateResponseSourceMqEventSourceKVType | null;
}
export const SubscriptionsUpdateResponseSourceMqEventSourceKV =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsUpdateResponseSourceMqEventSourceKVType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsUpdateResponseSourceMqEventSourceKV",
  }) as any as S.Schema<SubscriptionsUpdateResponseSourceMqEventSourceKV>;

export type SubscriptionsUpdateResponseSourceMqEventSourceR2Type = "r2";
export const SubscriptionsUpdateResponseSourceMqEventSourceR2Type =
  /*@__PURE__*/ S.String;

export interface SubscriptionsUpdateResponseSourceMqEventSourceR2 {
  /** Type of source */
  type?: SubscriptionsUpdateResponseSourceMqEventSourceR2Type | null;
}
export const SubscriptionsUpdateResponseSourceMqEventSourceR2 =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsUpdateResponseSourceMqEventSourceR2Type),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsUpdateResponseSourceMqEventSourceR2",
  }) as any as S.Schema<SubscriptionsUpdateResponseSourceMqEventSourceR2>;

export type SubscriptionsUpdateResponseSourceMqEventSourceSuperSlurperType =
  "superSlurper";
export const SubscriptionsUpdateResponseSourceMqEventSourceSuperSlurperType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsUpdateResponseSourceMqEventSourceSuperSlurper {
  /** Type of source */
  type?: SubscriptionsUpdateResponseSourceMqEventSourceSuperSlurperType | null;
}
export const SubscriptionsUpdateResponseSourceMqEventSourceSuperSlurper =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsUpdateResponseSourceMqEventSourceSuperSlurperType,
        ),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsUpdateResponseSourceMqEventSourceSuperSlurper",
  }) as any as S.Schema<SubscriptionsUpdateResponseSourceMqEventSourceSuperSlurper>;

export type SubscriptionsUpdateResponseSourceMqEventSourceVectorizeType =
  "vectorize";
export const SubscriptionsUpdateResponseSourceMqEventSourceVectorizeType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsUpdateResponseSourceMqEventSourceVectorize {
  /** Type of source */
  type?: SubscriptionsUpdateResponseSourceMqEventSourceVectorizeType | null;
}
export const SubscriptionsUpdateResponseSourceMqEventSourceVectorize =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(SubscriptionsUpdateResponseSourceMqEventSourceVectorizeType),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsUpdateResponseSourceMqEventSourceVectorize",
  }) as any as S.Schema<SubscriptionsUpdateResponseSourceMqEventSourceVectorize>;

export type SubscriptionsUpdateResponseSourceMqEventSourceWorkersAIModelType =
  "workersAi.model";
export const SubscriptionsUpdateResponseSourceMqEventSourceWorkersAIModelType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsUpdateResponseSourceMqEventSourceWorkersAIModel {
  /** Name of the Workers AI model */
  modelName?: string | null;
  /** Type of source */
  type?: SubscriptionsUpdateResponseSourceMqEventSourceWorkersAIModelType | null;
}
export const SubscriptionsUpdateResponseSourceMqEventSourceWorkersAIModel =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      modelName: S.optional(S.NullOr(S.String).pipe(T.Body("model_name"))),
      type: S.optional(
        S.NullOr(
          SubscriptionsUpdateResponseSourceMqEventSourceWorkersAIModelType,
        ),
      ),
    }),
  ).annotate({
    identifier: "SubscriptionsUpdateResponseSourceMqEventSourceWorkersAIModel",
  }) as any as S.Schema<SubscriptionsUpdateResponseSourceMqEventSourceWorkersAIModel>;

export type SubscriptionsUpdateResponseSourceMqEventSourceWorkersBuildsWorkerType =
  "workersBuilds.worker";
export const SubscriptionsUpdateResponseSourceMqEventSourceWorkersBuildsWorkerType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsUpdateResponseSourceMqEventSourceWorkersBuildsWorker {
  /** Type of source */
  type?: SubscriptionsUpdateResponseSourceMqEventSourceWorkersBuildsWorkerType | null;
  /** Name of the worker */
  workerName?: string | null;
}
export const SubscriptionsUpdateResponseSourceMqEventSourceWorkersBuildsWorker =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsUpdateResponseSourceMqEventSourceWorkersBuildsWorkerType,
        ),
      ),
      workerName: S.optional(S.NullOr(S.String).pipe(T.Body("worker_name"))),
    }),
  ).annotate({
    identifier:
      "SubscriptionsUpdateResponseSourceMqEventSourceWorkersBuildsWorker",
  }) as any as S.Schema<SubscriptionsUpdateResponseSourceMqEventSourceWorkersBuildsWorker>;

export type SubscriptionsUpdateResponseSourceMqEventSourceWorkflowsWorkflowType =
  "workflows.workflow";
export const SubscriptionsUpdateResponseSourceMqEventSourceWorkflowsWorkflowType =
  /*@__PURE__*/ S.String;

export interface SubscriptionsUpdateResponseSourceMqEventSourceWorkflowsWorkflow {
  /** Type of source */
  type?: SubscriptionsUpdateResponseSourceMqEventSourceWorkflowsWorkflowType | null;
  /** Name of the workflow */
  workflowName?: string | null;
}
export const SubscriptionsUpdateResponseSourceMqEventSourceWorkflowsWorkflow =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(
          SubscriptionsUpdateResponseSourceMqEventSourceWorkflowsWorkflowType,
        ),
      ),
      workflowName: S.optional(
        S.NullOr(S.String).pipe(T.Body("workflow_name")),
      ),
    }),
  ).annotate({
    identifier:
      "SubscriptionsUpdateResponseSourceMqEventSourceWorkflowsWorkflow",
  }) as any as S.Schema<SubscriptionsUpdateResponseSourceMqEventSourceWorkflowsWorkflow>;

export type SubscriptionsUpdateResponseSource =
  | SubscriptionsUpdateResponseSourceMqEventSourceImages
  | SubscriptionsUpdateResponseSourceMqEventSourceKV
  | SubscriptionsUpdateResponseSourceMqEventSourceR2
  | SubscriptionsUpdateResponseSourceMqEventSourceSuperSlurper
  | SubscriptionsUpdateResponseSourceMqEventSourceVectorize
  | SubscriptionsUpdateResponseSourceMqEventSourceWorkersAIModel
  | SubscriptionsUpdateResponseSourceMqEventSourceWorkersBuildsWorker
  | SubscriptionsUpdateResponseSourceMqEventSourceWorkflowsWorkflow;
export const SubscriptionsUpdateResponseSource = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["type"],
    ["modelName", "type"],
    ["type", "workerName"],
    ["type", "workflowName"],
  ]),
);

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchSubscriptionResponse {
  /** Unique identifier for the subscription */
  id: string;
  /** When the subscription was created */
  createdAt: string;
  /** Destination configuration for the subscription */
  destination: SubscriptionsUpdateResponseDestination;
  /** Whether the subscription is active */
  enabled: boolean;
  /** List of event types this subscription handles */
  events: SubscriptionsUpdateResponseEventsList;
  /** When the subscription was last modified */
  modifiedAt: string;
  /** Name of the subscription */
  name: string;
  /** Source configuration for the subscription */
  source: SubscriptionsUpdateResponseSource;
}
export const PatchSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createdAt: S.String.pipe(T.Body("created_at")),
    destination: SubscriptionsUpdateResponseDestination,
    enabled: S.Boolean,
    events: SubscriptionsUpdateResponseEventsList,
    modifiedAt: S.String.pipe(T.Body("modified_at")),
    name: S.String,
    source: SubscriptionsUpdateResponseSource,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchSubscriptionResponse",
}) as any as S.Schema<PatchSubscriptionResponse>;

export interface PullMessageRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
  /** The maximum number of messages to include in a batch. */
  batchSize?: number;
  /** The number of milliseconds that a message is exclusively leased. After the timeout, the message becomes available for another attempt. */
  visibilityTimeoutMs?: number;
}
export const PullMessageRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
    batchSize: S.optional(S.Number.pipe(T.Body("batch_size"))),
    visibilityTimeoutMs: S.optional(
      S.Number.pipe(T.Body("visibility_timeout_ms")),
    ),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/queues/{queue_id}/messages/pull",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PullMessageRequest",
}) as any as S.Schema<PullMessageRequest>;

export interface MessagesPullResponseMessagesItem {
  id?: string | null;
  attempts?: number | null;
  body?: string | null;
  /** An ID that represents an "in-flight" message that has been pulled from a Queue. You must hold on to this ID and use it to acknowledge this message. */
  leaseId?: string | null;
  metadata?: unknown | null;
  timestampMs?: number | null;
}
export const MessagesPullResponseMessagesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    attempts: S.optional(S.NullOr(S.Number)),
    body: S.optional(S.NullOr(S.String)),
    leaseId: S.optional(S.NullOr(S.String).pipe(T.Body("lease_id"))),
    metadata: S.optional(S.NullOr(S.Unknown)),
    timestampMs: S.optional(S.NullOr(S.Number).pipe(T.Body("timestamp_ms"))),
  }),
).annotate({
  identifier: "MessagesPullResponseMessagesItem",
}) as any as S.Schema<MessagesPullResponseMessagesItem>;

export type MessagesPullResponseMessagesList =
  Array<MessagesPullResponseMessagesItem>;
export const MessagesPullResponseMessagesList = /*@__PURE__*/ S.Array(
  MessagesPullResponseMessagesItem,
) as any as S.Schema<MessagesPullResponseMessagesList>;

export type MessagesPullResponseMetadataMetrics =
  MessagesBulkPushResponseMetadataMetrics;
export const MessagesPullResponseMetadataMetrics =
  MessagesBulkPushResponseMetadataMetrics;

export type MessagesPullResponseMetadata = MessagesBulkPushResponseMetadata;
export const MessagesPullResponseMetadata = MessagesBulkPushResponseMetadata;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PullMessageResponse {
  /** The number of unacknowledged messages in the queue. */
  messageBacklogCount?: number | null;
  messages?: MessagesPullResponseMessagesList | null;
  metadata?: MessagesBulkPushResponseMetadata | null;
}
export const PullMessageResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    messageBacklogCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("message_backlog_count")),
    ),
    messages: S.optional(S.NullOr(MessagesPullResponseMessagesList)),
    metadata: S.optional(S.NullOr(MessagesBulkPushResponseMetadata)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PullMessageResponse",
}) as any as S.Schema<PullMessageResponse>;

export interface PurgeStatusRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
}
export const PurgeStatusRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/queues/{queue_id}/purge",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PurgeStatusRequest",
}) as any as S.Schema<PurgeStatusRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PurgeStatusResponse {
  /** Indicates if the last purge operation completed successfully. */
  completed?: string | null;
  /** Timestamp when the last purge operation started. */
  startedAt?: string | null;
}
export const PurgeStatusResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    completed: S.optional(S.NullOr(S.String)),
    startedAt: S.optional(S.NullOr(S.String).pipe(T.Body("started_at"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PurgeStatusResponse",
}) as any as S.Schema<PurgeStatusResponse>;

export type MessagesPushRequestContentType = "text" | "json";
export const MessagesPushRequestContentType = /*@__PURE__*/ S.String;

export interface PushMessageRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
  body?: unknown;
  contentType?: MessagesPushRequestContentType | (string & {});
  /** The number of seconds to wait for attempting to deliver this message to consumers */
  delaySeconds?: number;
}
export const PushMessageRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
    body: S.optional(S.Unknown),
    contentType: S.optional(
      MessagesPushRequestContentType.pipe(T.Body("content_type")),
    ),
    delaySeconds: S.optional(S.Number.pipe(T.Body("delay_seconds"))),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/queues/{queue_id}/messages",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PushMessageRequest",
}) as any as S.Schema<PushMessageRequest>;

export type MessagesPushResponseMetadataMetrics =
  MessagesBulkPushResponseMetadataMetrics;
export const MessagesPushResponseMetadataMetrics =
  MessagesBulkPushResponseMetadataMetrics;

export type MessagesPushResponseMetadata = MessagesBulkPushResponseMetadata;
export const MessagesPushResponseMetadata = MessagesBulkPushResponseMetadata;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PushMessageResponse {
  metadata?: MessagesBulkPushResponseMetadata | null;
}
export const PushMessageResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    metadata: S.optional(S.NullOr(MessagesBulkPushResponseMetadata)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PushMessageResponse",
}) as any as S.Schema<PushMessageResponse>;

export interface StartPurgeRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
  /** Confimation that all messages will be deleted permanently. */
  deleteMessagesPermanently?: boolean;
}
export const StartPurgeRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
    deleteMessagesPermanently: S.optional(
      S.Boolean.pipe(T.Body("delete_messages_permanently")),
    ),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/queues/{queue_id}/purge",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StartPurgeRequest",
}) as any as S.Schema<StartPurgeRequest>;

export type PurgeStartResponseConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;
export const PurgeStartResponseConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;

export type PurgeStartResponseConsumersItemWorkerType = "worker";
export const PurgeStartResponseConsumersItemWorkerType = /*@__PURE__*/ S.String;

export interface PurgeStartResponseConsumersItemWorker {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  /** Name of a Worker */
  scriptName?: string | null;
  settings?: ConsumersCreateResultWorkerSettings | null;
  type?: PurgeStartResponseConsumersItemWorkerType | null;
}
export const PurgeStartResponseConsumersItemWorker = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
      createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
      deadLetterQueue: S.optional(
        S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
      ),
      queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
      scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
      settings: S.optional(S.NullOr(ConsumersCreateResultWorkerSettings)),
      type: S.optional(S.NullOr(PurgeStartResponseConsumersItemWorkerType)),
    }),
).annotate({
  identifier: "PurgeStartResponseConsumersItemWorker",
}) as any as S.Schema<PurgeStartResponseConsumersItemWorker>;

export type PurgeStartResponseConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;
export const PurgeStartResponseConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;

export type PurgeStartResponseConsumersItemHTTPPullType = "http_pull";
export const PurgeStartResponseConsumersItemHTTPPullType =
  /*@__PURE__*/ S.String;

export interface PurgeStartResponseConsumersItemHTTPPull {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  settings?: ConsumersCreateResultHTTPPullSettings | null;
  type?: PurgeStartResponseConsumersItemHTTPPullType | null;
}
export const PurgeStartResponseConsumersItemHTTPPull = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
      createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
      deadLetterQueue: S.optional(
        S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
      ),
      queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
      settings: S.optional(S.NullOr(ConsumersCreateResultHTTPPullSettings)),
      type: S.optional(S.NullOr(PurgeStartResponseConsumersItemHTTPPullType)),
    }),
).annotate({
  identifier: "PurgeStartResponseConsumersItemHTTPPull",
}) as any as S.Schema<PurgeStartResponseConsumersItemHTTPPull>;

export type PurgeStartResponseConsumersItem =
  | PurgeStartResponseConsumersItemWorker
  | PurgeStartResponseConsumersItemHTTPPull;
export const PurgeStartResponseConsumersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "scriptName",
      "settings",
      "type",
    ],
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "settings",
      "type",
    ],
  ]),
);

export type PurgeStartResponseConsumersList =
  Array<PurgeStartResponseConsumersItem>;
export const PurgeStartResponseConsumersList = /*@__PURE__*/ S.Array(
  PurgeStartResponseConsumersItem,
) as any as S.Schema<PurgeStartResponseConsumersList>;

export type PurgeStartResponseProducersItemMqWorkerProducerType = "worker";
export const PurgeStartResponseProducersItemMqWorkerProducerType =
  /*@__PURE__*/ S.String;

export interface PurgeStartResponseProducersItemMqWorkerProducer {
  type?: PurgeStartResponseProducersItemMqWorkerProducerType | null;
  scriptName?: string | null;
}
export const PurgeStartResponseProducersItemMqWorkerProducer =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(PurgeStartResponseProducersItemMqWorkerProducerType),
      ),
      scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    }),
  ).annotate({
    identifier: "PurgeStartResponseProducersItemMqWorkerProducer",
  }) as any as S.Schema<PurgeStartResponseProducersItemMqWorkerProducer>;

export type PurgeStartResponseProducersItemMqR2ProducerType = "r2_bucket";
export const PurgeStartResponseProducersItemMqR2ProducerType =
  /*@__PURE__*/ S.String;

export interface PurgeStartResponseProducersItemMqR2Producer {
  bucketName?: string | null;
  type?: PurgeStartResponseProducersItemMqR2ProducerType | null;
}
export const PurgeStartResponseProducersItemMqR2Producer =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      bucketName: S.optional(S.NullOr(S.String).pipe(T.Body("bucket_name"))),
      type: S.optional(
        S.NullOr(PurgeStartResponseProducersItemMqR2ProducerType),
      ),
    }),
  ).annotate({
    identifier: "PurgeStartResponseProducersItemMqR2Producer",
  }) as any as S.Schema<PurgeStartResponseProducersItemMqR2Producer>;

export type PurgeStartResponseProducersItem =
  | PurgeStartResponseProducersItemMqWorkerProducer
  | PurgeStartResponseProducersItemMqR2Producer;
export const PurgeStartResponseProducersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "scriptName"],
    ["bucketName", "type"],
  ]),
);

export type PurgeStartResponseProducersList =
  Array<PurgeStartResponseProducersItem>;
export const PurgeStartResponseProducersList = /*@__PURE__*/ S.Array(
  PurgeStartResponseProducersItem,
) as any as S.Schema<PurgeStartResponseProducersList>;

export type PurgeStartResponseSettings = CreateResponseSettings;
export const PurgeStartResponseSettings = CreateResponseSettings;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface StartPurgeResponse {
  consumers?: PurgeStartResponseConsumersList | null;
  consumersTotalCount?: number | null;
  createdOn?: string | null;
  modifiedOn?: string | null;
  producers?: PurgeStartResponseProducersList | null;
  producersTotalCount?: number | null;
  queueId?: string | null;
  queueName?: string | null;
  settings?: CreateResponseSettings | null;
}
export const StartPurgeResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumers: S.optional(S.NullOr(PurgeStartResponseConsumersList)),
    consumersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("consumers_total_count")),
    ),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    producers: S.optional(S.NullOr(PurgeStartResponseProducersList)),
    producersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("producers_total_count")),
    ),
    queueId: S.optional(S.NullOr(S.String).pipe(T.Body("queue_id"))),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(CreateResponseSettings)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "StartPurgeResponse",
}) as any as S.Schema<StartPurgeResponse>;

export type ConsumersUpdateRequestType = "worker" | "http_pull";
export const ConsumersUpdateRequestType = /*@__PURE__*/ S.String;

export type ConsumersUpdateRequestSettingsWorker =
  ConsumersCreateRequestSettingsWorker;
export const ConsumersUpdateRequestSettingsWorker =
  ConsumersCreateRequestSettingsWorker;

export type ConsumersUpdateRequestSettingsHTTPPull =
  ConsumersCreateRequestSettingsHTTPPull;
export const ConsumersUpdateRequestSettingsHTTPPull =
  ConsumersCreateRequestSettingsHTTPPull;

export type ConsumersUpdateRequestSettings =
  | ConsumersCreateRequestSettingsWorker
  | ConsumersCreateRequestSettingsHTTPPull;
export const ConsumersUpdateRequestSettings = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "batchSize",
      "maxConcurrency",
      "maxRetries",
      "maxWaitTimeMs",
      "retryDelay",
    ],
    ["batchSize", "maxRetries", "retryDelay", "visibilityTimeoutMs"],
  ]),
);

export interface UpdateConsumerRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
  /** A Resource identifier. */
  consumerId: string;
  /** Name of a Worker */
  scriptName?: string;
  type: ConsumersUpdateRequestType | (string & {});
  deadLetterQueue?: string;
  settings?: ConsumersUpdateRequestSettings;
}
export const UpdateConsumerRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
    consumerId: S.String.pipe(T.Label("consumer_id")),
    scriptName: S.optional(S.String.pipe(T.Body("script_name"))),
    type: ConsumersUpdateRequestType,
    deadLetterQueue: S.optional(S.String.pipe(T.Body("dead_letter_queue"))),
    settings: S.optional(ConsumersUpdateRequestSettings),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/queues/{queue_id}/consumers/{consumer_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateConsumerRequest",
}) as any as S.Schema<UpdateConsumerRequest>;

export type ConsumersUpdateResultWorkerSettings =
  ConsumersCreateResultWorkerSettings;
export const ConsumersUpdateResultWorkerSettings =
  ConsumersCreateResultWorkerSettings;

export type ConsumersUpdateResultWorkerType = "worker";
export const ConsumersUpdateResultWorkerType = /*@__PURE__*/ S.String;

export interface ConsumersUpdateResultWorker {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  /** Name of a Worker */
  scriptName?: string | null;
  settings?: ConsumersCreateResultWorkerSettings | null;
  type?: ConsumersUpdateResultWorkerType | null;
}
export const ConsumersUpdateResultWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultWorkerSettings)),
    type: S.optional(S.NullOr(ConsumersUpdateResultWorkerType)),
  }),
).annotate({
  identifier: "ConsumersUpdateResultWorker",
}) as any as S.Schema<ConsumersUpdateResultWorker>;

export type ConsumersUpdateResultHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;
export const ConsumersUpdateResultHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;

export type ConsumersUpdateResultHTTPPullType = "http_pull";
export const ConsumersUpdateResultHTTPPullType = /*@__PURE__*/ S.String;

export interface ConsumersUpdateResultHTTPPull {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  settings?: ConsumersCreateResultHTTPPullSettings | null;
  type?: ConsumersUpdateResultHTTPPullType | null;
}
export const ConsumersUpdateResultHTTPPull = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultHTTPPullSettings)),
    type: S.optional(S.NullOr(ConsumersUpdateResultHTTPPullType)),
  }),
).annotate({
  identifier: "ConsumersUpdateResultHTTPPull",
}) as any as S.Schema<ConsumersUpdateResultHTTPPull>;

export type ConsumersUpdateResult =
  | ConsumersUpdateResultWorker
  | ConsumersUpdateResultHTTPPull;
export const ConsumersUpdateResult = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "scriptName",
      "settings",
      "type",
    ],
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "settings",
      "type",
    ],
  ]),
);

export type UpdateConsumerResponse = ConsumersUpdateResult;
export const UpdateConsumerResponse = /*@__PURE__*/ S.suspend(() =>
  ConsumersUpdateResult.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "UpdateConsumerResponse",
}) as any as S.Schema<UpdateConsumerResponse>;

export type UpdateRequestSettings = EditRequestSettings;
export const UpdateRequestSettings = EditRequestSettings;

export interface UpdateQueueRequest {
  /** A Resource identifier. */
  accountId: string;
  /** A Resource identifier. */
  queueId: string;
  queueName?: string;
  settings?: EditRequestSettings;
}
export const UpdateQueueRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    queueId: S.String.pipe(T.Label("queue_id")),
    queueName: S.optional(S.String.pipe(T.Body("queue_name"))),
    settings: S.optional(EditRequestSettings),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/queues/{queue_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateQueueRequest",
}) as any as S.Schema<UpdateQueueRequest>;

export type UpdateResponseConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;
export const UpdateResponseConsumersItemWorkerSettings =
  ConsumersCreateResultWorkerSettings;

export type UpdateResponseConsumersItemWorkerType = "worker";
export const UpdateResponseConsumersItemWorkerType = /*@__PURE__*/ S.String;

export interface UpdateResponseConsumersItemWorker {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  /** Name of a Worker */
  scriptName?: string | null;
  settings?: ConsumersCreateResultWorkerSettings | null;
  type?: UpdateResponseConsumersItemWorkerType | null;
}
export const UpdateResponseConsumersItemWorker = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultWorkerSettings)),
    type: S.optional(S.NullOr(UpdateResponseConsumersItemWorkerType)),
  }),
).annotate({
  identifier: "UpdateResponseConsumersItemWorker",
}) as any as S.Schema<UpdateResponseConsumersItemWorker>;

export type UpdateResponseConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;
export const UpdateResponseConsumersItemHTTPPullSettings =
  ConsumersCreateResultHTTPPullSettings;

export type UpdateResponseConsumersItemHTTPPullType = "http_pull";
export const UpdateResponseConsumersItemHTTPPullType = /*@__PURE__*/ S.String;

export interface UpdateResponseConsumersItemHTTPPull {
  /** A Resource identifier. */
  consumerId?: string | null;
  createdOn?: string | null;
  /** Name of the dead letter queue, or empty string if not configured */
  deadLetterQueue?: string | null;
  queueName?: string | null;
  settings?: ConsumersCreateResultHTTPPullSettings | null;
  type?: UpdateResponseConsumersItemHTTPPullType | null;
}
export const UpdateResponseConsumersItemHTTPPull = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumerId: S.optional(S.NullOr(S.String).pipe(T.Body("consumer_id"))),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deadLetterQueue: S.optional(
      S.NullOr(S.String).pipe(T.Body("dead_letter_queue")),
    ),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(ConsumersCreateResultHTTPPullSettings)),
    type: S.optional(S.NullOr(UpdateResponseConsumersItemHTTPPullType)),
  }),
).annotate({
  identifier: "UpdateResponseConsumersItemHTTPPull",
}) as any as S.Schema<UpdateResponseConsumersItemHTTPPull>;

export type UpdateResponseConsumersItem =
  | UpdateResponseConsumersItemWorker
  | UpdateResponseConsumersItemHTTPPull;
export const UpdateResponseConsumersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "scriptName",
      "settings",
      "type",
    ],
    [
      "consumerId",
      "createdOn",
      "deadLetterQueue",
      "queueName",
      "settings",
      "type",
    ],
  ]),
);

export type UpdateResponseConsumersList = Array<UpdateResponseConsumersItem>;
export const UpdateResponseConsumersList = /*@__PURE__*/ S.Array(
  UpdateResponseConsumersItem,
) as any as S.Schema<UpdateResponseConsumersList>;

export type UpdateResponseProducersItemMqWorkerProducerType = "worker";
export const UpdateResponseProducersItemMqWorkerProducerType =
  /*@__PURE__*/ S.String;

export interface UpdateResponseProducersItemMqWorkerProducer {
  type?: UpdateResponseProducersItemMqWorkerProducerType | null;
  scriptName?: string | null;
}
export const UpdateResponseProducersItemMqWorkerProducer =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      type: S.optional(
        S.NullOr(UpdateResponseProducersItemMqWorkerProducerType),
      ),
      scriptName: S.optional(S.NullOr(S.String).pipe(T.Body("script_name"))),
    }),
  ).annotate({
    identifier: "UpdateResponseProducersItemMqWorkerProducer",
  }) as any as S.Schema<UpdateResponseProducersItemMqWorkerProducer>;

export type UpdateResponseProducersItemMqR2ProducerType = "r2_bucket";
export const UpdateResponseProducersItemMqR2ProducerType =
  /*@__PURE__*/ S.String;

export interface UpdateResponseProducersItemMqR2Producer {
  bucketName?: string | null;
  type?: UpdateResponseProducersItemMqR2ProducerType | null;
}
export const UpdateResponseProducersItemMqR2Producer = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      bucketName: S.optional(S.NullOr(S.String).pipe(T.Body("bucket_name"))),
      type: S.optional(S.NullOr(UpdateResponseProducersItemMqR2ProducerType)),
    }),
).annotate({
  identifier: "UpdateResponseProducersItemMqR2Producer",
}) as any as S.Schema<UpdateResponseProducersItemMqR2Producer>;

export type UpdateResponseProducersItem =
  | UpdateResponseProducersItemMqWorkerProducer
  | UpdateResponseProducersItemMqR2Producer;
export const UpdateResponseProducersItem = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["type", "scriptName"],
    ["bucketName", "type"],
  ]),
);

export type UpdateResponseProducersList = Array<UpdateResponseProducersItem>;
export const UpdateResponseProducersList = /*@__PURE__*/ S.Array(
  UpdateResponseProducersItem,
) as any as S.Schema<UpdateResponseProducersList>;

export type UpdateResponseSettings = CreateResponseSettings;
export const UpdateResponseSettings = CreateResponseSettings;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateQueueResponse {
  consumers?: UpdateResponseConsumersList | null;
  consumersTotalCount?: number | null;
  createdOn?: string | null;
  modifiedOn?: string | null;
  producers?: UpdateResponseProducersList | null;
  producersTotalCount?: number | null;
  queueId?: string | null;
  queueName?: string | null;
  settings?: CreateResponseSettings | null;
}
export const UpdateQueueResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    consumers: S.optional(S.NullOr(UpdateResponseConsumersList)),
    consumersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("consumers_total_count")),
    ),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    producers: S.optional(S.NullOr(UpdateResponseProducersList)),
    producersTotalCount: S.optional(
      S.NullOr(S.Number).pipe(T.Body("producers_total_count")),
    ),
    queueId: S.optional(S.NullOr(S.String).pipe(T.Body("queue_id"))),
    queueName: S.optional(S.NullOr(S.String).pipe(T.Body("queue_name"))),
    settings: S.optional(S.NullOr(CreateResponseSettings)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateQueueResponse",
}) as any as S.Schema<UpdateQueueResponse>;

export type AckMessageError =
  | InvalidRequestBody
  | InvalidQueueId
  | QueueNotFound
  | InvalidRoute
  | CloudflareOpError;
/** Acknowledge + Retry messages from a Queue */
export const ackMessage: API.OperationMethod<
  AckMessageRequest,
  AckMessageResponse,
  AckMessageError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: AckMessageRequest,
  output: AckMessageResponse,
  errors: [
    InvalidRequestBody,
    InvalidQueueId,
    QueueNotFound,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type BulkPushMessagesError =
  | InvalidMessageBody
  | InvalidQueueId
  | InvalidRoute
  | CloudflareOpError;
/** Push a batch of message to a Queue */
export const bulkPushMessages: API.OperationMethod<
  BulkPushMessagesRequest,
  BulkPushMessagesResponse,
  BulkPushMessagesError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: BulkPushMessagesRequest,
  output: BulkPushMessagesResponse,
  errors: [
    InvalidMessageBody,
    InvalidQueueId,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateConsumerError =
  | InvalidRequestBody
  | QueueNotFound
  | QueueHandlerMissing
  | ConsumerAlreadyExists
  | WorkerNotFound
  | InvalidRoute
  | CloudflareOpError;
/** Creates a new consumer for a Queue */
export const createConsumer: API.OperationMethod<
  CreateConsumerRequest,
  CreateConsumerResponse,
  CreateConsumerError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateConsumerRequest,
  output: CreateConsumerResponse,
  errors: [
    InvalidRequestBody,
    QueueNotFound,
    QueueHandlerMissing,
    ConsumerAlreadyExists,
    WorkerNotFound,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateQueueError =
  | QueueAlreadyExists
  | InvalidQueueName
  | InvalidRoute
  | CloudflareOpError;
/** Create a new queue */
export const createQueue: API.OperationMethod<
  CreateQueueRequest,
  CreateQueueResponse,
  CreateQueueError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateQueueRequest,
  output: CreateQueueResponse,
  errors: [
    QueueAlreadyExists,
    InvalidQueueName,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateSubscriptionError =
  | UnrecognizedEventType
  | SubscriptionAlreadyExists
  | QueueNotFound
  | CloudflareOpError;
/** Create a new event subscription for a queue */
export const createSubscription: API.OperationMethod<
  CreateSubscriptionRequest,
  CreateSubscriptionResponse,
  CreateSubscriptionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateSubscriptionRequest,
  output: CreateSubscriptionResponse,
  errors: [
    UnrecognizedEventType,
    SubscriptionAlreadyExists,
    QueueNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteConsumerError =
  | InvalidRequestBody
  | QueueNotFound
  | ConsumerNotFound
  | InvalidRoute
  | CloudflareOpError;
/** Deletes the consumer for a queue. */
export const deleteConsumer: API.OperationMethod<
  DeleteConsumerRequest,
  DeleteConsumerResponse,
  DeleteConsumerError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteConsumerRequest,
  output: DeleteConsumerResponse,
  errors: [
    InvalidRequestBody,
    QueueNotFound,
    ConsumerNotFound,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteQueueError =
  | QueueNotFound
  | QueueInUseByEventNotification
  | InvalidRoute
  | QueueInUseByWorkerBinding
  | CloudflareOpError;
/** Deletes a queue */
export const deleteQueue: API.OperationMethod<
  DeleteQueueRequest,
  DeleteQueueResponse,
  DeleteQueueError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteQueueRequest,
  output: DeleteQueueResponse,
  errors: [
    QueueNotFound,
    QueueInUseByEventNotification,
    InvalidRoute,
    QueueInUseByWorkerBinding,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteSubscriptionError =
  | UnrecognizedEventType
  | SubscriptionNotFound
  | CloudflareOpError;
/** Delete an existing event subscription */
export const deleteSubscription: API.OperationMethod<
  DeleteSubscriptionRequest,
  DeleteSubscriptionResponse,
  DeleteSubscriptionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteSubscriptionRequest,
  output: DeleteSubscriptionResponse,
  errors: [
    UnrecognizedEventType,
    SubscriptionNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetConsumerError =
  | InvalidRequestBody
  | QueueNotFound
  | ConsumerNotFound
  | InvalidRoute
  | CloudflareOpError;
/** Fetches the consumer for a queue by consumer id */
export const getConsumer: API.OperationMethod<
  GetConsumerRequest,
  GetConsumerResponse,
  GetConsumerError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetConsumerRequest,
  output: GetConsumerResponse,
  errors: [
    InvalidRequestBody,
    QueueNotFound,
    ConsumerNotFound,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetMetricsQueueError = CloudflareOpError;
/** Return best-effort metrics for a queue. Values may be approximate due to the distributed nature of queues. */
export const getMetricsQueue: API.OperationMethod<
  GetMetricsQueueRequest,
  GetMetricsQueueResponse,
  GetMetricsQueueError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetMetricsQueueRequest,
  output: GetMetricsQueueResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetQueueError = QueueNotFound | InvalidRoute | CloudflareOpError;
/** Get details about a specific queue. */
export const getQueue: API.OperationMethod<
  GetQueueRequest,
  GetQueueResponse,
  GetQueueError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetQueueRequest,
  output: GetQueueResponse,
  errors: [QueueNotFound, InvalidRoute, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSubscriptionError =
  | UnrecognizedEventType
  | SubscriptionNotFound
  | Forbidden
  | CloudflareOpError;
/** Get details about an existing event subscription */
export const getSubscription: API.OperationMethod<
  GetSubscriptionRequest,
  GetSubscriptionResponse,
  GetSubscriptionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSubscriptionRequest,
  output: GetSubscriptionResponse,
  errors: [
    UnrecognizedEventType,
    SubscriptionNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListConsumersError =
  | InvalidRequestBody
  | QueueNotFound
  | InvalidRoute
  | CloudflareOpError;
/** Returns the consumers for a Queue */
export const listConsumers: API.PaginatedOperationMethod<
  ListConsumersRequest,
  ListConsumersResponse,
  ListConsumersError,
  CloudflareOpContext,
  ConsumersListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListConsumersRequest,
    output: ListConsumersResponse,
    errors: [
      InvalidRequestBody,
      QueueNotFound,
      InvalidRoute,
      CloudflareRateLimited,
      CloudflareError,
    ],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListQueuesError = InvalidRoute | CloudflareOpError;
/** Returns the queues owned by an account. */
export const listQueues: API.PaginatedOperationMethod<
  ListQueuesRequest,
  ListQueuesResponse,
  ListQueuesError,
  CloudflareOpContext,
  ListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListQueuesRequest,
    output: ListQueuesResponse,
    errors: [InvalidRoute, CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListSubscriptionsError = Forbidden | CloudflareOpError;
/** Get a paginated list of event subscriptions with optional sorting and filtering */
export const listSubscriptions: API.PaginatedOperationMethod<
  ListSubscriptionsRequest,
  ListSubscriptionsResponse,
  ListSubscriptionsError,
  CloudflareOpContext,
  SubscriptionsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListSubscriptionsRequest,
    output: ListSubscriptionsResponse,
    errors: [Forbidden, CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type PatchQueueError = QueueNotFound | InvalidRoute | CloudflareOpError;
/** Updates a Queue. */
export const patchQueue: API.OperationMethod<
  PatchQueueRequest,
  PatchQueueResponse,
  PatchQueueError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchQueueRequest,
  output: PatchQueueResponse,
  errors: [QueueNotFound, InvalidRoute, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchSubscriptionError =
  | UnrecognizedEventType
  | SubscriptionNotFound
  | QueueNotFound
  | CloudflareOpError;
/** Update an existing event subscription */
export const patchSubscription: API.OperationMethod<
  PatchSubscriptionRequest,
  PatchSubscriptionResponse,
  PatchSubscriptionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchSubscriptionRequest,
  output: PatchSubscriptionResponse,
  errors: [
    UnrecognizedEventType,
    SubscriptionNotFound,
    QueueNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PullMessageError =
  | InvalidRequestBody
  | InvalidQueueId
  | QueueNotFound
  | InvalidRoute
  | CloudflareOpError;
/** Pull a batch of messages from a Queue */
export const pullMessage: API.OperationMethod<
  PullMessageRequest,
  PullMessageResponse,
  PullMessageError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PullMessageRequest,
  output: PullMessageResponse,
  errors: [
    InvalidRequestBody,
    InvalidQueueId,
    QueueNotFound,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PurgeStatusError =
  | InvalidQueueId
  | InvalidRoute
  | CloudflareOpError;
/** Get details about a Queue's purge status. */
export const purgeStatus: API.OperationMethod<
  PurgeStatusRequest,
  PurgeStatusResponse,
  PurgeStatusError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PurgeStatusRequest,
  output: PurgeStatusResponse,
  errors: [
    InvalidQueueId,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PushMessageError =
  | InvalidMessageBody
  | InvalidQueueId
  | InvalidRoute
  | CloudflareOpError;
/** Push a message to a Queue */
export const pushMessage: API.OperationMethod<
  PushMessageRequest,
  PushMessageResponse,
  PushMessageError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PushMessageRequest,
  output: PushMessageResponse,
  errors: [
    InvalidMessageBody,
    InvalidQueueId,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type StartPurgeError = InvalidQueueId | InvalidRoute | CloudflareOpError;
/** Deletes all messages from the Queue. */
export const startPurge: API.OperationMethod<
  StartPurgeRequest,
  StartPurgeResponse,
  StartPurgeError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: StartPurgeRequest,
  output: StartPurgeResponse,
  errors: [
    InvalidQueueId,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateConsumerError =
  | InvalidRequestBody
  | QueueNotFound
  | QueueHandlerMissing
  | ConsumerNotFound
  | WorkerNotFound
  | InvalidRoute
  | CloudflareOpError;
/** Updates the consumer for a queue, or creates one if it does not exist. */
export const updateConsumer: API.OperationMethod<
  UpdateConsumerRequest,
  UpdateConsumerResponse,
  UpdateConsumerError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateConsumerRequest,
  output: UpdateConsumerResponse,
  errors: [
    InvalidRequestBody,
    QueueNotFound,
    QueueHandlerMissing,
    ConsumerNotFound,
    WorkerNotFound,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateQueueError =
  | InvalidQueueName
  | QueueNotFound
  | InvalidRoute
  | CloudflareOpError;
/** Updates a Queue. Note that this endpoint does not support partial updates. If successful, the Queue's configuration is overwritten with the supplied configuration. */
export const updateQueue: API.OperationMethod<
  UpdateQueueRequest,
  UpdateQueueResponse,
  UpdateQueueError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateQueueRequest,
  output: UpdateQueueResponse,
  errors: [
    InvalidQueueName,
    QueueNotFound,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));