@distilled.cloud/cloudflare 0.25.2 → 0.26.1

package/src/services/schema-validation.ts

@@ -16,35 +16,53 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
-export class Forbidden extends Schema.TaggedErrorClass<Forbidden>()(
-  "Forbidden",
-  { code: Schema.Number, message: Schema.String },
+export class Forbidden extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<Forbidden>()("Forbidden", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 403 }],
 ) {}
-T.applyErrorMatchers(Forbidden, [{ status: 403 }]);
 
-export class InvalidSchema extends Schema.TaggedErrorClass<InvalidSchema>()(
-  "InvalidSchema",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidSchema extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidSchema>()("InvalidSchema", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 50010 }],
 ) {}
-T.applyErrorMatchers(InvalidSchema, [{ code: 50010 }]);
 
-export class OperationNotFound extends Schema.TaggedErrorClass<OperationNotFound>()(
-  "OperationNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class OperationNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<OperationNotFound>()("OperationNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10404 }],
 ) {}
-T.applyErrorMatchers(OperationNotFound, [{ code: 10404 }]);
 
-export class SchemaNotFound extends Schema.TaggedErrorClass<SchemaNotFound>()(
-  "SchemaNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class SchemaNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SchemaNotFound>()("SchemaNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 19400 }],
 ) {}
-T.applyErrorMatchers(SchemaNotFound, [{ code: 19400 }]);
 
-export class UnentitledMitigationAction extends Schema.TaggedErrorClass<UnentitledMitigationAction>()(
-  "UnentitledMitigationAction",
-  { code: Schema.Number, message: Schema.String },
+export class UnentitledMitigationAction extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<UnentitledMitigationAction>()(
+    "UnentitledMitigationAction",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [{ code: 11400 }],
+) {}
+
+export class ZonePurged extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<ZonePurged>()("ZonePurged", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ message: { includes: "has been purged" } }],
 ) {}
-T.applyErrorMatchers(UnentitledMitigationAction, [{ code: 11400 }]);
 
 // =============================================================================
 // Schema
@@ -222,7 +240,7 @@ export const ListSchemasResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.suspend(
     }).pipe(Schema.encodeKeys({ result: "result", resultInfo: "result_info" })),
 ) as unknown as Schema.Schema<ListSchemasResponse>;
 
-export type ListSchemasError = DefaultErrors;
+export type ListSchemasError = DefaultErrors | ZonePurged | Forbidden;
 
 export const listSchemas: API.PaginatedOperationMethod<
   ListSchemasRequest,
@@ -232,7 +250,7 @@ export const listSchemas: API.PaginatedOperationMethod<
 > = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
   input: ListSchemasRequest,
   output: ListSchemasResponse,
-  errors: [],
+  errors: [ZonePurged, Forbidden],
   pagination: {
     mode: "page",
     inputToken: "page",

package/src/services/secrets-store.ts

@@ -16,81 +16,85 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
-export class InvalidAccountId extends Schema.TaggedErrorClass<InvalidAccountId>()(
-  "InvalidAccountId",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidAccountId extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidAccountId>()("InvalidAccountId", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 7003 }],
 ) {}
-T.applyErrorMatchers(InvalidAccountId, [{ code: 7003 }]);
 
-export class InvalidJsonBody extends Schema.TaggedErrorClass<InvalidJsonBody>()(
-  "InvalidJsonBody",
-  { code: Schema.Number, message: Schema.String },
+export class InvalidJsonBody extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<InvalidJsonBody>()("InvalidJsonBody", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1001, message: { includes: "invalid_json_body" } }],
 ) {}
-T.applyErrorMatchers(InvalidJsonBody, [
-  { code: 1001, message: { includes: "invalid_json_body" } },
-]);
 
-export class MaximumStoresExceeded extends Schema.TaggedErrorClass<MaximumStoresExceeded>()(
-  "MaximumStoresExceeded",
-  { code: Schema.Number, message: Schema.String },
+export class MaximumStoresExceeded extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<MaximumStoresExceeded>()("MaximumStoresExceeded", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1003, message: { includes: "maximum_stores_exceeded" } }],
 ) {}
-T.applyErrorMatchers(MaximumStoresExceeded, [
-  { code: 1003, message: { includes: "maximum_stores_exceeded" } },
-]);
-
-export class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
-  code: Schema.Number,
-  message: Schema.String,
-}) {}
-T.applyErrorMatchers(NotFound, [{ code: 1000 }]);
-
-export class SecretNameAlreadyExists extends Schema.TaggedErrorClass<SecretNameAlreadyExists>()(
-  "SecretNameAlreadyExists",
-  { code: Schema.Number, message: Schema.String },
+
+export class NotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<NotFound>()("NotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1000 }],
+) {}
+
+export class SecretNameAlreadyExists extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SecretNameAlreadyExists>()(
+    "SecretNameAlreadyExists",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [{ code: 1003, message: { includes: "secret_name_already_exists" } }],
 ) {}
-T.applyErrorMatchers(SecretNameAlreadyExists, [
-  { code: 1003, message: { includes: "secret_name_already_exists" } },
-]);
 
-export class SecretNameEmpty extends Schema.TaggedErrorClass<SecretNameEmpty>()(
-  "SecretNameEmpty",
-  { code: Schema.Number, message: Schema.String },
+export class SecretNameEmpty extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SecretNameEmpty>()("SecretNameEmpty", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1001, message: { includes: "secret_name_empty" } }],
 ) {}
-T.applyErrorMatchers(SecretNameEmpty, [
-  { code: 1001, message: { includes: "secret_name_empty" } },
-]);
 
-export class SecretNotFound extends Schema.TaggedErrorClass<SecretNotFound>()(
-  "SecretNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class SecretNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SecretNotFound>()("SecretNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1001, message: { includes: "secret_not_found" } }],
 ) {}
-T.applyErrorMatchers(SecretNotFound, [
-  { code: 1001, message: { includes: "secret_not_found" } },
-]);
 
-export class SecretScopeInvalid extends Schema.TaggedErrorClass<SecretScopeInvalid>()(
-  "SecretScopeInvalid",
-  { code: Schema.Number, message: Schema.String },
+export class SecretScopeInvalid extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SecretScopeInvalid>()("SecretScopeInvalid", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1001, message: { includes: "secret_scope_invalid" } }],
 ) {}
-T.applyErrorMatchers(SecretScopeInvalid, [
-  { code: 1001, message: { includes: "secret_scope_invalid" } },
-]);
 
-export class SecretScopesEmpty extends Schema.TaggedErrorClass<SecretScopesEmpty>()(
-  "SecretScopesEmpty",
-  { code: Schema.Number, message: Schema.String },
+export class SecretScopesEmpty extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SecretScopesEmpty>()("SecretScopesEmpty", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1001, message: { includes: "secret_scopes_empty" } }],
 ) {}
-T.applyErrorMatchers(SecretScopesEmpty, [
-  { code: 1001, message: { includes: "secret_scopes_empty" } },
-]);
 
-export class StoreNotFound extends Schema.TaggedErrorClass<StoreNotFound>()(
-  "StoreNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class StoreNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<StoreNotFound>()("StoreNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 1001, message: { includes: "store_not_found" } }],
 ) {}
-T.applyErrorMatchers(StoreNotFound, [
-  { code: 1001, message: { includes: "store_not_found" } },
-]);
 
 // =============================================================================
 // Quota

package/src/services/security-txt.ts

@@ -16,19 +16,21 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
-export class Forbidden extends Schema.TaggedErrorClass<Forbidden>()(
-  "Forbidden",
-  { code: Schema.Number, message: Schema.String },
+export class Forbidden extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<Forbidden>()("Forbidden", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 403 }],
 ) {}
-T.applyErrorMatchers(Forbidden, [{ status: 403 }]);
 
-export class SecurityTxtInvalid extends Schema.TaggedErrorClass<SecurityTxtInvalid>()(
-  "SecurityTxtInvalid",
-  { code: Schema.Number, message: Schema.String },
+export class SecurityTxtInvalid extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SecurityTxtInvalid>()("SecurityTxtInvalid", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10400, message: { includes: "invalid or missing values" } }],
 ) {}
-T.applyErrorMatchers(SecurityTxtInvalid, [
-  { code: 10400, message: { includes: "invalid or missing values" } },
-]);
 
 // =============================================================================
 // SecurityTxt

package/src/services/snippets.ts

@@ -17,35 +17,43 @@ import { UploadableSchema } from "../schemas.ts";
 // Errors
 // =============================================================================
 
-export class Forbidden extends Schema.TaggedErrorClass<Forbidden>()(
-  "Forbidden",
-  { code: Schema.Number, message: Schema.String },
+export class Forbidden extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<Forbidden>()("Forbidden", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 403 }],
 ) {}
-T.applyErrorMatchers(Forbidden, [{ status: 403 }]);
 
-export class SnippetInUse extends Schema.TaggedErrorClass<SnippetInUse>()(
-  "SnippetInUse",
-  { code: Schema.Number, message: Schema.String },
+export class SnippetInUse extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SnippetInUse>()("SnippetInUse", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [
+    { status: 400, message: { includes: "still used" } },
+    { status: 409, message: { includes: "still used" } },
+  ],
 ) {}
-T.applyErrorMatchers(SnippetInUse, [
-  { status: 400, message: { includes: "still used" } },
-  { status: 409, message: { includes: "still used" } },
-]);
-
-export class SnippetNotFound extends Schema.TaggedErrorClass<SnippetNotFound>()(
-  "SnippetNotFound",
-  { code: Schema.Number, message: Schema.String },
+
+export class SnippetNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SnippetNotFound>()("SnippetNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [
+    { status: 400, message: { includes: "snippet not found" } },
+    { status: 404 },
+  ],
 ) {}
-T.applyErrorMatchers(SnippetNotFound, [
-  { status: 400, message: { includes: "snippet not found" } },
-  { status: 404 },
-]);
-
-export class SnippetRulesNotFound extends Schema.TaggedErrorClass<SnippetRulesNotFound>()(
-  "SnippetRulesNotFound",
-  { code: Schema.Number, message: Schema.String },
+
+export class SnippetRulesNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SnippetRulesNotFound>()("SnippetRulesNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 404 }],
 ) {}
-T.applyErrorMatchers(SnippetRulesNotFound, [{ status: 404 }]);
 
 // =============================================================================
 // Content

package/src/services/spectrum.ts

@@ -16,23 +16,29 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
-export class Forbidden extends Schema.TaggedErrorClass<Forbidden>()(
-  "Forbidden",
-  { code: Schema.Number, message: Schema.String },
+export class Forbidden extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<Forbidden>()("Forbidden", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 403 }],
 ) {}
-T.applyErrorMatchers(Forbidden, [{ status: 403 }]);
 
-export class SpectrumAppNotFound extends Schema.TaggedErrorClass<SpectrumAppNotFound>()(
-  "SpectrumAppNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class SpectrumAppNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SpectrumAppNotFound>()("SpectrumAppNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10006 }],
 ) {}
-T.applyErrorMatchers(SpectrumAppNotFound, [{ code: 10006 }]);
 
-export class SpectrumProtocolNotAvailable extends Schema.TaggedErrorClass<SpectrumProtocolNotAvailable>()(
-  "SpectrumProtocolNotAvailable",
-  { code: Schema.Number, message: Schema.String },
+export class SpectrumProtocolNotAvailable extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SpectrumProtocolNotAvailable>()(
+    "SpectrumProtocolNotAvailable",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [{ code: 13002 }],
 ) {}
-T.applyErrorMatchers(SpectrumProtocolNotAvailable, [{ code: 13002 }]);
 
 // =============================================================================
 // AnalyticAggregateCurrent

package/src/services/speed.ts

@@ -16,36 +16,37 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
-export class Forbidden extends Schema.TaggedErrorClass<Forbidden>()(
-  "Forbidden",
-  { code: Schema.Number, message: Schema.String },
+export class Forbidden extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<Forbidden>()("Forbidden", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 403 }],
 ) {}
-T.applyErrorMatchers(Forbidden, [{ status: 403 }]);
 
-export class TestScheduleAlreadyExists extends Schema.TaggedErrorClass<TestScheduleAlreadyExists>()(
-  "TestScheduleAlreadyExists",
-  { code: Schema.Number, message: Schema.String },
+export class TestScheduleAlreadyExists extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<TestScheduleAlreadyExists>()(
+    "TestScheduleAlreadyExists",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [{ code: 400, message: { includes: "scheduled_test_already_exists" } }],
 ) {}
-T.applyErrorMatchers(TestScheduleAlreadyExists, [
-  { code: 400, message: { includes: "scheduled_test_already_exists" } },
-]);
 
-export class TestScheduleNotFound extends Schema.TaggedErrorClass<TestScheduleNotFound>()(
-  "TestScheduleNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class TestScheduleNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<TestScheduleNotFound>()("TestScheduleNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 404, message: { includes: "schedule_not_found" } }, { status: 404 }],
 ) {}
-T.applyErrorMatchers(TestScheduleNotFound, [
-  { code: 404, message: { includes: "schedule_not_found" } },
-  { status: 404 },
-]);
-
-export class TestScheduleQuotaReached extends Schema.TaggedErrorClass<TestScheduleQuotaReached>()(
-  "TestScheduleQuotaReached",
-  { code: Schema.Number, message: Schema.String },
+
+export class TestScheduleQuotaReached extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<TestScheduleQuotaReached>()(
+    "TestScheduleQuotaReached",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [{ code: 429, message: { includes: "quota reached" } }],
 ) {}
-T.applyErrorMatchers(TestScheduleQuotaReached, [
-  { code: 429, message: { includes: "quota reached" } },
-]);
 
 // =============================================================================
 // Availability

package/src/services/ssl.ts

@@ -16,26 +16,29 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
-export class AdvancedCertificateManagerRequired extends Schema.TaggedErrorClass<AdvancedCertificateManagerRequired>()(
-  "AdvancedCertificateManagerRequired",
-  { code: Schema.Number, message: Schema.String },
+export class AdvancedCertificateManagerRequired extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<AdvancedCertificateManagerRequired>()(
+    "AdvancedCertificateManagerRequired",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [{ code: 1450 }],
 ) {}
-T.applyErrorMatchers(AdvancedCertificateManagerRequired, [{ code: 1450 }]);
 
-export class CertificatePackNotFound extends Schema.TaggedErrorClass<CertificatePackNotFound>()(
-  "CertificatePackNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class CertificatePackNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<CertificatePackNotFound>()(
+    "CertificatePackNotFound",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [{ code: 1408 }, { status: 404 }],
 ) {}
-T.applyErrorMatchers(CertificatePackNotFound, [
-  { code: 1408 },
-  { status: 404 },
-]);
-
-export class Forbidden extends Schema.TaggedErrorClass<Forbidden>()(
-  "Forbidden",
-  { code: Schema.Number, message: Schema.String },
+
+export class Forbidden extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<Forbidden>()("Forbidden", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 403 }],
 ) {}
-T.applyErrorMatchers(Forbidden, [{ status: 403 }]);
 
 // =============================================================================
 // Analyze

package/src/services/stream.ts

@@ -16,47 +16,61 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
-export class Forbidden extends Schema.TaggedErrorClass<Forbidden>()(
-  "Forbidden",
-  { code: Schema.Number, message: Schema.String },
+export class Forbidden extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<Forbidden>()("Forbidden", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 403 }],
 ) {}
-T.applyErrorMatchers(Forbidden, [{ status: 403 }]);
 
-export class LiveInputNotFound extends Schema.TaggedErrorClass<LiveInputNotFound>()(
-  "LiveInputNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class LiveInputNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<LiveInputNotFound>()("LiveInputNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10003 }],
 ) {}
-T.applyErrorMatchers(LiveInputNotFound, [{ code: 10003 }]);
 
-export class OutputNotFound extends Schema.TaggedErrorClass<OutputNotFound>()(
-  "OutputNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class OutputNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<OutputNotFound>()("OutputNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10003 }],
 ) {}
-T.applyErrorMatchers(OutputNotFound, [{ code: 10003 }]);
 
-export class SigningKeyNotFound extends Schema.TaggedErrorClass<SigningKeyNotFound>()(
-  "SigningKeyNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class SigningKeyNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<SigningKeyNotFound>()("SigningKeyNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10003 }],
 ) {}
-T.applyErrorMatchers(SigningKeyNotFound, [{ code: 10003 }]);
 
-export class WatermarkImageInvalid extends Schema.TaggedErrorClass<WatermarkImageInvalid>()(
-  "WatermarkImageInvalid",
-  { code: Schema.Number, message: Schema.String },
+export class WatermarkImageInvalid extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<WatermarkImageInvalid>()("WatermarkImageInvalid", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10004 }],
 ) {}
-T.applyErrorMatchers(WatermarkImageInvalid, [{ code: 10004 }]);
 
-export class WatermarkNotFound extends Schema.TaggedErrorClass<WatermarkNotFound>()(
-  "WatermarkNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class WatermarkNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<WatermarkNotFound>()("WatermarkNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10003 }],
 ) {}
-T.applyErrorMatchers(WatermarkNotFound, [{ code: 10003 }]);
 
-export class WebhookNotFound extends Schema.TaggedErrorClass<WebhookNotFound>()(
-  "WebhookNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class WebhookNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<WebhookNotFound>()("WebhookNotFound", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ code: 10003 }],
 ) {}
-T.applyErrorMatchers(WebhookNotFound, [{ code: 10003 }]);
 
 // =============================================================================
 // AudioTrack

package/src/services/token-validation.ts

@@ -16,29 +16,37 @@ import { type DefaultErrors } from "../errors.ts";
 // Errors
 // =============================================================================
 
-export class Forbidden extends Schema.TaggedErrorClass<Forbidden>()(
-  "Forbidden",
-  { code: Schema.Number, message: Schema.String },
+export class Forbidden extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<Forbidden>()("Forbidden", {
+    code: Schema.Number,
+    message: Schema.String,
+  }),
+  [{ status: 403 }],
 ) {}
-T.applyErrorMatchers(Forbidden, [{ status: 403 }]);
 
-export class TokenConfigurationNotFound extends Schema.TaggedErrorClass<TokenConfigurationNotFound>()(
-  "TokenConfigurationNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class TokenConfigurationNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<TokenConfigurationNotFound>()(
+    "TokenConfigurationNotFound",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [{ status: 404 }],
 ) {}
-T.applyErrorMatchers(TokenConfigurationNotFound, [{ status: 404 }]);
 
-export class TokenValidationNotEntitled extends Schema.TaggedErrorClass<TokenValidationNotEntitled>()(
-  "TokenValidationNotEntitled",
-  { code: Schema.Number, message: Schema.String },
+export class TokenValidationNotEntitled extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<TokenValidationNotEntitled>()(
+    "TokenValidationNotEntitled",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [{ code: 10403 }],
 ) {}
-T.applyErrorMatchers(TokenValidationNotEntitled, [{ code: 10403 }]);
 
-export class TokenValidationRuleNotFound extends Schema.TaggedErrorClass<TokenValidationRuleNotFound>()(
-  "TokenValidationRuleNotFound",
-  { code: Schema.Number, message: Schema.String },
+export class TokenValidationRuleNotFound extends T.applyErrorMatchers(
+  Schema.TaggedErrorClass<TokenValidationRuleNotFound>()(
+    "TokenValidationRuleNotFound",
+    { code: Schema.Number, message: Schema.String },
+  ),
+  [{ status: 404 }],
 ) {}
-T.applyErrorMatchers(TokenValidationRuleNotFound, [{ status: 404 }]);
 
 // =============================================================================
 // Configuration