@quotalayer/contracts 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,793 @@
+// src/auth.ts
+import { Type } from "@sinclair/typebox";
+
+// src/value.ts
+import { FormatRegistry } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+var uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+if (!FormatRegistry.Has("uuid")) {
+  FormatRegistry.Set("uuid", (value) => uuidPattern.test(value));
+}
+if (!FormatRegistry.Has("date-time")) {
+  FormatRegistry.Set("date-time", (value) => Number.isFinite(Date.parse(value)));
+}
+
+// src/auth.ts
+var RegisterSchema = Type.Object(
+  {
+    email: Type.String({ format: "email", maxLength: 320 }),
+    password: Type.String({ minLength: 12, maxLength: 128 }),
+    displayName: Type.String({ minLength: 1, maxLength: 120 }),
+    workspaceName: Type.String({ minLength: 1, maxLength: 120 })
+  },
+  { additionalProperties: false }
+);
+var LoginSchema = Type.Object(
+  {
+    email: Type.String({ format: "email", maxLength: 320 }),
+    password: Type.String({ minLength: 1, maxLength: 128 })
+  },
+  { additionalProperties: false }
+);
+var AuthSessionSchema = Type.Object({
+  user: Type.Object({
+    id: Type.String({ format: "uuid" }),
+    email: Type.String(),
+    displayName: Type.String(),
+    locale: Type.String()
+  }),
+  workspace: Type.Object({
+    id: Type.String({ format: "uuid" }),
+    name: Type.String(),
+    role: Type.String()
+  }),
+  project: Type.Object({
+    id: Type.String({ format: "uuid" }),
+    name: Type.String()
+  }),
+  environment: Type.Object({
+    id: Type.String({ format: "uuid" }),
+    name: Type.String(),
+    type: Type.String()
+  })
+});
+function isAuthSessionResponse(value) {
+  return Value.Check(AuthSessionSchema, value);
+}
+
+// src/common.ts
+import { Type as Type2 } from "@sinclair/typebox";
+var ApiErrorSchema = Type2.Object({
+  error: Type2.Object({
+    code: Type2.String(),
+    message: Type2.String(),
+    requestId: Type2.String()
+  })
+});
+function isApiError(value) {
+  return Value.Check(ApiErrorSchema, value);
+}
+var HealthResponseSchema = Type2.Object({
+  status: Type2.Literal("ok"),
+  service: Type2.String(),
+  version: Type2.String()
+});
+function isHealthResponse(value) {
+  return Value.Check(HealthResponseSchema, value);
+}
+
+// src/credits.ts
+import { Type as Type3 } from "@sinclair/typebox";
+var CreditAmountSchema = Type3.String({ pattern: "^[0-9]+$" });
+var CreditBalanceSchema = Type3.Object({
+  accountId: Type3.String({ format: "uuid" }),
+  granted: CreditAmountSchema,
+  available: CreditAmountSchema,
+  reserved: CreditAmountSchema,
+  consumed: CreditAmountSchema,
+  expired: CreditAmountSchema
+});
+function isCreditBalanceResponse(value) {
+  return Value.Check(CreditBalanceSchema, value);
+}
+var GrantCreditsSchema = Type3.Object({
+  customerId: Type3.String({ minLength: 1, maxLength: 255 }),
+  amount: CreditAmountSchema,
+  idempotencyKey: Type3.String({ minLength: 1, maxLength: 255 }),
+  expiresAt: Type3.Optional(Type3.String({ format: "date-time" }))
+});
+var ReserveCreditsSchema = Type3.Object({
+  customerId: Type3.String({ minLength: 1, maxLength: 255 }),
+  amount: CreditAmountSchema,
+  idempotencyKey: Type3.String({ minLength: 1, maxLength: 255 }),
+  expiresAt: Type3.String({ format: "date-time" })
+});
+var ReservationResponseSchema = Type3.Object({
+  id: Type3.String({ format: "uuid" }),
+  accountId: Type3.String({ format: "uuid" }),
+  customerId: Type3.String({ format: "uuid" }),
+  amount: CreditAmountSchema,
+  committedAmount: Type3.Union([CreditAmountSchema, Type3.Null()]),
+  status: Type3.String(),
+  expiresAt: Type3.String({ format: "date-time" })
+});
+function isReservationResponse(value) {
+  return Value.Check(ReservationResponseSchema, value);
+}
+var CommitReservationSchema = Type3.Object({
+  amount: CreditAmountSchema
+});
+var RefundCreditsSchema = Type3.Object(
+  {
+    reservationId: Type3.String({ format: "uuid" }),
+    amount: CreditAmountSchema,
+    idempotencyKey: Type3.String({ minLength: 1, maxLength: 255 })
+  },
+  { additionalProperties: false }
+);
+var CreditBalanceQuerySchema = Type3.Object({
+  customerId: Type3.String({ minLength: 1, maxLength: 255 })
+});
+var ReservationParamsSchema = Type3.Object({
+  reservationId: Type3.String({ format: "uuid" })
+});
+var CreditAccountRecordSchema = Type3.Object({
+  accountId: Type3.String({ format: "uuid" }),
+  customerId: Type3.String({ format: "uuid" }),
+  externalCustomerId: Type3.String(),
+  customerName: Type3.Union([Type3.String(), Type3.Null()]),
+  granted: CreditAmountSchema,
+  available: CreditAmountSchema,
+  reserved: CreditAmountSchema,
+  consumed: CreditAmountSchema,
+  expired: CreditAmountSchema
+});
+var CreditAccountListSchema = Type3.Object({
+  items: Type3.Array(CreditAccountRecordSchema)
+});
+var CreditLedgerRecordSchema = Type3.Object({
+  id: Type3.String({ format: "uuid" }),
+  accountId: Type3.String({ format: "uuid" }),
+  externalCustomerId: Type3.String(),
+  type: Type3.String(),
+  amount: Type3.String(),
+  balanceAfter: Type3.String(),
+  idempotencyKey: Type3.String(),
+  referenceType: Type3.Union([Type3.String(), Type3.Null()]),
+  referenceId: Type3.Union([Type3.String(), Type3.Null()]),
+  createdAt: Type3.String({ format: "date-time" })
+});
+var CreditLedgerListSchema = Type3.Object({ items: Type3.Array(CreditLedgerRecordSchema) });
+function isCreditAccountList(value) {
+  return Value.Check(CreditAccountListSchema, value);
+}
+function isCreditLedgerList(value) {
+  return Value.Check(CreditLedgerListSchema, value);
+}
+
+// src/entitlements.ts
+import { Type as Type4 } from "@sinclair/typebox";
+var EntitlementTypeSchema = Type4.Union([
+  Type4.Literal("BOOLEAN"),
+  Type4.Literal("STATIC"),
+  Type4.Literal("METERED")
+]);
+var BillingPeriodSchema = Type4.Union([
+  Type4.Literal("ONE_TIME"),
+  Type4.Literal("MONTHLY"),
+  Type4.Literal("ANNUAL")
+]);
+var StaticValueSchema = Type4.Union([Type4.String(), Type4.Number(), Type4.Boolean()]);
+var FeatureInputSchema = Type4.Object(
+  {
+    key: Type4.String({ minLength: 1, maxLength: 128, pattern: "^[a-z0-9][a-z0-9._-]*$" }),
+    name: Type4.String({ minLength: 1, maxLength: 120 }),
+    type: EntitlementTypeSchema,
+    meterId: Type4.Optional(Type4.String({ format: "uuid" }))
+  },
+  { additionalProperties: false }
+);
+var FeatureRecordSchema = Type4.Object({
+  id: Type4.String({ format: "uuid" }),
+  key: Type4.String(),
+  name: Type4.String(),
+  type: EntitlementTypeSchema,
+  meterId: Type4.Union([Type4.String({ format: "uuid" }), Type4.Null()])
+});
+var FeatureListSchema = Type4.Object({ items: Type4.Array(FeatureRecordSchema) });
+var PlanEntitlementInputSchema = Type4.Object(
+  {
+    featureId: Type4.String({ format: "uuid" }),
+    booleanValue: Type4.Optional(Type4.Boolean()),
+    staticValue: Type4.Optional(StaticValueSchema),
+    allowance: Type4.Optional(Type4.String({ pattern: "^[0-9]+(?:\\.[0-9]+)?$" })),
+    period: Type4.Optional(BillingPeriodSchema)
+  },
+  { additionalProperties: false }
+);
+var PlanInputSchema = Type4.Object(
+  {
+    key: Type4.String({ minLength: 1, maxLength: 128, pattern: "^[a-z0-9][a-z0-9._-]*$" }),
+    name: Type4.String({ minLength: 1, maxLength: 120 }),
+    period: BillingPeriodSchema,
+    entitlements: Type4.Array(PlanEntitlementInputSchema, { minItems: 1, maxItems: 100 })
+  },
+  { additionalProperties: false }
+);
+var PlanRecordSchema = Type4.Object({
+  id: Type4.String({ format: "uuid" }),
+  key: Type4.String(),
+  name: Type4.String(),
+  versionId: Type4.String({ format: "uuid" }),
+  version: Type4.Integer({ minimum: 1 }),
+  status: Type4.Union([Type4.Literal("DRAFT"), Type4.Literal("PUBLISHED"), Type4.Literal("ARCHIVED")]),
+  period: BillingPeriodSchema,
+  entitlementCount: Type4.Integer({ minimum: 0 })
+});
+var PlanListSchema = Type4.Object({ items: Type4.Array(PlanRecordSchema) });
+var PlanVersionParamsSchema = Type4.Object({
+  planVersionId: Type4.String({ format: "uuid" })
+});
+var SubscriptionInputSchema = Type4.Object(
+  {
+    customerId: Type4.String({ minLength: 1, maxLength: 255 }),
+    planVersionId: Type4.String({ format: "uuid" }),
+    startsAt: Type4.Optional(Type4.String({ format: "date-time" })),
+    endsAt: Type4.Optional(Type4.String({ format: "date-time" }))
+  },
+  { additionalProperties: false }
+);
+var SubscriptionRecordSchema = Type4.Object({
+  id: Type4.String({ format: "uuid" }),
+  customerId: Type4.String({ format: "uuid" }),
+  planVersionId: Type4.String({ format: "uuid" }),
+  status: Type4.Literal("ACTIVE"),
+  startsAt: Type4.String({ format: "date-time" }),
+  endsAt: Type4.Union([Type4.String({ format: "date-time" }), Type4.Null()])
+});
+var EntitlementOverrideInputSchema = Type4.Object(
+  {
+    customerId: Type4.String({ minLength: 1, maxLength: 255 }),
+    featureId: Type4.String({ format: "uuid" }),
+    booleanValue: Type4.Optional(Type4.Boolean()),
+    staticValue: Type4.Optional(StaticValueSchema),
+    allowance: Type4.Optional(Type4.String({ pattern: "^[0-9]+(?:\\.[0-9]+)?$" })),
+    period: Type4.Optional(BillingPeriodSchema),
+    startsAt: Type4.Optional(Type4.String({ format: "date-time" })),
+    endsAt: Type4.Optional(Type4.String({ format: "date-time" }))
+  },
+  { additionalProperties: false }
+);
+var EntitlementOverrideRecordSchema = Type4.Object({
+  id: Type4.String({ format: "uuid" }),
+  customerId: Type4.String({ format: "uuid" }),
+  featureId: Type4.String({ format: "uuid" }),
+  startsAt: Type4.String({ format: "date-time" }),
+  endsAt: Type4.Union([Type4.String({ format: "date-time" }), Type4.Null()])
+});
+var EntitlementQuerySchema = Type4.Object({
+  customerId: Type4.String({ minLength: 1, maxLength: 255 }),
+  featureKey: Type4.String({ minLength: 1, maxLength: 128 })
+});
+var EntitlementResponseSchema = Type4.Object({
+  customerId: Type4.String({ format: "uuid" }),
+  featureKey: Type4.String(),
+  type: EntitlementTypeSchema,
+  source: Type4.Union([Type4.Literal("PLAN"), Type4.Literal("OVERRIDE"), Type4.Literal("NONE")]),
+  hasAccess: Type4.Boolean(),
+  booleanValue: Type4.Optional(Type4.Boolean()),
+  staticValue: Type4.Optional(StaticValueSchema),
+  allowance: Type4.Optional(Type4.String()),
+  usage: Type4.Optional(Type4.String()),
+  remaining: Type4.Optional(Type4.String()),
+  periodStart: Type4.Optional(Type4.String({ format: "date-time" })),
+  periodEnd: Type4.Optional(Type4.String({ format: "date-time" }))
+});
+function isFeatureList(value) {
+  return Value.Check(FeatureListSchema, value);
+}
+function isFeatureRecord(value) {
+  return Value.Check(FeatureRecordSchema, value);
+}
+function isPlanList(value) {
+  return Value.Check(PlanListSchema, value);
+}
+function isPlanRecord(value) {
+  return Value.Check(PlanRecordSchema, value);
+}
+function isSubscriptionRecord(value) {
+  return Value.Check(SubscriptionRecordSchema, value);
+}
+function isEntitlementResponse(value) {
+  return Value.Check(EntitlementResponseSchema, value);
+}
+
+// src/events.ts
+import { Type as Type5 } from "@sinclair/typebox";
+var EventValueSchema = Type5.Union([Type5.String(), Type5.Number(), Type5.Boolean()]);
+var EventPropertiesSchema = Type5.Record(
+  Type5.String({ minLength: 1, maxLength: 64 }),
+  EventValueSchema
+);
+function isEventProperties(value) {
+  return Value.Check(EventPropertiesSchema, value);
+}
+var CloudEventInputSchema = Type5.Object({
+  specversion: Type5.Literal("1.0"),
+  id: Type5.String({ minLength: 1, maxLength: 255 }),
+  source: Type5.String({ minLength: 1, maxLength: 255 }),
+  type: Type5.String({ minLength: 1, maxLength: 128 }),
+  subject: Type5.String({ minLength: 1, maxLength: 255 }),
+  time: Type5.Optional(Type5.String({ format: "date-time" })),
+  data: Type5.Optional(EventPropertiesSchema)
+});
+var CloudEventIngestSchema = Type5.Union([
+  CloudEventInputSchema,
+  Type5.Array(CloudEventInputSchema, { minItems: 1, maxItems: 100 })
+]);
+var UsageEventInputSchema = Type5.Object(
+  {
+    idempotencyKey: Type5.String({ minLength: 1, maxLength: 255 }),
+    customerId: Type5.String({ minLength: 1, maxLength: 255 }),
+    event: Type5.String({ minLength: 1, maxLength: 128 }),
+    occurredAt: Type5.String({ format: "date-time" }),
+    value: Type5.Optional(Type5.Number({ minimum: 0 })),
+    properties: Type5.Optional(EventPropertiesSchema)
+  },
+  { additionalProperties: false }
+);
+var UsageEventCorrectionInputSchema = Type5.Object(
+  {
+    idempotencyKey: Type5.String({ minLength: 1, maxLength: 255 }),
+    reason: Type5.Optional(Type5.String({ minLength: 1, maxLength: 500 }))
+  },
+  { additionalProperties: false }
+);
+var UsageEventParamsSchema = Type5.Object({
+  eventId: Type5.String({ format: "uuid" })
+});
+var UsageEventAcceptedSchema = Type5.Object({
+  id: Type5.String({ format: "uuid" }),
+  duplicate: Type5.Boolean()
+});
+function isUsageEventAccepted(value) {
+  return Value.Check(UsageEventAcceptedSchema, value);
+}
+var UsageEventBatchInputSchema = Type5.Object({
+  events: Type5.Array(UsageEventInputSchema, { minItems: 1, maxItems: 100 })
+});
+var UsageEventBatchAcceptedSchema = Type5.Object({
+  items: Type5.Array(UsageEventAcceptedSchema)
+});
+function isUsageEventBatchAccepted(value) {
+  return Value.Check(UsageEventBatchAcceptedSchema, value);
+}
+var UsageEventQuerySchema = Type5.Object({
+  customerId: Type5.Optional(Type5.String({ minLength: 1, maxLength: 255 })),
+  event: Type5.Optional(Type5.String({ minLength: 1, maxLength: 128 })),
+  from: Type5.Optional(Type5.String({ format: "date-time" })),
+  to: Type5.Optional(Type5.String({ format: "date-time" })),
+  limit: Type5.Optional(Type5.Integer({ minimum: 1, maximum: 100 })),
+  cursor: Type5.Optional(Type5.String({ format: "uuid" }))
+});
+var UsageEventRecordSchema = Type5.Object({
+  id: Type5.String({ format: "uuid" }),
+  idempotencyKey: Type5.String(),
+  customerId: Type5.String(),
+  event: Type5.String(),
+  occurredAt: Type5.String({ format: "date-time" }),
+  ingestedAt: Type5.String({ format: "date-time" }),
+  value: Type5.String(),
+  properties: Type5.Record(Type5.String(), EventValueSchema),
+  status: Type5.String(),
+  correctionOfId: Type5.Union([Type5.String({ format: "uuid" }), Type5.Null()]),
+  estimatedCostMinor: Type5.Union([Type5.String(), Type5.Null()]),
+  costCurrency: Type5.Union([Type5.String(), Type5.Null()])
+});
+var UsageEventListSchema = Type5.Object({
+  items: Type5.Array(UsageEventRecordSchema),
+  nextCursor: Type5.Union([Type5.String({ format: "uuid" }), Type5.Null()])
+});
+function isUsageEventList(value) {
+  return Value.Check(UsageEventListSchema, value);
+}
+
+// src/management.ts
+import { Type as Type6 } from "@sinclair/typebox";
+var CustomerInputSchema = Type6.Object(
+  {
+    externalId: Type6.String({ minLength: 1, maxLength: 255 }),
+    name: Type6.Optional(Type6.String({ minLength: 1, maxLength: 255 })),
+    email: Type6.Optional(Type6.String({ format: "email", maxLength: 320 }))
+  },
+  { additionalProperties: false }
+);
+var CustomerRecordSchema = Type6.Object({
+  id: Type6.String({ format: "uuid" }),
+  externalId: Type6.String(),
+  name: Type6.Union([Type6.String(), Type6.Null()]),
+  email: Type6.Union([Type6.String(), Type6.Null()]),
+  createdAt: Type6.String({ format: "date-time" })
+});
+var CustomerListSchema = Type6.Object({ items: Type6.Array(CustomerRecordSchema) });
+function isCustomerList(value) {
+  return Value.Check(CustomerListSchema, value);
+}
+var MeterInputSchema = Type6.Object(
+  {
+    key: Type6.String({ minLength: 1, maxLength: 128, pattern: "^[a-z0-9][a-z0-9._-]*$" }),
+    name: Type6.String({ minLength: 1, maxLength: 120 }),
+    event: Type6.String({ minLength: 1, maxLength: 128 }),
+    aggregation: Type6.Union([Type6.Literal("COUNT"), Type6.Literal("SUM")]),
+    valueProperty: Type6.Optional(
+      Type6.String({ minLength: 3, maxLength: 128, pattern: "^\\$\\.[A-Za-z0-9_-]+$" })
+    ),
+    dimensionKeys: Type6.Optional(
+      Type6.Array(Type6.String({ minLength: 1, maxLength: 64 }), { maxItems: 10, uniqueItems: true })
+    )
+  },
+  { additionalProperties: false }
+);
+var MeterRecordSchema = Type6.Object({
+  id: Type6.String({ format: "uuid" }),
+  key: Type6.String(),
+  name: Type6.String(),
+  event: Type6.String(),
+  aggregation: Type6.String(),
+  valueProperty: Type6.Union([Type6.String(), Type6.Null()]),
+  dimensionKeys: Type6.Array(Type6.String())
+});
+var MeterListSchema = Type6.Object({ items: Type6.Array(MeterRecordSchema) });
+function isMeterList(value) {
+  return Value.Check(MeterListSchema, value);
+}
+var ApiKeyInputSchema = Type6.Object({
+  name: Type6.String({ minLength: 1, maxLength: 120 }),
+  expiresAt: Type6.Optional(Type6.String({ format: "date-time" }))
+});
+var ApiKeyCreatedSchema = Type6.Object({
+  id: Type6.String({ format: "uuid" }),
+  name: Type6.String(),
+  prefix: Type6.String(),
+  token: Type6.String()
+});
+function isApiKeyCreatedResponse(value) {
+  return Value.Check(ApiKeyCreatedSchema, value);
+}
+var ApiKeyRecordSchema = Type6.Object({
+  id: Type6.String({ format: "uuid" }),
+  name: Type6.String(),
+  prefix: Type6.String(),
+  lastUsedAt: Type6.Union([Type6.String({ format: "date-time" }), Type6.Null()]),
+  expiresAt: Type6.Union([Type6.String({ format: "date-time" }), Type6.Null()]),
+  revokedAt: Type6.Union([Type6.String({ format: "date-time" }), Type6.Null()]),
+  createdAt: Type6.String({ format: "date-time" })
+});
+var ApiKeyListSchema = Type6.Object({ items: Type6.Array(ApiKeyRecordSchema) });
+var ApiKeyParamsSchema = Type6.Object({ apiKeyId: Type6.String({ format: "uuid" }) });
+function isApiKeyList(value) {
+  return Value.Check(ApiKeyListSchema, value);
+}
+var OverviewSchema = Type6.Object({
+  customers: Type6.Integer({ minimum: 0 }),
+  eventsToday: Type6.Integer({ minimum: 0 }),
+  credits: Type6.Object({
+    available: Type6.String({ pattern: "^[0-9]+$" }),
+    consumed: Type6.String({ pattern: "^[0-9]+$" }),
+    reserved: Type6.String({ pattern: "^[0-9]+$" }),
+    total: Type6.String({ pattern: "^[0-9]+$" }),
+    utilizationRate: Type6.Union([Type6.Number({ minimum: 0, maximum: 100 }), Type6.Null()])
+  }),
+  setup: Type6.Object({
+    apiKey: Type6.Boolean(),
+    credits: Type6.Boolean(),
+    customer: Type6.Boolean(),
+    feature: Type6.Boolean()
+  }),
+  webhookSuccessRate: Type6.Union([Type6.Number({ minimum: 0, maximum: 100 }), Type6.Null()])
+});
+var AuditLogRecordSchema = Type6.Object({
+  id: Type6.String({ format: "uuid" }),
+  action: Type6.String(),
+  resourceType: Type6.String(),
+  resourceId: Type6.Union([Type6.String(), Type6.Null()]),
+  createdAt: Type6.String({ format: "date-time" })
+});
+var AuditLogListSchema = Type6.Object({ items: Type6.Array(AuditLogRecordSchema) });
+function isAuditLogList(value) {
+  return Value.Check(AuditLogListSchema, value);
+}
+function isOverviewResponse(value) {
+  return Value.Check(OverviewSchema, value);
+}
+
+// src/metering.ts
+import { Type as Type7 } from "@sinclair/typebox";
+var MeterQueryParamsSchema = Type7.Object({
+  meterKey: Type7.String({ minLength: 1, maxLength: 128 })
+});
+var MeterQuerySchema = Type7.Object(
+  {
+    customerId: Type7.String({ minLength: 1, maxLength: 255 }),
+    from: Type7.Optional(Type7.String({ format: "date-time" })),
+    to: Type7.Optional(Type7.String({ format: "date-time" })),
+    limit: Type7.Optional(Type7.Integer({ minimum: 1, maximum: 5e3 }))
+  },
+  { additionalProperties: false }
+);
+var MeterQueryDataPointSchema = Type7.Object({
+  windowStart: Type7.String({ format: "date-time" }),
+  windowEnd: Type7.String({ format: "date-time" }),
+  value: Type7.String(),
+  eventCount: Type7.String({ pattern: "^[0-9]+$" }),
+  dimensions: EventPropertiesSchema
+});
+var MeterQueryResponseSchema = Type7.Object({
+  meter: Type7.Object({
+    key: Type7.String(),
+    name: Type7.String(),
+    aggregation: Type7.Union([Type7.Literal("COUNT"), Type7.Literal("SUM")])
+  }),
+  customerId: Type7.String(),
+  from: Type7.Union([Type7.String({ format: "date-time" }), Type7.Null()]),
+  to: Type7.Union([Type7.String({ format: "date-time" }), Type7.Null()]),
+  value: Type7.String(),
+  eventCount: Type7.String({ pattern: "^[0-9]+$" }),
+  data: Type7.Array(MeterQueryDataPointSchema)
+});
+function isMeterQueryResponse(value) {
+  return Value.Check(MeterQueryResponseSchema, value);
+}
+
+// src/notifications.ts
+import { Type as Type8 } from "@sinclair/typebox";
+var AlertRuleInputSchema = Type8.Object(
+  {
+    name: Type8.String({ minLength: 1, maxLength: 120 }),
+    metric: Type8.Literal("METER_USAGE"),
+    operator: Type8.Union([
+      Type8.Literal("GREATER_THAN"),
+      Type8.Literal("GREATER_THAN_OR_EQUAL"),
+      Type8.Literal("LESS_THAN"),
+      Type8.Literal("LESS_THAN_OR_EQUAL")
+    ]),
+    threshold: Type8.String({ pattern: "^[0-9]+(?:\\.[0-9]+)?$" }),
+    meterId: Type8.Optional(Type8.String({ format: "uuid" }))
+  },
+  { additionalProperties: false }
+);
+var AlertRuleRecordSchema = Type8.Object({
+  id: Type8.String({ format: "uuid" }),
+  name: Type8.String(),
+  metric: Type8.String(),
+  operator: Type8.String(),
+  threshold: Type8.String(),
+  meterId: Type8.Union([Type8.String({ format: "uuid" }), Type8.Null()]),
+  enabled: Type8.Boolean()
+});
+var AlertRuleListSchema = Type8.Object({ items: Type8.Array(AlertRuleRecordSchema) });
+var WebhookEndpointInputSchema = Type8.Object(
+  {
+    name: Type8.String({ minLength: 1, maxLength: 120 }),
+    url: Type8.String({ format: "uri", maxLength: 2048 }),
+    secret: Type8.String({ minLength: 16, maxLength: 255 }),
+    eventTypes: Type8.Array(Type8.String({ minLength: 1, maxLength: 128 }), {
+      minItems: 1,
+      maxItems: 20,
+      uniqueItems: true
+    })
+  },
+  { additionalProperties: false }
+);
+var WebhookEndpointRecordSchema = Type8.Object({
+  id: Type8.String({ format: "uuid" }),
+  name: Type8.String(),
+  url: Type8.String(),
+  eventTypes: Type8.Array(Type8.String()),
+  enabled: Type8.Boolean(),
+  createdAt: Type8.String({ format: "date-time" })
+});
+var WebhookEndpointListSchema = Type8.Object({
+  items: Type8.Array(WebhookEndpointRecordSchema)
+});
+var WebhookDeliveryRecordSchema = Type8.Object({
+  id: Type8.String({ format: "uuid" }),
+  endpointName: Type8.String(),
+  eventType: Type8.String(),
+  status: Type8.Union([
+    Type8.Literal("PENDING"),
+    Type8.Literal("SUCCEEDED"),
+    Type8.Literal("FAILED"),
+    Type8.Literal("DEAD_LETTER")
+  ]),
+  attemptCount: Type8.Integer({ minimum: 0 }),
+  lastStatusCode: Type8.Union([Type8.Integer(), Type8.Null()]),
+  lastError: Type8.Union([Type8.String(), Type8.Null()]),
+  createdAt: Type8.String({ format: "date-time" })
+});
+var WebhookDeliveryListSchema = Type8.Object({
+  items: Type8.Array(WebhookDeliveryRecordSchema)
+});
+var DeliveryParamsSchema = Type8.Object({
+  deliveryId: Type8.String({ format: "uuid" })
+});
+function isWebhookEndpointList(value) {
+  return Value.Check(WebhookEndpointListSchema, value);
+}
+function isWebhookEndpointRecord(value) {
+  return Value.Check(WebhookEndpointRecordSchema, value);
+}
+function isWebhookDeliveryList(value) {
+  return Value.Check(WebhookDeliveryListSchema, value);
+}
+function isAlertRuleList(value) {
+  return Value.Check(AlertRuleListSchema, value);
+}
+function isAlertRuleRecord(value) {
+  return Value.Check(AlertRuleRecordSchema, value);
+}
+
+// src/pricing.ts
+import { Type as Type9 } from "@sinclair/typebox";
+var PriceUnitSchema = Type9.Union([
+  Type9.Literal("INPUT_TOKEN"),
+  Type9.Literal("OUTPUT_TOKEN"),
+  Type9.Literal("CACHED_INPUT_TOKEN"),
+  Type9.Literal("CACHED_OUTPUT_TOKEN"),
+  Type9.Literal("REASONING_TOKEN"),
+  Type9.Literal("REQUEST"),
+  Type9.Literal("TOOL_CALL"),
+  Type9.Literal("RAG_QUERY"),
+  Type9.Literal("SECOND"),
+  Type9.Literal("AUDIO_SECOND"),
+  Type9.Literal("VIDEO_SECOND"),
+  Type9.Literal("IMAGE"),
+  Type9.Literal("CUSTOM")
+]);
+var ModelPriceItemInputSchema = Type9.Object(
+  {
+    unit: PriceUnitSchema,
+    unitSize: Type9.String({ pattern: "^[1-9][0-9]*$" }),
+    priceMinor: Type9.String({ pattern: "^[0-9]+$" })
+  },
+  { additionalProperties: false }
+);
+var ModelPriceInputSchema = Type9.Object(
+  {
+    providerKey: Type9.String({ minLength: 1, maxLength: 64, pattern: "^[a-z0-9][a-z0-9._-]*$" }),
+    providerName: Type9.String({ minLength: 1, maxLength: 120 }),
+    modelKey: Type9.String({ minLength: 1, maxLength: 128 }),
+    modelName: Type9.String({ minLength: 1, maxLength: 160 }),
+    currency: Type9.String({ pattern: "^[A-Z]{3}$" }),
+    validFrom: Type9.String({ format: "date-time" }),
+    items: Type9.Array(ModelPriceItemInputSchema, { minItems: 1, maxItems: 20 })
+  },
+  { additionalProperties: false }
+);
+var ModelPriceRecordSchema = Type9.Object({
+  id: Type9.String({ format: "uuid" }),
+  providerKey: Type9.String(),
+  providerName: Type9.String(),
+  modelKey: Type9.String(),
+  modelName: Type9.String(),
+  version: Type9.Integer({ minimum: 1 }),
+  currency: Type9.String(),
+  validFrom: Type9.String({ format: "date-time" }),
+  validTo: Type9.Union([Type9.String({ format: "date-time" }), Type9.Null()]),
+  items: Type9.Array(ModelPriceItemInputSchema)
+});
+var ModelPriceListSchema = Type9.Object({ items: Type9.Array(ModelPriceRecordSchema) });
+function isModelPriceList(value) {
+  return Value.Check(ModelPriceListSchema, value);
+}
+function isModelPriceRecord(value) {
+  return Value.Check(ModelPriceRecordSchema, value);
+}
+export {
+  AlertRuleInputSchema,
+  AlertRuleListSchema,
+  AlertRuleRecordSchema,
+  ApiErrorSchema,
+  ApiKeyCreatedSchema,
+  ApiKeyInputSchema,
+  ApiKeyListSchema,
+  ApiKeyParamsSchema,
+  ApiKeyRecordSchema,
+  AuditLogListSchema,
+  AuditLogRecordSchema,
+  AuthSessionSchema,
+  CloudEventIngestSchema,
+  CloudEventInputSchema,
+  CommitReservationSchema,
+  CreditAccountListSchema,
+  CreditAccountRecordSchema,
+  CreditBalanceQuerySchema,
+  CreditBalanceSchema,
+  CreditLedgerListSchema,
+  CreditLedgerRecordSchema,
+  CustomerInputSchema,
+  CustomerListSchema,
+  CustomerRecordSchema,
+  DeliveryParamsSchema,
+  EntitlementOverrideInputSchema,
+  EntitlementOverrideRecordSchema,
+  EntitlementQuerySchema,
+  EntitlementResponseSchema,
+  EventPropertiesSchema,
+  FeatureInputSchema,
+  FeatureListSchema,
+  FeatureRecordSchema,
+  GrantCreditsSchema,
+  HealthResponseSchema,
+  LoginSchema,
+  MeterInputSchema,
+  MeterListSchema,
+  MeterQueryDataPointSchema,
+  MeterQueryParamsSchema,
+  MeterQueryResponseSchema,
+  MeterQuerySchema,
+  MeterRecordSchema,
+  ModelPriceInputSchema,
+  ModelPriceItemInputSchema,
+  ModelPriceListSchema,
+  ModelPriceRecordSchema,
+  OverviewSchema,
+  PlanEntitlementInputSchema,
+  PlanInputSchema,
+  PlanListSchema,
+  PlanRecordSchema,
+  PlanVersionParamsSchema,
+  PriceUnitSchema,
+  RefundCreditsSchema,
+  RegisterSchema,
+  ReservationParamsSchema,
+  ReservationResponseSchema,
+  ReserveCreditsSchema,
+  SubscriptionInputSchema,
+  SubscriptionRecordSchema,
+  UsageEventAcceptedSchema,
+  UsageEventBatchAcceptedSchema,
+  UsageEventBatchInputSchema,
+  UsageEventCorrectionInputSchema,
+  UsageEventInputSchema,
+  UsageEventListSchema,
+  UsageEventParamsSchema,
+  UsageEventQuerySchema,
+  UsageEventRecordSchema,
+  WebhookDeliveryListSchema,
+  WebhookDeliveryRecordSchema,
+  WebhookEndpointInputSchema,
+  WebhookEndpointListSchema,
+  WebhookEndpointRecordSchema,
+  isAlertRuleList,
+  isAlertRuleRecord,
+  isApiError,
+  isApiKeyCreatedResponse,
+  isApiKeyList,
+  isAuditLogList,
+  isAuthSessionResponse,
+  isCreditAccountList,
+  isCreditBalanceResponse,
+  isCreditLedgerList,
+  isCustomerList,
+  isEntitlementResponse,
+  isEventProperties,
+  isFeatureList,
+  isFeatureRecord,
+  isHealthResponse,
+  isMeterList,
+  isMeterQueryResponse,
+  isModelPriceList,
+  isModelPriceRecord,
+  isOverviewResponse,
+  isPlanList,
+  isPlanRecord,
+  isReservationResponse,
+  isSubscriptionRecord,
+  isUsageEventAccepted,
+  isUsageEventBatchAccepted,
+  isUsageEventList,
+  isWebhookDeliveryList,
+  isWebhookEndpointList,
+  isWebhookEndpointRecord
+};