@rolino/contracts 0.1.0

package/dist/index.js

@@ -0,0 +1,724 @@
+// src/index.ts
+import { z } from "zod";
+var API_VERSION = "v1";
+var CONTRACT_VERSION = "0.12.0";
+var RequestMetadataSchema = z.object({
+  requestId: z.string().min(1)
+});
+var ApiErrorCodeSchema = z.enum([
+  "AUTH_REQUIRED",
+  "FORBIDDEN",
+  "NOT_FOUND",
+  "FEATURE_DISABLED",
+  "BILLING_REQUIRED",
+  "LIMIT_REACHED",
+  "VALIDATION_ERROR",
+  "CONFLICT",
+  "RATE_LIMITED",
+  "INTERNAL_ERROR"
+]);
+var ApiProblemSchema = z.object({
+  error: z.object({
+    code: ApiErrorCodeSchema,
+    message: z.string().min(1),
+    details: z.record(z.string(), z.unknown()).optional()
+  }),
+  meta: RequestMetadataSchema
+});
+function successEnvelopeSchema(data) {
+  return z.object({
+    data,
+    meta: RequestMetadataSchema
+  });
+}
+var CapabilityIdSchema = z.enum([
+  "identity:read",
+  "projects:read",
+  "projects:write",
+  "posts:read",
+  "posts:write",
+  "posts:schedule",
+  "posts:publish",
+  "integrations:read",
+  "calendar:read"
+]);
+var CapabilitySchema = z.object({
+  id: CapabilityIdSchema,
+  available: z.boolean(),
+  reason: z.enum([
+    "AVAILABLE",
+    "AUTH_REQUIRED",
+    "SCOPE_REQUIRED",
+    "FEATURE_DISABLED"
+  ])
+});
+var ApiMetaSchema = z.object({
+  name: z.literal("Rolino"),
+  serverVersion: z.string().min(1),
+  apiVersion: z.literal(API_VERSION),
+  contractVersion: z.literal(CONTRACT_VERSION),
+  authentication: z.object({
+    browserSession: z.boolean(),
+    cliBrowserAuthorization: z.boolean(),
+    apiKey: z.boolean(),
+    remoteOAuth: z.boolean()
+  }),
+  mcp: z.object({
+    stdio: z.boolean(),
+    streamableHttp: z.boolean(),
+    remoteStatus: z.enum(["AVAILABLE", "AUTH_GATE"])
+  }),
+  capabilities: z.array(CapabilitySchema)
+});
+var ApiMetaResponseSchema = successEnvelopeSchema(ApiMetaSchema);
+var AuthenticationKindSchema = z.enum(["session", "api_key"]);
+var ActorSchema = z.object({
+  user: z.object({
+    id: z.string().min(1),
+    name: z.string(),
+    email: z.string().email()
+  }),
+  organization: z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    role: z.string().min(1)
+  }),
+  authentication: z.object({
+    kind: AuthenticationKindSchema,
+    credentialId: z.string().min(1).nullable()
+  }),
+  capabilities: z.array(CapabilityIdSchema)
+});
+var WhoAmIResponseSchema = successEnvelopeSchema(ActorSchema);
+var Base64UrlSecretSchema = z.string().min(43).max(128).regex(/^[A-Za-z0-9_-]+$/);
+var CLI_BROWSER_AUTHORIZATION_TIMEOUT_MS = 5 * 60 * 1e3;
+var CliAuthorizationExchangeRequestSchema = z.object({
+  code: Base64UrlSecretSchema,
+  codeVerifier: Base64UrlSecretSchema
+});
+var CliAuthorizationCredentialSchema = z.object({
+  token: z.string().min(1),
+  tokenType: z.literal("Bearer"),
+  expiresAt: z.string().datetime(),
+  organization: z.object({
+    id: z.string().min(1),
+    name: z.string().min(1)
+  }),
+  capabilities: z.array(CapabilityIdSchema)
+});
+var CliAuthorizationExchangeResponseSchema = successEnvelopeSchema(
+  CliAuthorizationCredentialSchema
+);
+var CliAuthorizationRevokeDataSchema = z.object({
+  revoked: z.literal(true)
+});
+var CliAuthorizationRevokeResponseSchema = successEnvelopeSchema(
+  CliAuthorizationRevokeDataSchema
+);
+var CapabilitiesDataSchema = z.object({
+  capabilities: z.array(CapabilitySchema)
+});
+var CapabilitiesResponseSchema = successEnvelopeSchema(CapabilitiesDataSchema);
+var ProjectTypeSchema = z.enum([
+  "PRODUCT",
+  "LAUNCH",
+  "EVENT",
+  "CONTENT_SERIES",
+  "CLIENT",
+  "BRAND",
+  "INTERNAL"
+]);
+var ProjectWebsiteUrlSchema = z.string().trim().min(1).max(2e3).url().refine((value) => {
+  try {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password;
+  } catch {
+    return false;
+  }
+}, "websiteUrl must be an absolute http or https URL without credentials");
+var ProjectCreateInputSchema = z.object({
+  name: z.string().trim().min(1).max(100),
+  type: ProjectTypeSchema.default("PRODUCT"),
+  websiteUrl: ProjectWebsiteUrlSchema.optional(),
+  description: z.string().trim().min(1).max(2e3).optional()
+}).strict();
+var ProjectSchema = z.object({
+  id: z.string().min(1),
+  organizationId: z.string().min(1),
+  name: z.string().min(1),
+  slug: z.string().min(1),
+  type: ProjectTypeSchema,
+  status: z.enum(["ACTIVE", "PAUSED", "ARCHIVED"]),
+  websiteUrl: z.string().url().nullable(),
+  description: z.string().nullable(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+var ProjectListQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(50),
+  cursor: z.string().min(1).optional()
+});
+var ProjectListDataSchema = z.object({
+  items: z.array(ProjectSchema),
+  page: z.object({
+    limit: z.number().int().min(1).max(100),
+    nextCursor: z.string().min(1).nullable()
+  })
+});
+var ProjectListResponseSchema = successEnvelopeSchema(ProjectListDataSchema);
+var ProjectResponseSchema = successEnvelopeSchema(ProjectSchema);
+var PostStatusSchema = z.enum([
+  "DRAFT",
+  "SCHEDULED",
+  "ACTION_REQUIRED",
+  "PUBLISHING",
+  "PUBLISHED",
+  "PARTIALLY_PUBLISHED",
+  "FAILED"
+]);
+var PlatformPostStatusSchema = z.enum([
+  "DRAFT",
+  "SCHEDULED",
+  "PREPARING",
+  "ACTION_REQUIRED",
+  "PUBLISHING",
+  "PUBLISHED",
+  "FAILED"
+]);
+var PostMediaSchema = z.object({
+  id: z.string().min(1),
+  type: z.enum(["IMAGE", "VIDEO"]),
+  url: z.string().url(),
+  mimeType: z.string().min(1),
+  width: z.number().int().positive().nullable(),
+  height: z.number().int().positive().nullable(),
+  durationMs: z.number().int().nonnegative().nullable(),
+  thumbnailUrl: z.string().url().nullable(),
+  altText: z.string().nullable(),
+  position: z.number().int().nonnegative()
+});
+var MediaAssetSchema = z.object({
+  id: z.string().min(1),
+  type: z.enum(["IMAGE", "VIDEO"]),
+  url: z.string().url(),
+  thumbnailUrl: z.string().url().nullable(),
+  originalFileName: z.string().nullable(),
+  mimeType: z.string().min(1),
+  sizeBytes: z.number().int().positive().nullable(),
+  width: z.number().int().positive().nullable(),
+  height: z.number().int().positive().nullable(),
+  durationMs: z.number().int().nonnegative().nullable(),
+  createdAt: z.string().datetime()
+});
+var MediaAssetListQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(50),
+  cursor: z.string().min(1).optional(),
+  type: z.enum(["IMAGE", "VIDEO"]).optional(),
+  query: z.string().trim().min(1).max(100).optional()
+});
+var MediaAssetListDataSchema = z.object({
+  items: z.array(MediaAssetSchema),
+  page: z.object({
+    limit: z.number().int().min(1).max(100),
+    nextCursor: z.string().min(1).nullable()
+  })
+});
+var MediaAssetListResponseSchema = successEnvelopeSchema(MediaAssetListDataSchema);
+var MediaAssetUploadInputSchema = z.object({
+  fileName: z.string().trim().min(1).max(255),
+  contentType: z.string().trim().min(1).max(100),
+  fileSize: z.number().int().positive()
+}).strict();
+var MediaAssetUploadPreparationSchema = z.object({
+  uploadUrl: z.string().url(),
+  storageKey: z.string().min(1),
+  expiresAt: z.string().datetime(),
+  headers: z.record(z.string(), z.string()),
+  maxFileSize: z.number().int().positive()
+});
+var MediaAssetUploadPreparationResponseSchema = successEnvelopeSchema(MediaAssetUploadPreparationSchema);
+var MediaAssetUploadCompleteInputSchema = MediaAssetUploadInputSchema.extend({
+  storageKey: z.string().min(1),
+  width: z.number().int().positive().max(1e5).nullable().optional(),
+  height: z.number().int().positive().max(1e5).nullable().optional(),
+  durationMs: z.number().int().nonnegative().max(864e5).nullable().optional()
+}).strict();
+var MediaAssetResponseSchema = successEnvelopeSchema(MediaAssetSchema);
+var PostDestinationSchema = z.object({
+  provider: z.enum(["INSTAGRAM", "TIKTOK", "YOUTUBE", "BLUESKY"]),
+  status: PlatformPostStatusSchema,
+  captionOverride: z.string().nullable(),
+  scheduledAt: z.string().datetime().nullable(),
+  publishedAt: z.string().datetime().nullable(),
+  remoteUrl: z.string().url().nullable(),
+  attemptCount: z.number().int().nonnegative()
+});
+var PublishingProviderSchema = z.enum([
+  "INSTAGRAM",
+  "TIKTOK",
+  "YOUTUBE",
+  "BLUESKY"
+]);
+var PUBLISHING_PROVIDER_COUNT = PublishingProviderSchema.options.length;
+var PostSchema = z.object({
+  id: z.string().min(1),
+  projectId: z.string().min(1),
+  version: z.number().int().positive(),
+  campaign: z.object({
+    id: z.string().min(1),
+    title: z.string().min(1)
+  }).nullable(),
+  caption: z.string(),
+  status: PostStatusSchema,
+  scheduledAt: z.string().datetime().nullable(),
+  timezone: z.string().nullable(),
+  publishedAt: z.string().datetime().nullable(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+  media: z.array(PostMediaSchema),
+  destinations: z.array(PostDestinationSchema)
+});
+var PostListQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(50),
+  cursor: z.string().min(1).optional(),
+  status: PostStatusSchema.optional()
+});
+var PostListDataSchema = z.object({
+  items: z.array(PostSchema),
+  page: z.object({
+    limit: z.number().int().min(1).max(100),
+    nextCursor: z.string().min(1).nullable()
+  })
+});
+var PostListResponseSchema = successEnvelopeSchema(PostListDataSchema);
+var PostResponseSchema = successEnvelopeSchema(PostSchema);
+var TikTokPostSettingsSchema = z.object({
+  postMode: z.enum(["DIRECT_POST", "MEDIA_UPLOAD"]).default("DIRECT_POST"),
+  privacyLevel: z.string().trim().min(1).max(100).nullable().default(null),
+  allowComment: z.boolean().default(false),
+  allowDuet: z.boolean().default(false),
+  allowStitch: z.boolean().default(false),
+  commercialContentEnabled: z.boolean().default(false),
+  promotesOwnBrand: z.boolean().default(false),
+  promotesThirdParty: z.boolean().default(false),
+  isAiGenerated: z.boolean().default(false),
+  videoCoverTimestampMs: z.number().int().nonnegative().nullable().default(null),
+  consentedAt: z.union([z.string().datetime(), z.literal("")]).default("")
+}).strict();
+function youtubeTagLength(tags) {
+  return tags.reduce((total, tag, index) => total + (index ? 1 : 0) + tag.length + (tag.includes(" ") ? 2 : 0), 0);
+}
+var YouTubePostSettingsSchema = z.object({
+  title: z.string().trim().min(1).max(100).refine(
+    (value) => !/[<>]/.test(value),
+    "YouTube titles cannot contain angle brackets."
+  ),
+  categoryId: z.string().trim().regex(/^\d+$/).max(20),
+  privacyStatus: z.enum(["PUBLIC", "UNLISTED", "PRIVATE"]),
+  madeForKids: z.boolean(),
+  containsSyntheticMedia: z.boolean().default(false),
+  notifySubscribers: z.boolean().default(true),
+  tags: z.array(z.string().trim().min(1).max(500)).max(50).refine(
+    (tags) => new Set(tags).size === tags.length,
+    "YouTube tags must be unique."
+  ).refine(
+    (tags) => youtubeTagLength(tags) <= 500,
+    "YouTube tags exceed the 500-character aggregate limit."
+  ).default([])
+}).strict();
+var blueskyGraphemeSegmenter = new Intl.Segmenter("en", {
+  granularity: "grapheme"
+});
+var BlueskyCaptionSchema = z.string().max(3e3).refine(
+  (value) => Array.from(blueskyGraphemeSegmenter.segment(value)).length <= 300,
+  "Bluesky captions cannot exceed 300 graphemes."
+);
+var utf8Encoder = new TextEncoder();
+var YouTubeDescriptionSchema = z.string().max(5e3).refine(
+  (value) => utf8Encoder.encode(value).length <= 5e3,
+  "YouTube descriptions cannot exceed 5,000 UTF-8 bytes."
+);
+var DraftCaptionOverridesSchema = z.object({
+  INSTAGRAM: z.string().max(2200).nullable().optional(),
+  TIKTOK: z.string().max(2200).nullable().optional(),
+  YOUTUBE: YouTubeDescriptionSchema.nullable().optional(),
+  BLUESKY: BlueskyCaptionSchema.nullable().optional()
+}).strict().default({});
+var DraftPostInputSchema = z.object({
+  caption: z.string().max(2200).transform((value) => value.trim()).default(""),
+  platforms: z.array(PublishingProviderSchema).max(PUBLISHING_PROVIDER_COUNT).refine(
+    (providers) => new Set(providers).size === providers.length,
+    "Publishing destinations must be unique."
+  ).default([]),
+  mediaAssetIds: z.array(z.string().trim().min(1).max(200)).max(10).refine(
+    (ids) => new Set(ids).size === ids.length,
+    "Media asset IDs must be unique."
+  ).default([]),
+  captionOverrides: DraftCaptionOverridesSchema,
+  tiktokSettings: TikTokPostSettingsSchema.nullable().default(null),
+  youtubeSettings: YouTubePostSettingsSchema.nullable().default(null)
+}).strict().superRefine((input, context) => {
+  if (input.caption.length === 0 && input.mediaAssetIds.length === 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["caption"],
+      message: "A draft requires a caption or at least one media asset."
+    });
+  }
+  if (input.tiktokSettings && !input.platforms.includes("TIKTOK")) {
+    context.addIssue({
+      code: "custom",
+      path: ["tiktokSettings"],
+      message: "TikTok settings require the TIKTOK destination."
+    });
+  }
+  if (input.youtubeSettings && !input.platforms.includes("YOUTUBE")) {
+    context.addIssue({
+      code: "custom",
+      path: ["youtubeSettings"],
+      message: "YouTube settings require the YOUTUBE destination."
+    });
+  }
+  if (input.platforms.includes("YOUTUBE") && !input.youtubeSettings) {
+    context.addIssue({
+      code: "custom",
+      path: ["youtubeSettings"],
+      message: "YouTube settings are required for the YOUTUBE destination."
+    });
+  }
+  if (input.platforms.includes("YOUTUBE") && input.captionOverrides.YOUTUBE == null && utf8Encoder.encode(input.caption).length > 5e3) {
+    context.addIssue({
+      code: "custom",
+      path: ["caption"],
+      message: "YouTube descriptions cannot exceed 5,000 UTF-8 bytes."
+    });
+  }
+  if (input.platforms.includes("BLUESKY") && input.captionOverrides.BLUESKY == null && Array.from(blueskyGraphemeSegmenter.segment(input.caption)).length > 300) {
+    context.addIssue({
+      code: "custom",
+      path: ["caption"],
+      message: "Bluesky captions cannot exceed 300 graphemes."
+    });
+  }
+});
+var IntegrationConnectionStatusSchema = z.enum([
+  "PENDING",
+  "CONNECTED",
+  "ERROR",
+  "EXPIRED",
+  "DISCONNECTED"
+]);
+var ProviderHealthStatusSchema = z.enum([
+  "pass",
+  "blocking",
+  "unknown"
+]);
+var IntegrationHealthSchema = z.object({
+  provider: PublishingProviderSchema,
+  connectionStatus: IntegrationConnectionStatusSchema,
+  connected: z.boolean(),
+  account: z.object({
+    username: z.string().nullable(),
+    displayName: z.string().nullable(),
+    avatarUrl: z.string().url().nullable()
+  }),
+  grantedScopes: z.array(z.string()),
+  expiresAt: z.string().datetime().nullable(),
+  health: z.object({
+    status: ProviderHealthStatusSchema,
+    checkedAt: z.string().datetime().nullable(),
+    code: z.string().min(1),
+    message: z.string().min(1),
+    isStale: z.boolean(),
+    requiresAction: z.boolean(),
+    refreshRecommended: z.boolean()
+  })
+});
+var IntegrationHealthListDataSchema = z.object({
+  items: z.array(IntegrationHealthSchema).max(PUBLISHING_PROVIDER_COUNT).refine(
+    (items) => new Set(items.map((item) => item.provider)).size === items.length,
+    "Provider health items must be unique."
+  )
+});
+var IntegrationHealthListResponseSchema = successEnvelopeSchema(
+  IntegrationHealthListDataSchema
+);
+var ReadinessStatusSchema = z.enum([
+  "checking",
+  "pass",
+  "warning",
+  "blocking",
+  "unknown"
+]);
+var ReadinessActionSchema = z.object({
+  kind: z.enum([
+    "reconnect",
+    "replace_media",
+    "review_settings",
+    "edit_caption",
+    "refresh_health"
+  ]),
+  provider: PublishingProviderSchema.optional()
+});
+var PostReadinessCheckSchema = z.object({
+  key: z.string().min(1),
+  id: z.enum([
+    "connection",
+    "permissions",
+    "media",
+    "caption",
+    "tiktok_settings",
+    "youtube_settings",
+    "storage",
+    "schedule_lead",
+    "token_health",
+    "media_duration",
+    "provider_health"
+  ]),
+  provider: PublishingProviderSchema.nullable(),
+  mediaId: z.string().min(1).optional(),
+  status: ReadinessStatusSchema,
+  source: z.enum(["local", "live"]),
+  checkedAt: z.string().datetime().nullable(),
+  message: z.string().min(1),
+  code: z.string().min(1),
+  action: ReadinessActionSchema.nullable()
+});
+var PostReadinessSchema = z.object({
+  checks: z.array(PostReadinessCheckSchema),
+  accounts: z.array(z.object({
+    provider: PublishingProviderSchema,
+    connected: z.boolean(),
+    username: z.string().nullable(),
+    avatarUrl: z.string().url().nullable(),
+    requiresAction: z.boolean()
+  })),
+  hasBlockingChecks: z.boolean(),
+  requiresLiveRefresh: z.array(PublishingProviderSchema),
+  liveHealthCheckedAt: z.string().datetime().nullable()
+});
+var PostReadinessResponseSchema = successEnvelopeSchema(
+  PostReadinessSchema
+);
+var PostScheduleInputSchema = z.object({
+  scheduledAt: z.string().datetime({ offset: true }),
+  timezone: z.string().trim().min(1).max(100).refine((timezone) => {
+    try {
+      new Intl.DateTimeFormat("en", { timeZone: timezone }).format();
+      return true;
+    } catch {
+      return false;
+    }
+  }, "timezone must be a valid IANA timezone")
+}).strict();
+var PostScheduleExecuteInputSchema = PostScheduleInputSchema.extend({
+  confirmationToken: z.string().trim().min(1).max(200)
+}).strict();
+var PostSchedulePreviewSchema = z.object({
+  operation: z.literal("posts.schedule.execute"),
+  post: z.object({
+    id: z.string().min(1),
+    projectId: z.string().min(1),
+    version: z.number().int().positive(),
+    status: PostStatusSchema
+  }),
+  schedule: PostScheduleInputSchema,
+  destinations: z.array(PublishingProviderSchema).min(1).max(PUBLISHING_PROVIDER_COUNT),
+  providerReconciliation: z.object({
+    provider: z.literal("YOUTUBE"),
+    required: z.boolean(),
+    message: z.string().min(1)
+  }).nullable().optional(),
+  readiness: PostReadinessSchema,
+  confirmation: z.object({
+    token: z.string().min(1),
+    expiresAt: z.string().datetime()
+  })
+});
+var PostSchedulePreviewResponseSchema = successEnvelopeSchema(
+  PostSchedulePreviewSchema
+);
+var PostSchedulePendingSchema = z.object({
+  status: z.literal("PENDING"),
+  postId: z.string().min(1),
+  provider: z.literal("YOUTUBE"),
+  mutationId: z.string().min(1),
+  operation: z.enum(["SCHEDULE", "CANCEL"]),
+  message: z.string().min(1)
+});
+var PostScheduleExecuteResultSchema = z.union([
+  PostSchema,
+  PostSchedulePendingSchema
+]);
+var PostScheduleExecuteResponseSchema = successEnvelopeSchema(
+  PostScheduleExecuteResultSchema
+);
+var PostPublishInputSchema = z.object({
+  destinations: z.array(PublishingProviderSchema).min(1).max(PUBLISHING_PROVIDER_COUNT).refine(
+    (destinations) => new Set(destinations).size === destinations.length,
+    "destinations must not contain duplicates"
+  )
+}).strict();
+var PostPublishExecuteInputSchema = PostPublishInputSchema.extend({
+  confirmationToken: z.string().trim().min(1).max(200)
+}).strict();
+var PostPublishPreviewSchema = z.object({
+  operation: z.literal("posts.publish.execute"),
+  post: z.object({
+    id: z.string().min(1),
+    projectId: z.string().min(1),
+    version: z.number().int().positive(),
+    status: PostStatusSchema
+  }),
+  destinations: PostPublishInputSchema.shape.destinations,
+  readiness: PostReadinessSchema,
+  confirmation: z.object({
+    token: z.string().min(1),
+    expiresAt: z.string().datetime()
+  })
+});
+var PostPublishPreviewResponseSchema = successEnvelopeSchema(
+  PostPublishPreviewSchema
+);
+var CalendarEventSchema = z.object({
+  postId: z.string().min(1),
+  projectId: z.string().min(1),
+  title: z.string().min(1),
+  caption: z.string(),
+  status: PostStatusSchema.exclude(["DRAFT"]),
+  scheduledAt: z.string().datetime(),
+  timezone: z.string().nullable(),
+  campaign: z.object({
+    id: z.string().min(1),
+    title: z.string().min(1)
+  }).nullable(),
+  thumbnailUrl: z.string().url().nullable(),
+  destinations: z.array(z.object({
+    provider: PublishingProviderSchema,
+    status: PlatformPostStatusSchema
+  }))
+});
+var CalendarListQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(50),
+  cursor: z.string().min(1).optional(),
+  from: z.string().datetime().optional(),
+  to: z.string().datetime().optional()
+}).superRefine((value, context) => {
+  if (value.from === void 0 !== (value.to === void 0)) {
+    context.addIssue({
+      code: "custom",
+      path: value.from === void 0 ? ["from"] : ["to"],
+      message: "from and to must be provided together"
+    });
+  }
+  if (value.from && value.to) {
+    const from = Date.parse(value.from);
+    const to = Date.parse(value.to);
+    if (from >= to) {
+      context.addIssue({
+        code: "custom",
+        path: ["to"],
+        message: "to must be later than from"
+      });
+    } else if (to - from > 366 * 24 * 60 * 60 * 1e3) {
+      context.addIssue({
+        code: "custom",
+        path: ["to"],
+        message: "calendar ranges cannot exceed 366 days"
+      });
+    }
+  }
+});
+var CalendarListDataSchema = z.object({
+  items: z.array(CalendarEventSchema),
+  page: z.object({
+    limit: z.number().int().min(1).max(100),
+    nextCursor: z.string().min(1).nullable()
+  }),
+  window: z.object({
+    from: z.string().datetime(),
+    to: z.string().datetime()
+  })
+});
+var CalendarListResponseSchema = successEnvelopeSchema(
+  CalendarListDataSchema
+);
+export {
+  API_VERSION,
+  ActorSchema,
+  ApiErrorCodeSchema,
+  ApiMetaResponseSchema,
+  ApiMetaSchema,
+  ApiProblemSchema,
+  AuthenticationKindSchema,
+  CLI_BROWSER_AUTHORIZATION_TIMEOUT_MS,
+  CONTRACT_VERSION,
+  CalendarEventSchema,
+  CalendarListDataSchema,
+  CalendarListQuerySchema,
+  CalendarListResponseSchema,
+  CapabilitiesDataSchema,
+  CapabilitiesResponseSchema,
+  CapabilityIdSchema,
+  CapabilitySchema,
+  CliAuthorizationCredentialSchema,
+  CliAuthorizationExchangeRequestSchema,
+  CliAuthorizationExchangeResponseSchema,
+  CliAuthorizationRevokeDataSchema,
+  CliAuthorizationRevokeResponseSchema,
+  DraftPostInputSchema,
+  IntegrationConnectionStatusSchema,
+  IntegrationHealthListDataSchema,
+  IntegrationHealthListResponseSchema,
+  IntegrationHealthSchema,
+  MediaAssetListDataSchema,
+  MediaAssetListQuerySchema,
+  MediaAssetListResponseSchema,
+  MediaAssetResponseSchema,
+  MediaAssetSchema,
+  MediaAssetUploadCompleteInputSchema,
+  MediaAssetUploadInputSchema,
+  MediaAssetUploadPreparationResponseSchema,
+  MediaAssetUploadPreparationSchema,
+  PUBLISHING_PROVIDER_COUNT,
+  PlatformPostStatusSchema,
+  PostDestinationSchema,
+  PostListDataSchema,
+  PostListQuerySchema,
+  PostListResponseSchema,
+  PostMediaSchema,
+  PostPublishExecuteInputSchema,
+  PostPublishInputSchema,
+  PostPublishPreviewResponseSchema,
+  PostPublishPreviewSchema,
+  PostReadinessCheckSchema,
+  PostReadinessResponseSchema,
+  PostReadinessSchema,
+  PostResponseSchema,
+  PostScheduleExecuteInputSchema,
+  PostScheduleExecuteResponseSchema,
+  PostScheduleExecuteResultSchema,
+  PostScheduleInputSchema,
+  PostSchedulePendingSchema,
+  PostSchedulePreviewResponseSchema,
+  PostSchedulePreviewSchema,
+  PostSchema,
+  PostStatusSchema,
+  ProjectCreateInputSchema,
+  ProjectListDataSchema,
+  ProjectListQuerySchema,
+  ProjectListResponseSchema,
+  ProjectResponseSchema,
+  ProjectSchema,
+  ProjectTypeSchema,
+  ProviderHealthStatusSchema,
+  PublishingProviderSchema,
+  ReadinessActionSchema,
+  ReadinessStatusSchema,
+  RequestMetadataSchema,
+  TikTokPostSettingsSchema,
+  WhoAmIResponseSchema,
+  YouTubePostSettingsSchema,
+  successEnvelopeSchema
+};
+//# sourceMappingURL=index.js.map