@distilled.cloud/cloudflare 0.12.2 → 0.12.4

package/src/services/d1.ts

@@ -16,6 +16,12 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
+export class DatabaseAlreadyExists extends Schema.TaggedErrorClass<DatabaseAlreadyExists>()(
+  "DatabaseAlreadyExists",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(DatabaseAlreadyExists, [{ code: 7502 }]);
+
 export class DatabaseNotFound extends Schema.TaggedErrorClass<DatabaseNotFound>()(
   "DatabaseNotFound",
   { code: Schema.Number, message: Schema.String },
@@ -370,7 +376,8 @@ export const CreateDatabaseResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
 export type CreateDatabaseError =
   | DefaultErrors
   | InvalidObjectIdentifier
-  | InvalidProperty;
+  | InvalidProperty
+  | DatabaseAlreadyExists;
 
 export const createDatabase: API.OperationMethod<
   CreateDatabaseRequest,
@@ -380,7 +387,7 @@ export const createDatabase: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: CreateDatabaseRequest,
   output: CreateDatabaseResponse,
-  errors: [InvalidObjectIdentifier, InvalidProperty],
+  errors: [InvalidObjectIdentifier, InvalidProperty, DatabaseAlreadyExists],
 }));
 
 export interface UpdateDatabaseRequest {

package/src/services/pipelines.ts

@@ -17,12 +17,24 @@ import { SensitiveString } from "../sensitive.ts";
 // Errors
 // =============================================================================
 
+export class InvalidSinkConfig extends Schema.TaggedErrorClass<InvalidSinkConfig>()(
+  "InvalidSinkConfig",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(InvalidSinkConfig, [{ code: 1012 }]);
+
 export class InvalidSinkId extends Schema.TaggedErrorClass<InvalidSinkId>()(
   "InvalidSinkId",
   { code: Schema.Number, message: Schema.String },
 ) {}
 T.applyErrorMatchers(InvalidSinkId, [{ code: 2 }]);
 
+export class InvalidSql extends Schema.TaggedErrorClass<InvalidSql>()(
+  "InvalidSql",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(InvalidSql, [{ code: 1014 }]);
+
 export class InvalidStreamId extends Schema.TaggedErrorClass<InvalidStreamId>()(
   "InvalidStreamId",
   { code: Schema.Number, message: Schema.String },
@@ -35,12 +47,32 @@ export class InvalidStreamName extends Schema.TaggedErrorClass<InvalidStreamName
 ) {}
 T.applyErrorMatchers(InvalidStreamName, [{ code: 2 }]);
 
+export class PipelineAlreadyExists extends Schema.TaggedErrorClass<PipelineAlreadyExists>()(
+  "PipelineAlreadyExists",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(PipelineAlreadyExists, [{ code: 1003 }]);
+
 export class PipelineNotExists extends Schema.TaggedErrorClass<PipelineNotExists>()(
   "PipelineNotExists",
   { code: Schema.Number, message: Schema.String },
 ) {}
 T.applyErrorMatchers(PipelineNotExists, [{ code: 1000 }]);
 
+export class SinkAlreadyExists extends Schema.TaggedErrorClass<SinkAlreadyExists>()(
+  "SinkAlreadyExists",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(SinkAlreadyExists, [{ code: 1003 }]);
+
+export class SinkAuthFailed extends Schema.TaggedErrorClass<SinkAuthFailed>()(
+  "SinkAuthFailed",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(SinkAuthFailed, [
+  { code: 1012, message: { includes: "could not authenticate" } },
+]);
+
 export class SinkNotFound extends Schema.TaggedErrorClass<SinkNotFound>()(
   "SinkNotFound",
   { code: Schema.Number, message: Schema.String },
@@ -63,7 +95,9 @@ export class TableNotFound extends Schema.TaggedErrorClass<TableNotFound>()(
   "TableNotFound",
   { code: Schema.Number, message: Schema.String },
 ) {}
-T.applyErrorMatchers(TableNotFound, [{ code: 1014 }]);
+T.applyErrorMatchers(TableNotFound, [
+  { code: 1014, message: { includes: "not found" } },
+]);
 
 // =============================================================================
 // Pipeline
@@ -3328,7 +3362,11 @@ export const CreateSinkResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     T.ResponsePath("result"),
   ) as unknown as Schema.Schema<CreateSinkResponse>;
 
-export type CreateSinkError = DefaultErrors;
+export type CreateSinkError =
+  | DefaultErrors
+  | SinkAuthFailed
+  | InvalidSinkConfig
+  | SinkAlreadyExists;
 
 export const createSink: API.OperationMethod<
   CreateSinkRequest,
@@ -3338,7 +3376,7 @@ export const createSink: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: CreateSinkRequest,
   output: CreateSinkResponse,
-  errors: [],
+  errors: [SinkAuthFailed, InvalidSinkConfig, SinkAlreadyExists],
 }));
 
 export interface DeleteSinkRequest {
@@ -3466,7 +3504,10 @@ export const ValidateSqlPipelineResponse =
     T.ResponsePath("result"),
   ) as unknown as Schema.Schema<ValidateSqlPipelineResponse>;
 
-export type ValidateSqlPipelineError = DefaultErrors | TableNotFound;
+export type ValidateSqlPipelineError =
+  | DefaultErrors
+  | TableNotFound
+  | InvalidSql;
 
 export const validateSqlPipeline: API.OperationMethod<
   ValidateSqlPipelineRequest,
@@ -3476,7 +3517,7 @@ export const validateSqlPipeline: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: ValidateSqlPipelineRequest,
   output: ValidateSqlPipelineResponse,
-  errors: [TableNotFound],
+  errors: [TableNotFound, InvalidSql],
 }));
 
 // =============================================================================
@@ -5863,7 +5904,7 @@ export const GetV1PipelineResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     T.ResponsePath("result"),
   ) as unknown as Schema.Schema<GetV1PipelineResponse>;
 
-export type GetV1PipelineError = DefaultErrors;
+export type GetV1PipelineError = DefaultErrors | PipelineNotExists;
 
 export const getV1Pipeline: API.OperationMethod<
   GetV1PipelineRequest,
@@ -5873,7 +5914,7 @@ export const getV1Pipeline: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: GetV1PipelineRequest,
   output: GetV1PipelineResponse,
-  errors: [],
+  errors: [PipelineNotExists],
 }));
 
 export interface ListV1PipelineRequest {
@@ -6030,7 +6071,11 @@ export const CreateV1PipelineResponse =
       T.ResponsePath("result"),
     ) as unknown as Schema.Schema<CreateV1PipelineResponse>;
 
-export type CreateV1PipelineError = DefaultErrors;
+export type CreateV1PipelineError =
+  | DefaultErrors
+  | TableNotFound
+  | InvalidSql
+  | PipelineAlreadyExists;
 
 export const createV1Pipeline: API.OperationMethod<
   CreateV1PipelineRequest,
@@ -6040,7 +6085,7 @@ export const createV1Pipeline: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: CreateV1PipelineRequest,
   output: CreateV1PipelineResponse,
-  errors: [],
+  errors: [TableNotFound, InvalidSql, PipelineAlreadyExists],
 }));
 
 export interface DeleteV1PipelineRequest {
@@ -6065,7 +6110,7 @@ export type DeleteV1PipelineResponse = unknown;
 export const DeleteV1PipelineResponse =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<DeleteV1PipelineResponse>;
 
-export type DeleteV1PipelineError = DefaultErrors;
+export type DeleteV1PipelineError = DefaultErrors | PipelineNotExists;
 
 export const deleteV1Pipeline: API.OperationMethod<
   DeleteV1PipelineRequest,
@@ -6075,5 +6120,5 @@ export const deleteV1Pipeline: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: DeleteV1PipelineRequest,
   output: DeleteV1PipelineResponse,
-  errors: [],
+  errors: [PipelineNotExists],
 }));

package/src/services/queues.ts

@@ -16,6 +16,18 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
+export class ConsumerAlreadyExists extends Schema.TaggedErrorClass<ConsumerAlreadyExists>()(
+  "ConsumerAlreadyExists",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(ConsumerAlreadyExists, [{ code: 11004 }]);
+
+export class ConsumerNotFound extends Schema.TaggedErrorClass<ConsumerNotFound>()(
+  "ConsumerNotFound",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(ConsumerNotFound, [{ code: 10105 }, { code: 11006 }]);
+
 export class InvalidMessageBody extends Schema.TaggedErrorClass<InvalidMessageBody>()(
   "InvalidMessageBody",
   { code: Schema.Number, message: Schema.String },
@@ -56,7 +68,10 @@ export class QueueNotFound extends Schema.TaggedErrorClass<QueueNotFound>()(
   "QueueNotFound",
   { code: Schema.Number, message: Schema.String },
 ) {}
-T.applyErrorMatchers(QueueNotFound, [{ code: 11000 }]);
+T.applyErrorMatchers(QueueNotFound, [
+  { code: 11000 },
+  { code: 0, message: { includes: "Queue does not exist" } },
+]);
 
 export class UnrecognizedEventType extends Schema.TaggedErrorClass<UnrecognizedEventType>()(
   "UnrecognizedEventType",
@@ -66,6 +81,12 @@ T.applyErrorMatchers(UnrecognizedEventType, [
   { code: 0, message: { includes: "Unrecognized event types" } },
 ]);
 
+export class WorkerNotFound extends Schema.TaggedErrorClass<WorkerNotFound>()(
+  "WorkerNotFound",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(WorkerNotFound, [{ code: 10007 }]);
+
 // =============================================================================
 // Consumer
 // =============================================================================
@@ -215,6 +236,7 @@ export type GetConsumerError =
   | DefaultErrors
   | InvalidRequestBody
   | QueueNotFound
+  | ConsumerNotFound
   | InvalidRoute;
 
 export const getConsumer: API.OperationMethod<
@@ -225,7 +247,7 @@ export const getConsumer: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: GetConsumerRequest,
   output: GetConsumerResponse,
-  errors: [InvalidRequestBody, QueueNotFound, InvalidRoute],
+  errors: [InvalidRequestBody, QueueNotFound, ConsumerNotFound, InvalidRoute],
 }));
 
 export interface ListConsumersRequest {
@@ -576,6 +598,8 @@ export type CreateConsumerError =
   | DefaultErrors
   | InvalidRequestBody
   | QueueNotFound
+  | ConsumerAlreadyExists
+  | WorkerNotFound
   | InvalidRoute;
 
 export const createConsumer: API.OperationMethod<
@@ -586,7 +610,13 @@ export const createConsumer: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: CreateConsumerRequest,
   output: CreateConsumerResponse,
-  errors: [InvalidRequestBody, QueueNotFound, InvalidRoute],
+  errors: [
+    InvalidRequestBody,
+    QueueNotFound,
+    ConsumerAlreadyExists,
+    WorkerNotFound,
+    InvalidRoute,
+  ],
 }));
 
 export interface UpdateConsumerRequest {
@@ -774,6 +804,8 @@ export type UpdateConsumerError =
   | DefaultErrors
   | InvalidRequestBody
   | QueueNotFound
+  | ConsumerNotFound
+  | WorkerNotFound
   | InvalidRoute;
 
 export const updateConsumer: API.OperationMethod<
@@ -784,7 +816,13 @@ export const updateConsumer: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: UpdateConsumerRequest,
   output: UpdateConsumerResponse,
-  errors: [InvalidRequestBody, QueueNotFound, InvalidRoute],
+  errors: [
+    InvalidRequestBody,
+    QueueNotFound,
+    ConsumerNotFound,
+    WorkerNotFound,
+    InvalidRoute,
+  ],
 }));
 
 export interface DeleteConsumerRequest {
@@ -863,6 +901,7 @@ export type DeleteConsumerError =
   | DefaultErrors
   | InvalidRequestBody
   | QueueNotFound
+  | ConsumerNotFound
   | InvalidRoute;
 
 export const deleteConsumer: API.OperationMethod<
@@ -873,7 +912,7 @@ export const deleteConsumer: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: DeleteConsumerRequest,
   output: DeleteConsumerResponse,
-  errors: [InvalidRequestBody, QueueNotFound, InvalidRoute],
+  errors: [InvalidRequestBody, QueueNotFound, ConsumerNotFound, InvalidRoute],
 }));
 
 // =============================================================================
@@ -1092,6 +1131,7 @@ export type PullMessageError =
   | DefaultErrors
   | InvalidRequestBody
   | InvalidQueueId
+  | QueueNotFound
   | InvalidRoute;
 
 export const pullMessage: API.OperationMethod<
@@ -1102,7 +1142,7 @@ export const pullMessage: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: PullMessageRequest,
   output: PullMessageResponse,
-  errors: [InvalidRequestBody, InvalidQueueId, InvalidRoute],
+  errors: [InvalidRequestBody, InvalidQueueId, QueueNotFound, InvalidRoute],
 }));
 
 export interface PushMessageRequest {
@@ -1266,6 +1306,7 @@ export type AckMessageError =
   | DefaultErrors
   | InvalidRequestBody
   | InvalidQueueId
+  | QueueNotFound
   | InvalidRoute;
 
 export const ackMessage: API.OperationMethod<
@@ -1276,7 +1317,7 @@ export const ackMessage: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: AckMessageRequest,
   output: AckMessageResponse,
-  errors: [InvalidRequestBody, InvalidQueueId, InvalidRoute],
+  errors: [InvalidRequestBody, InvalidQueueId, QueueNotFound, InvalidRoute],
 }));
 
 // =============================================================================

package/src/services/r2.ts

@@ -36,6 +36,18 @@ export class DomainNotFound extends Schema.TaggedErrorClass<DomainNotFound>()(
 ) {}
 T.applyErrorMatchers(DomainNotFound, [{ code: 10053 }]);
 
+export class EventNotificationConfigNotFound extends Schema.TaggedErrorClass<EventNotificationConfigNotFound>()(
+  "EventNotificationConfigNotFound",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(EventNotificationConfigNotFound, [{ code: 11011 }]);
+
+export class EventNotificationRuleConflict extends Schema.TaggedErrorClass<EventNotificationRuleConflict>()(
+  "EventNotificationRuleConflict",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(EventNotificationRuleConflict, [{ code: 11020 }]);
+
 export class InvalidBucketName extends Schema.TaggedErrorClass<InvalidBucketName>()(
   "InvalidBucketName",
   { code: Schema.Number, message: Schema.String },
@@ -46,7 +58,10 @@ export class InvalidEventNotificationConfig extends Schema.TaggedErrorClass<Inva
   "InvalidEventNotificationConfig",
   { code: Schema.Number, message: Schema.String },
 ) {}
-T.applyErrorMatchers(InvalidEventNotificationConfig, [{ code: 11014 }]);
+T.applyErrorMatchers(InvalidEventNotificationConfig, [
+  { code: 11014 },
+  { code: 11019 },
+]);
 
 export class InvalidRoute extends Schema.TaggedErrorClass<InvalidRoute>()(
   "InvalidRoute",
@@ -1471,6 +1486,7 @@ export type GetBucketEventNotificationError =
   | DefaultErrors
   | BucketNotFound
   | NoEventNotificationConfig
+  | EventNotificationConfigNotFound
   | QueueNotFound
   | InvalidRoute;
 
@@ -1485,6 +1501,7 @@ export const getBucketEventNotification: API.OperationMethod<
   errors: [
     BucketNotFound,
     NoEventNotificationConfig,
+    EventNotificationConfigNotFound,
     QueueNotFound,
     InvalidRoute,
   ],
@@ -1682,6 +1699,7 @@ export type PutBucketEventNotificationError =
   | DefaultErrors
   | BucketNotFound
   | InvalidEventNotificationConfig
+  | EventNotificationRuleConflict
   | QueueNotFound
   | InvalidRoute;
 
@@ -1696,6 +1714,7 @@ export const putBucketEventNotification: API.OperationMethod<
   errors: [
     BucketNotFound,
     InvalidEventNotificationConfig,
+    EventNotificationRuleConflict,
     QueueNotFound,
     InvalidRoute,
   ],
@@ -1735,6 +1754,7 @@ export const DeleteBucketEventNotificationResponse =
 export type DeleteBucketEventNotificationError =
   | DefaultErrors
   | BucketNotFound
+  | EventNotificationConfigNotFound
   | QueueNotFound
   | InvalidRoute;
 
@@ -1746,7 +1766,12 @@ export const deleteBucketEventNotification: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: DeleteBucketEventNotificationRequest,
   output: DeleteBucketEventNotificationResponse,
-  errors: [BucketNotFound, QueueNotFound, InvalidRoute],
+  errors: [
+    BucketNotFound,
+    EventNotificationConfigNotFound,
+    QueueNotFound,
+    InvalidRoute,
+  ],
 }));
 
 // =============================================================================

package/src/services/user.ts

@@ -12,6 +12,44 @@ import * as T from "../traits.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
 
+// =============================================================================
+// Errors
+// =============================================================================
+
+export class InvalidRoute extends Schema.TaggedErrorClass<InvalidRoute>()(
+  "InvalidRoute",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(InvalidRoute, [{ code: 7003 }]);
+
+export class InvalidTokenName extends Schema.TaggedErrorClass<InvalidTokenName>()(
+  "InvalidTokenName",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(InvalidTokenName, [
+  { code: 400, message: { includes: "name must have a length" } },
+]);
+
+export class MethodNotAllowed extends Schema.TaggedErrorClass<MethodNotAllowed>()(
+  "MethodNotAllowed",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(MethodNotAllowed, [{ code: 7001 }]);
+
+export class PermissionGroupNotFound extends Schema.TaggedErrorClass<PermissionGroupNotFound>()(
+  "PermissionGroupNotFound",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(PermissionGroupNotFound, [
+  { code: 1001, message: { includes: "Permission group" } },
+]);
+
+export class TokenNotFound extends Schema.TaggedErrorClass<TokenNotFound>()(
+  "TokenNotFound",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(TokenNotFound, [{ code: 1003 }]);
+
 // =============================================================================
 // AuditLog
 // =============================================================================
@@ -1260,7 +1298,7 @@ export const GetTokenResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   )
   .pipe(T.ResponsePath("result")) as unknown as Schema.Schema<GetTokenResponse>;
 
-export type GetTokenError = DefaultErrors;
+export type GetTokenError = DefaultErrors | InvalidRoute | TokenNotFound;
 
 export const getToken: API.OperationMethod<
   GetTokenRequest,
@@ -1270,7 +1308,7 @@ export const getToken: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: GetTokenRequest,
   output: GetTokenResponse,
-  errors: [],
+  errors: [InvalidRoute, TokenNotFound],
 }));
 
 export interface ListTokensRequest {}
@@ -1637,7 +1675,11 @@ export const CreateTokenResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     T.ResponsePath("result"),
   ) as unknown as Schema.Schema<CreateTokenResponse>;
 
-export type CreateTokenError = DefaultErrors;
+export type CreateTokenError =
+  | DefaultErrors
+  | InvalidRoute
+  | InvalidTokenName
+  | PermissionGroupNotFound;
 
 export const createToken: API.OperationMethod<
   CreateTokenRequest,
@@ -1647,7 +1689,7 @@ export const createToken: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: CreateTokenRequest,
   output: CreateTokenResponse,
-  errors: [],
+  errors: [InvalidRoute, InvalidTokenName, PermissionGroupNotFound],
 }));
 
 export interface UpdateTokenRequest {
@@ -1846,7 +1888,12 @@ export const UpdateTokenResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     T.ResponsePath("result"),
   ) as unknown as Schema.Schema<UpdateTokenResponse>;
 
-export type UpdateTokenError = DefaultErrors;
+export type UpdateTokenError =
+  | DefaultErrors
+  | InvalidRoute
+  | MethodNotAllowed
+  | TokenNotFound
+  | PermissionGroupNotFound;
 
 export const updateToken: API.OperationMethod<
   UpdateTokenRequest,
@@ -1856,7 +1903,12 @@ export const updateToken: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: UpdateTokenRequest,
   output: UpdateTokenResponse,
-  errors: [],
+  errors: [
+    InvalidRoute,
+    MethodNotAllowed,
+    TokenNotFound,
+    PermissionGroupNotFound,
+  ],
 }));
 
 export interface DeleteTokenRequest {
@@ -1880,7 +1932,11 @@ export const DeleteTokenResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   T.ResponsePath("result"),
 ) as unknown as Schema.Schema<DeleteTokenResponse>;
 
-export type DeleteTokenError = DefaultErrors;
+export type DeleteTokenError =
+  | DefaultErrors
+  | InvalidRoute
+  | MethodNotAllowed
+  | TokenNotFound;
 
 export const deleteToken: API.OperationMethod<
   DeleteTokenRequest,
@@ -1890,7 +1946,7 @@ export const deleteToken: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: DeleteTokenRequest,
   output: DeleteTokenResponse,
-  errors: [],
+  errors: [InvalidRoute, MethodNotAllowed, TokenNotFound],
 }));
 
 export interface VerifyTokenRequest {}
@@ -2030,7 +2086,7 @@ export const PutTokenValueResponse =
     T.ResponsePath("result"),
   ) as unknown as Schema.Schema<PutTokenValueResponse>;
 
-export type PutTokenValueError = DefaultErrors;
+export type PutTokenValueError = DefaultErrors | InvalidRoute | TokenNotFound;
 
 export const putTokenValue: API.OperationMethod<
   PutTokenValueRequest,
@@ -2040,7 +2096,7 @@ export const putTokenValue: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: PutTokenValueRequest,
   output: PutTokenValueResponse,
-  errors: [],
+  errors: [InvalidRoute, TokenNotFound],
 }));
 
 // =============================================================================

package/src/services/workers.ts

@@ -99,6 +99,12 @@ export class ServiceBindingConflict extends Schema.TaggedErrorClass<ServiceBindi
 ) {}
 T.applyErrorMatchers(ServiceBindingConflict, [{ code: 10142 }]);
 
+export class SubdomainAlreadyExists extends Schema.TaggedErrorClass<SubdomainAlreadyExists>()(
+  "SubdomainAlreadyExists",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(SubdomainAlreadyExists, [{ code: 10036 }]);
+
 export class VersionNotFound extends Schema.TaggedErrorClass<VersionNotFound>()(
   "VersionNotFound",
   { code: Schema.Number, message: Schema.String },
@@ -14834,7 +14840,10 @@ export const PutSubdomainResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   T.ResponsePath("result"),
 ) as unknown as Schema.Schema<PutSubdomainResponse>;
 
-export type PutSubdomainError = DefaultErrors | InvalidRoute;
+export type PutSubdomainError =
+  | DefaultErrors
+  | SubdomainAlreadyExists
+  | InvalidRoute;
 
 export const putSubdomain: API.OperationMethod<
   PutSubdomainRequest,
@@ -14844,7 +14853,7 @@ export const putSubdomain: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: PutSubdomainRequest,
   output: PutSubdomainResponse,
-  errors: [InvalidRoute],
+  errors: [SubdomainAlreadyExists, InvalidRoute],
 }));
 
 export interface DeleteSubdomainRequest {

package/src/services/workflows.ts

@@ -16,6 +16,12 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
+export class InstanceAlreadyExists extends Schema.TaggedErrorClass<InstanceAlreadyExists>()(
+  "InstanceAlreadyExists",
+  { code: Schema.Number, message: Schema.String },
+) {}
+T.applyErrorMatchers(InstanceAlreadyExists, [{ code: 10405 }]);
+
 export class InstanceCannotTerminate extends Schema.TaggedErrorClass<InstanceCannotTerminate>()(
   "InstanceCannotTerminate",
   { code: Schema.Number, message: Schema.String },
@@ -513,6 +519,7 @@ export const CreateInstanceResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
 export type CreateInstanceError =
   | DefaultErrors
   | WorkflowNotFound
+  | InstanceAlreadyExists
   | InvalidRoute
   | InvalidBody;
 
@@ -524,7 +531,7 @@ export const createInstance: API.OperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
   input: CreateInstanceRequest,
   output: CreateInstanceResponse,
-  errors: [WorkflowNotFound, InvalidRoute, InvalidBody],
+  errors: [WorkflowNotFound, InstanceAlreadyExists, InvalidRoute, InvalidBody],
 }));
 
 export interface BulkInstanceRequest {
@@ -628,6 +635,7 @@ export const BulkInstanceResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
 export type BulkInstanceError =
   | DefaultErrors
   | WorkflowNotFound
+  | InstanceAlreadyExists
   | InvalidRoute
   | InvalidBody;
 
@@ -639,7 +647,7 @@ export const bulkInstance: API.PaginatedOperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: BulkInstanceRequest,
   output: BulkInstanceResponse,
-  errors: [WorkflowNotFound, InvalidRoute, InvalidBody],
+  errors: [WorkflowNotFound, InstanceAlreadyExists, InvalidRoute, InvalidBody],
   pagination: {
     mode: "single",
     items: "result",