@zapier/youtube-connector 0.0.0 → 0.0.1

package/dist/index.js

@@ -0,0 +1,1550 @@
+// index.ts
+import { defineConnector, toFunctions } from "@zapier/connectors-sdk";
+
+// connections.ts
+import {
+  defineEnvTokenResolver,
+  zapierConnectionResolver
+} from "@zapier/connectors-sdk";
+var connectionResolvers = {
+  youtube: [zapierConnectionResolver, defineEnvTokenResolver()]
+};
+
+// scripts/addVideoToPlaylist.ts
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z as z2 } from "zod";
+
+// lib/youtube.ts
+import { ConnectorHttpError } from "@zapier/connectors-sdk";
+import { z } from "zod";
+var ThumbnailsSchema = z.record(
+  z.string(),
+  z.object({
+    url: z.string().optional(),
+    width: z.number().int().optional(),
+    height: z.number().int().optional()
+  })
+).describe("Thumbnail images keyed by size (default, medium, high, ...).");
+var ResourceIdSchema = z.object({
+  kind: z.string().describe(
+    "The referenced resource type, e.g. youtube#video or youtube#channel."
+  ).optional(),
+  videoId: z.string().describe("Set when kind is youtube#video.").optional(),
+  channelId: z.string().describe("Set when kind is youtube#channel.").optional()
+});
+var NextPageToken = z.string().describe("Cursor for the next page; absent when there are no more results.").nullable().optional();
+var VideoSchema = z.object({
+  id: z.string().describe("The 11-char video id."),
+  snippet: z.object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+    channelId: z.string().optional(),
+    channelTitle: z.string().optional(),
+    publishedAt: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    categoryId: z.string().optional(),
+    defaultLanguage: z.string().optional(),
+    defaultAudioLanguage: z.string().optional(),
+    liveBroadcastContent: z.string().optional(),
+    thumbnails: ThumbnailsSchema.optional()
+  }).optional(),
+  contentDetails: z.object({
+    duration: z.string().describe("ISO 8601 duration, e.g. PT4M13S (4 min 13 s).").optional(),
+    definition: z.string().describe("hd or sd.").optional(),
+    caption: z.string().describe(
+      '"true" or "false" (string) \u2014 whether captions are available.'
+    ).optional(),
+    licensedContent: z.boolean().optional()
+  }).optional(),
+  statistics: z.object({
+    // Counts are returned as strings; likeCount/commentCount are absent when hidden.
+    viewCount: z.string().optional(),
+    likeCount: z.string().optional(),
+    commentCount: z.string().optional(),
+    favoriteCount: z.string().optional()
+  }).optional(),
+  status: z.object({
+    uploadStatus: z.string().describe("uploaded, processed, failed, rejected, or deleted.").optional(),
+    privacyStatus: z.string().describe("public, unlisted, or private.").optional(),
+    publishAt: z.string().describe("Scheduled publish time, if a private scheduled upload.").optional(),
+    madeForKids: z.boolean().optional(),
+    license: z.string().optional()
+  }).optional()
+}).describe("A YouTube video resource.");
+var PlaylistSchema = z.object({
+  id: z.string().describe(
+    "The playlist id (PL...). Use with addVideoToPlaylist / listPlaylistItems."
+  ),
+  snippet: z.object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+    channelId: z.string().optional(),
+    channelTitle: z.string().optional(),
+    publishedAt: z.string().optional(),
+    thumbnails: ThumbnailsSchema.optional()
+  }).optional(),
+  status: z.object({
+    privacyStatus: z.string().optional()
+  }).optional(),
+  contentDetails: z.object({
+    itemCount: z.number().int().describe("Number of videos in the playlist.").optional()
+  }).optional()
+}).describe("A YouTube playlist resource.");
+var PlaylistItemSchema = z.object({
+  id: z.string().describe(
+    "The playlistItem id (use with removeVideoFromPlaylist \u2014 distinct from the video id)."
+  ),
+  snippet: z.object({
+    playlistId: z.string().optional(),
+    position: z.number().int().optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    channelId: z.string().optional(),
+    channelTitle: z.string().optional(),
+    publishedAt: z.string().optional(),
+    resourceId: ResourceIdSchema.optional(),
+    thumbnails: ThumbnailsSchema.optional()
+  }).optional(),
+  contentDetails: z.object({
+    videoId: z.string().optional(),
+    videoPublishedAt: z.string().optional()
+  }).optional(),
+  status: z.object({
+    privacyStatus: z.string().optional()
+  }).optional()
+}).describe("A video entry within a playlist.");
+var CommentSchema = z.object({
+  id: z.string().describe("The comment id."),
+  snippet: z.object({
+    textDisplay: z.string().describe("The comment text as HTML (may contain links/formatting).").optional(),
+    textOriginal: z.string().describe("The raw comment text as written.").optional(),
+    authorDisplayName: z.string().optional(),
+    authorChannelId: z.object({ value: z.string().optional() }).optional(),
+    likeCount: z.number().int().optional(),
+    publishedAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+    parentId: z.string().describe(
+      "For a reply, the id of the top-level comment it replies to."
+    ).optional()
+  }).optional()
+}).describe("A YouTube comment.");
+var CommentThreadSchema = z.object({
+  id: z.string().describe("The comment thread id (use as parentId for replyToComment)."),
+  snippet: z.object({
+    videoId: z.string().optional(),
+    totalReplyCount: z.number().int().optional(),
+    isPublic: z.boolean().optional(),
+    topLevelComment: CommentSchema.optional()
+  }).optional(),
+  replies: z.object({
+    comments: z.array(CommentSchema).optional()
+  }).describe(
+    "A sample of replies (not exhaustive \u2014 page more via listComments)."
+  ).optional()
+}).describe("A top-level comment thread on a video.");
+var ChannelSchema = z.object({
+  id: z.string().describe("The channel id (UC...)."),
+  snippet: z.object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+    customUrl: z.string().describe("The channel's @handle / custom URL.").optional(),
+    publishedAt: z.string().optional(),
+    country: z.string().optional(),
+    thumbnails: ThumbnailsSchema.optional()
+  }).optional(),
+  contentDetails: z.object({
+    relatedPlaylists: z.object({
+      uploads: z.string().describe(
+        "The channel's uploads playlist id \u2014 pass to listPlaylistItems to list the channel's videos."
+      ).optional(),
+      likes: z.string().optional()
+    }).optional()
+  }).optional(),
+  statistics: z.object({
+    // Counts returned as strings; subscriberCount is suppressed when hiddenSubscriberCount is true.
+    viewCount: z.string().optional(),
+    subscriberCount: z.string().optional(),
+    hiddenSubscriberCount: z.boolean().optional(),
+    videoCount: z.string().optional()
+  }).optional()
+}).describe("A YouTube channel resource.");
+var VideoCategorySchema = z.object({
+  id: z.string().describe("The category id to pass as categoryId on a video."),
+  snippet: z.object({
+    title: z.string().optional(),
+    assignable: z.boolean().describe(
+      "Whether the category can be assigned to a video. Only assignable categories are usable."
+    ).optional()
+  }).optional()
+}).describe("An assignable video category.");
+var SubscriptionSchema = z.object({
+  id: z.string().describe(
+    "The subscription id (use with unsubscribeFromChannel \u2014 distinct from the channel id)."
+  ),
+  snippet: z.object({
+    title: z.string().describe("The subscribed channel's title.").optional(),
+    description: z.string().optional(),
+    publishedAt: z.string().optional(),
+    resourceId: ResourceIdSchema.optional(),
+    thumbnails: ThumbnailsSchema.optional()
+  }).optional(),
+  contentDetails: z.object({
+    totalItemCount: z.number().int().optional(),
+    newItemCount: z.number().int().optional()
+  }).optional()
+}).describe("A channel subscription.");
+var CaptionSchema = z.object({
+  id: z.string().describe("The caption track id (use with downloadCaption)."),
+  snippet: z.object({
+    videoId: z.string().optional(),
+    language: z.string().describe("BCP-47 language code of the track, e.g. en.").optional(),
+    name: z.string().describe("The track name/label.").optional(),
+    trackKind: z.string().describe("standard, ASR (auto-generated), or forced.").optional(),
+    status: z.string().describe("serving, syncing, or failed.").optional(),
+    isAutoSynced: z.boolean().optional(),
+    lastUpdated: z.string().optional()
+  }).optional()
+}).describe("A caption track on a video.");
+var SearchResultSchema = z.object({
+  id: z.object({
+    kind: z.string().optional(),
+    videoId: z.string().optional(),
+    channelId: z.string().optional(),
+    playlistId: z.string().optional()
+  }).describe("The matched resource id; id.videoId is the video.").optional(),
+  snippet: z.object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+    channelId: z.string().optional(),
+    channelTitle: z.string().optional(),
+    publishedAt: z.string().optional(),
+    liveBroadcastContent: z.string().describe("none, upcoming, or live.").optional(),
+    thumbnails: ThumbnailsSchema.optional()
+  }).optional()
+}).describe("A lightweight search hit (id + snippet only).");
+var SuccessResultSchema = z.object({ success: z.literal(true) }).describe(
+  "Result for an operation with an empty API body (delete/rate/unsubscribe). success is synthesized."
+);
+var QUOTA_REASONS = /* @__PURE__ */ new Set(["quotaExceeded", "dailyLimitExceeded"]);
+var RATE_LIMIT_REASONS = /* @__PURE__ */ new Set([
+  "rateLimitExceeded",
+  "userRateLimitExceeded",
+  "servingLimitExceeded"
+]);
+async function readBody(res) {
+  let text;
+  try {
+    text = await res.text();
+  } catch {
+    return void 0;
+  }
+  if (text === "") return "";
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+async function throwForYouTube(res, toolName) {
+  if (res.ok) return res;
+  const body = await readBody(res);
+  const err = body?.error;
+  const reason = err?.errors?.[0]?.reason;
+  const apiMessage = err?.message;
+  const prefix = `YouTube ${toolName} ${res.status}`;
+  let message;
+  if (res.status === 401) {
+    message = `${prefix}: invalid or expired credentials. Reconnect YouTube.`;
+  } else if (res.status === 403 && reason && QUOTA_REASONS.has(reason)) {
+    message = `${prefix}: ${reason} \u2014 the daily YouTube API quota is exhausted (no Retry-After is sent; the quota resets once per day). Do not retry today; stop and report the quota limit.`;
+  } else if (res.status === 429 || res.status === 403 && reason && RATE_LIMIT_REASONS.has(reason)) {
+    message = `${prefix}: ${reason ?? "rateLimitExceeded"} \u2014 short-term rate limit. Back off and retry with jitter.`;
+  } else if (res.status === 403 && reason === "insufficientPermissions") {
+    message = `${prefix}: insufficientPermissions \u2014 the connection's OAuth scope is too narrow. Reconnect YouTube with the access this tool needs (comment and caption operations require the youtube.force-ssl scope).`;
+  } else if (res.status === 403) {
+    message = `${prefix}: ${reason ?? "forbidden"} \u2014 ${apiMessage ?? "access denied"}. This is either a missing OAuth scope (reconnect YouTube with the needed access \u2014 comment/caption writes need youtube.force-ssl) or you do not own this resource (reconnecting won't help; you can only modify videos, playlists, and subscriptions you own).`;
+  } else if (res.status === 404) {
+    message = `${prefix}: ${reason ?? "notFound"} \u2014 ${apiMessage ?? "the resource does not exist"}. Verify the id (resolve channels via getChannel, playlists via listPlaylists, videos via searchVideos/getVideo).`;
+  } else {
+    message = `${prefix}: ${apiMessage ?? reason ?? "request failed"}`;
+  }
+  throw ConnectorHttpError.fromResponseBody(res, body, { message });
+}
+function hasYouTubeReason(body, reason) {
+  const err = body?.error;
+  return err?.errors?.some((e) => e.reason === reason) ?? false;
+}
+
+// scripts/addVideoToPlaylist.ts
+var inputSchema = z2.object({
+  snippet: z2.object({
+    playlistId: z2.string().describe(
+      "The id of the playlist to add the video to (from listPlaylists; you must own it)."
+    ),
+    resourceId: z2.object({
+      kind: z2.string().describe("Always youtube#video for adding a video.").default("youtube#video"),
+      videoId: z2.string().describe("The 11-char id of the video to add.")
+    }).strict().describe(
+      "The video to add. Set kind to youtube#video and videoId to the 11-char video id."
+    ),
+    position: z2.number().int().describe("0-based insert position. Omit to append at the end.").optional()
+  }).strict(),
+  part: z2.string().describe("Resource parts being written. Leave as the default.").default("snippet")
+}).strict();
+var outputSchema = PlaylistItemSchema;
+var definition = defineTool({
+  name: "addVideoToPlaylist",
+  title: "Add Video To Playlist",
+  description: "Add a video to a playlist owned by the authenticated user. Resolve the playlist id via listPlaylists. Returns the new playlistItem id (distinct from the video id \u2014 use it with removeVideoFromPlaylist).",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/playlistItems`);
+    url.searchParams.set("part", input.part);
+    const res = await ctx.fetch(url.toString(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ snippet: input.snippet })
+    });
+    await throwForYouTube(res, "addVideoToPlaylist");
+    return res.json();
+  }
+});
+var addVideoToPlaylist_default = definition;
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });
+
+// scripts/createPlaylist.ts
+import { defineTool as defineTool2, handleIfScriptMain as handleIfScriptMain2 } from "@zapier/connectors-sdk";
+import { z as z3 } from "zod";
+var inputSchema2 = z3.object({
+  snippet: z3.object({
+    title: z3.string().describe("Playlist title (required)."),
+    description: z3.string().describe("Playlist description.").optional(),
+    defaultLanguage: z3.string().describe(
+      "BCP-47 language code of the title/description text, e.g. en."
+    ).optional()
+  }).strict(),
+  status: z3.object({
+    privacyStatus: z3.enum(["public", "unlisted", "private"]).describe("Playlist visibility. Defaults to private if omitted.").optional()
+  }).strict().optional(),
+  part: z3.string().describe("Resource parts being written. Leave as the default.").default("snippet,status")
+}).strict();
+var outputSchema2 = PlaylistSchema;
+var definition2 = defineTool2({
+  name: "createPlaylist",
+  title: "Create Playlist",
+  description: "Create a new playlist on the authenticated user's channel. Returns the new playlist id for addVideoToPlaylist.",
+  inputSchema: inputSchema2,
+  outputSchema: outputSchema2,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/playlists`);
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    const body = {};
+    if (input.snippet !== void 0) body["snippet"] = input.snippet;
+    if (input.status !== void 0) body["status"] = input.status;
+    const res = await ctx.fetch(url.toString(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    await throwForYouTube(res, "createPlaylist");
+    return res.json();
+  }
+});
+var createPlaylist_default = definition2;
+await handleIfScriptMain2(import.meta, definition2, { connectionResolvers });
+
+// scripts/deletePlaylist.ts
+import { defineTool as defineTool3, handleIfScriptMain as handleIfScriptMain3 } from "@zapier/connectors-sdk";
+import { z as z4 } from "zod";
+var inputSchema3 = z4.object({
+  id: z4.string().describe("The id of the playlist to delete (from listPlaylists).")
+}).strict();
+var outputSchema3 = SuccessResultSchema;
+var definition3 = defineTool3({
+  name: "deletePlaylist",
+  title: "Delete Playlist",
+  description: "Permanently delete a playlist owned by the authenticated user. Irreversible.",
+  inputSchema: inputSchema3,
+  outputSchema: outputSchema3,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/playlists`);
+    if (input.id !== void 0) {
+      url.searchParams.set("id", String(input.id));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "DELETE"
+    });
+    await throwForYouTube(res, "deletePlaylist");
+    return { success: true };
+  }
+});
+var deletePlaylist_default = definition3;
+await handleIfScriptMain3(import.meta, definition3, { connectionResolvers });
+
+// scripts/deleteVideo.ts
+import { defineTool as defineTool4, handleIfScriptMain as handleIfScriptMain4 } from "@zapier/connectors-sdk";
+import { z as z5 } from "zod";
+var inputSchema4 = z5.object({ id: z5.string().describe("The id of the video to delete.") }).strict();
+var outputSchema4 = SuccessResultSchema;
+var definition4 = defineTool4({
+  name: "deleteVideo",
+  title: "Delete Video",
+  description: "Permanently delete a video from the authenticated user's channel. Irreversible. The caller must own the video.",
+  inputSchema: inputSchema4,
+  outputSchema: outputSchema4,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/videos`);
+    if (input.id !== void 0) {
+      url.searchParams.set("id", String(input.id));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "DELETE"
+    });
+    await throwForYouTube(res, "deleteVideo");
+    return { success: true };
+  }
+});
+var deleteVideo_default = definition4;
+await handleIfScriptMain4(import.meta, definition4, { connectionResolvers });
+
+// scripts/downloadCaption.ts
+import { defineTool as defineTool5, handleIfScriptMain as handleIfScriptMain5 } from "@zapier/connectors-sdk";
+import { z as z6 } from "zod";
+var inputSchema5 = z6.object({
+  id: z6.string().describe("The caption track id to download (from listCaptions)."),
+  tfmt: z6.enum(["srt", "vtt", "sbv", "scc", "ttml"]).describe("Output caption format. Defaults to srt.").default("srt"),
+  tlang: z6.string().describe(
+    "Optional BCP-47 language code (e.g. es) to request a machine translation of the track."
+  ).optional()
+}).strict();
+var outputSchema5 = z6.object({
+  caption_text: z6.string().describe("The caption track text in the requested format."),
+  format: z6.string().describe("The format the text was returned in.")
+});
+var definition5 = defineTool5({
+  name: "downloadCaption",
+  title: "Download Caption",
+  description: "Download a caption track's text in a chosen format (srt, vtt, sbv, scc, or ttml). Resolve the track id via listCaptions. Requires permission to edit the video (the owner or an editor) and the youtube.force-ssl scope.",
+  inputSchema: inputSchema5,
+  outputSchema: outputSchema5,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(
+      `https://www.googleapis.com/youtube/v3/captions/${encodeURIComponent(input.id)}`
+    );
+    url.searchParams.set("tfmt", input.tfmt);
+    if (input.tlang !== void 0) url.searchParams.set("tlang", input.tlang);
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    await throwForYouTube(res, "downloadCaption");
+    const caption_text = await res.text();
+    return { caption_text, format: input.tfmt };
+  }
+});
+var downloadCaption_default = definition5;
+await handleIfScriptMain5(import.meta, definition5, { connectionResolvers });
+
+// scripts/getChannel.ts
+import { defineTool as defineTool6, handleIfScriptMain as handleIfScriptMain6 } from "@zapier/connectors-sdk";
+import { z as z7 } from "zod";
+var inputSchema6 = z7.object({
+  part: z7.string().describe("Resource parts to return. Leave as the default.").default("snippet,contentDetails,statistics,brandingSettings"),
+  mine: z7.boolean().describe(
+    "Return the authenticated user's own channel(s). Use this to discover the caller's channel id and uploads playlist."
+  ).optional(),
+  id: z7.string().describe("Look up channel(s) by id (UC..., comma-separated, max 50).").optional(),
+  forHandle: z7.string().describe(
+    "Look up a channel by its @handle, e.g. @MrBeast (with or without the leading @). Mutually exclusive with mine and id."
+  ).optional()
+}).strict().refine(
+  (v) => [v.mine, v.id, v.forHandle].filter((x) => x !== void 0).length <= 1,
+  {
+    message: "Provide only one of mine, id, or forHandle (they are mutually exclusive)."
+  }
+);
+var outputSchema6 = z7.object({
+  items: z7.array(ChannelSchema).describe("The requested channels.")
+});
+var definition6 = defineTool6({
+  name: "getChannel",
+  title: "Get Channel",
+  description: "Get a channel's profile, statistics, and uploads-playlist id. Pass mine=true for the authenticated user's channel, or a channel id / handle to look up another. The resolver for channelId and for a channel's uploads playlist.",
+  inputSchema: inputSchema6,
+  outputSchema: outputSchema6,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/channels`);
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    if (input.mine !== void 0) {
+      url.searchParams.set("mine", String(input.mine));
+    }
+    if (input.id !== void 0) {
+      url.searchParams.set("id", String(input.id));
+    }
+    if (input.forHandle !== void 0) {
+      url.searchParams.set("forHandle", String(input.forHandle));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET"
+    });
+    await throwForYouTube(res, "getChannel");
+    const payload = await res.json();
+    return { items: payload.items ?? [] };
+  }
+});
+var getChannel_default = definition6;
+await handleIfScriptMain6(import.meta, definition6, { connectionResolvers });
+
+// scripts/getVideo.ts
+import { defineTool as defineTool7, handleIfScriptMain as handleIfScriptMain7 } from "@zapier/connectors-sdk";
+import { z as z8 } from "zod";
+var inputSchema7 = z8.object({
+  part: z8.string().describe("Resource parts to return. Leave as the default.").default("snippet,contentDetails,statistics,status"),
+  id: z8.string().describe(
+    "One video id or a comma-separated list (max 50), e.g. dQw4w9WgXcQ. The 11-char id from a watch URL or searchVideos."
+  ),
+  maxResults: z8.number().int().gte(1).lte(50).describe(
+    "Max results per page when listing many ids. Defaults to 10 when omitted; pass a value when you need a specific number of results."
+  ).optional()
+}).strict();
+var outputSchema7 = z8.object({
+  items: z8.array(VideoSchema).describe("The requested videos."),
+  next_page_token: NextPageToken
+});
+var definition7 = defineTool7({
+  name: "getVideo",
+  title: "Get Video",
+  description: "Get full details of one or more videos by id \u2014 snippet (title, description, tags, category), statistics (view/like/comment counts), contentDetails (ISO-8601 duration), and status (privacy, upload state). Counts come back as strings; like/comment counts are absent when the owner hides them. Resolve ids via searchVideos or a watch URL.",
+  inputSchema: inputSchema7,
+  outputSchema: outputSchema7,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/videos`);
+    url.searchParams.set("part", input.part);
+    url.searchParams.set("id", input.id);
+    url.searchParams.set("maxResults", String(input.maxResults ?? 10));
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    await throwForYouTube(res, "getVideo");
+    const payload = await res.json();
+    return {
+      items: payload.items ?? [],
+      next_page_token: payload.nextPageToken
+    };
+  }
+});
+var getVideo_default = definition7;
+await handleIfScriptMain7(import.meta, definition7, { connectionResolvers });
+
+// scripts/listCaptions.ts
+import { defineTool as defineTool8, handleIfScriptMain as handleIfScriptMain8 } from "@zapier/connectors-sdk";
+import { z as z9 } from "zod";
+var inputSchema8 = z9.object({
+  part: z9.string().describe("Resource parts to return. Leave as the default.").default("snippet"),
+  videoId: z9.string().describe("The video id whose caption tracks to list.")
+}).strict();
+var outputSchema8 = z9.object({
+  items: z9.array(CaptionSchema).describe("The caption tracks for the video.")
+});
+var definition8 = defineTool8({
+  name: "listCaptions",
+  title: "List Captions",
+  description: "List the caption tracks available for a video (id, language, name, type, status). Use the track id with downloadCaption to fetch the text. Requires the youtube.force-ssl scope.",
+  inputSchema: inputSchema8,
+  outputSchema: outputSchema8,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/captions`);
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    if (input.videoId !== void 0) {
+      url.searchParams.set("videoId", String(input.videoId));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET"
+    });
+    await throwForYouTube(res, "listCaptions");
+    const payload = await res.json();
+    return { items: payload.items ?? [] };
+  }
+});
+var listCaptions_default = definition8;
+await handleIfScriptMain8(import.meta, definition8, { connectionResolvers });
+
+// scripts/listComments.ts
+import { defineTool as defineTool9, handleIfScriptMain as handleIfScriptMain9 } from "@zapier/connectors-sdk";
+import { z as z10 } from "zod";
+var inputSchema9 = z10.object({
+  part: z10.string().describe("Resource parts to return. Leave as the default.").default("snippet,replies"),
+  videoId: z10.string().describe("The video id whose comment threads to list."),
+  order: z10.enum(["time", "relevance"]).describe("time = newest first; relevance = YouTube's relevance ranking.").default("time"),
+  searchTerms: z10.string().describe("Only return comment threads matching this text.").optional(),
+  maxResults: z10.number().int().gte(1).lte(100).describe(
+    "Max threads per page (1-100). Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  pageToken: z10.string().describe(
+    "Page cursor from a previous response's next_page_token. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema9 = z10.object({
+  items: z10.array(CommentThreadSchema).describe("The comment threads."),
+  next_page_token: NextPageToken
+});
+var definition9 = defineTool9({
+  name: "listComments",
+  title: "List Comments",
+  description: "List top-level comment threads on a video (each with its first replies). Use to read what viewers commented. Resolve videoId via searchVideos/getVideo.",
+  inputSchema: inputSchema9,
+  outputSchema: outputSchema9,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/commentThreads`);
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    if (input.videoId !== void 0) {
+      url.searchParams.set("videoId", String(input.videoId));
+    }
+    if (input.order !== void 0) {
+      url.searchParams.set("order", String(input.order));
+    }
+    if (input.searchTerms !== void 0) {
+      url.searchParams.set("searchTerms", String(input.searchTerms));
+    }
+    url.searchParams.set("maxResults", String(input.maxResults ?? 20));
+    if (input.pageToken !== void 0) {
+      url.searchParams.set("pageToken", String(input.pageToken));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET"
+    });
+    await throwForYouTube(res, "listComments");
+    const payload = await res.json();
+    return {
+      items: payload.items ?? [],
+      next_page_token: payload.nextPageToken
+    };
+  }
+});
+var listComments_default = definition9;
+await handleIfScriptMain9(import.meta, definition9, { connectionResolvers });
+
+// scripts/listPlaylistItems.ts
+import { defineTool as defineTool10, handleIfScriptMain as handleIfScriptMain10 } from "@zapier/connectors-sdk";
+import { z as z11 } from "zod";
+var inputSchema10 = z11.object({
+  part: z11.string().describe("Resource parts to return. Leave as the default.").default("snippet,contentDetails,status"),
+  playlistId: z11.string().describe(
+    "The playlist id whose items to list (from listPlaylists). For a channel's uploads, use the uploads playlist id from getChannel."
+  ),
+  maxResults: z11.number().int().gte(1).lte(50).describe(
+    "Max items per page (1-50). Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  pageToken: z11.string().describe(
+    "Page cursor from a previous response's next_page_token. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema10 = z11.object({
+  items: z11.array(PlaylistItemSchema).describe("The videos in the playlist, in order."),
+  next_page_token: NextPageToken
+});
+var definition10 = defineTool10({
+  name: "listPlaylistItems",
+  title: "List Playlist Items",
+  description: "List the videos in a playlist, in playlist order. Each item carries its own playlistItem id (needed by removeVideoFromPlaylist) plus the video id and snippet.",
+  inputSchema: inputSchema10,
+  outputSchema: outputSchema10,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/playlistItems`);
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    if (input.playlistId !== void 0) {
+      url.searchParams.set("playlistId", String(input.playlistId));
+    }
+    url.searchParams.set("maxResults", String(input.maxResults ?? 20));
+    if (input.pageToken !== void 0) {
+      url.searchParams.set("pageToken", String(input.pageToken));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET"
+    });
+    await throwForYouTube(res, "listPlaylistItems");
+    const payload = await res.json();
+    return {
+      items: payload.items ?? [],
+      next_page_token: payload.nextPageToken
+    };
+  }
+});
+var listPlaylistItems_default = definition10;
+await handleIfScriptMain10(import.meta, definition10, { connectionResolvers });
+
+// scripts/listPlaylists.ts
+import { defineTool as defineTool11, handleIfScriptMain as handleIfScriptMain11 } from "@zapier/connectors-sdk";
+import { z as z12 } from "zod";
+var inputSchema11 = z12.object({
+  part: z12.string().describe("Resource parts to return. Leave as the default.").default("snippet,contentDetails,status"),
+  mine: z12.boolean().describe(
+    "List the authenticated user's own playlists. The default when no channelId or id is given."
+  ).optional(),
+  channelId: z12.string().describe(
+    "List playlists owned by this channel id (UC...). Mutually exclusive with mine and id."
+  ).optional(),
+  id: z12.string().describe(
+    "Fetch specific playlists by id (comma-separated, max 50). Mutually exclusive with mine and channelId."
+  ).optional(),
+  maxResults: z12.number().int().gte(1).lte(50).describe(
+    "Max playlists per page (1-50). Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  pageToken: z12.string().describe(
+    "Page cursor from a previous response's next_page_token. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema11 = z12.object({
+  items: z12.array(PlaylistSchema).describe("The playlists."),
+  next_page_token: NextPageToken
+});
+var definition11 = defineTool11({
+  name: "listPlaylists",
+  title: "List Playlists",
+  description: "List playlists owned by the authenticated user (default) or by a channel, or fetch specific playlists by id. The resolver for any playlistId input.",
+  inputSchema: inputSchema11,
+  outputSchema: outputSchema11,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/playlists`);
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    if (input.mine !== void 0) {
+      url.searchParams.set("mine", String(input.mine));
+    }
+    if (input.channelId !== void 0) {
+      url.searchParams.set("channelId", String(input.channelId));
+    }
+    if (input.id !== void 0) {
+      url.searchParams.set("id", String(input.id));
+    }
+    url.searchParams.set("maxResults", String(input.maxResults ?? 20));
+    if (input.pageToken !== void 0) {
+      url.searchParams.set("pageToken", String(input.pageToken));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET"
+    });
+    await throwForYouTube(res, "listPlaylists");
+    const payload = await res.json();
+    return {
+      items: payload.items ?? [],
+      next_page_token: payload.nextPageToken
+    };
+  }
+});
+var listPlaylists_default = definition11;
+await handleIfScriptMain11(import.meta, definition11, { connectionResolvers });
+
+// scripts/listSubscriptions.ts
+import { defineTool as defineTool12, handleIfScriptMain as handleIfScriptMain12 } from "@zapier/connectors-sdk";
+import { z as z13 } from "zod";
+var inputSchema12 = z13.object({
+  part: z13.string().describe("Resource parts to return. Leave as the default.").default("snippet,contentDetails"),
+  mine: z13.boolean().describe("List the authenticated user's subscriptions. The default.").default(true),
+  forChannelId: z13.string().describe(
+    "Restrict to a subscription to this specific channel id \u2014 returns one item if subscribed, none otherwise. Use to check subscription state."
+  ).optional(),
+  order: z13.enum(["alphabetical", "relevance", "unread"]).describe("Sort order.").default("relevance"),
+  maxResults: z13.number().int().gte(1).lte(50).describe(
+    "Max subscriptions per page (1-50). Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  pageToken: z13.string().describe(
+    "Page cursor from a previous response's next_page_token. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema12 = z13.object({
+  items: z13.array(SubscriptionSchema).describe("The subscriptions."),
+  next_page_token: NextPageToken
+});
+var definition12 = defineTool12({
+  name: "listSubscriptions",
+  title: "List Subscriptions",
+  description: "List the channels the authenticated user is subscribed to (default), or check whether the user subscribes to a specific channel via forChannelId.",
+  inputSchema: inputSchema12,
+  outputSchema: outputSchema12,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/subscriptions`);
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    if (input.mine !== void 0) {
+      url.searchParams.set("mine", String(input.mine));
+    }
+    if (input.forChannelId !== void 0) {
+      url.searchParams.set("forChannelId", String(input.forChannelId));
+    }
+    if (input.order !== void 0) {
+      url.searchParams.set("order", String(input.order));
+    }
+    url.searchParams.set("maxResults", String(input.maxResults ?? 20));
+    if (input.pageToken !== void 0) {
+      url.searchParams.set("pageToken", String(input.pageToken));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET"
+    });
+    await throwForYouTube(res, "listSubscriptions");
+    const payload = await res.json();
+    return {
+      items: payload.items ?? [],
+      next_page_token: payload.nextPageToken
+    };
+  }
+});
+var listSubscriptions_default = definition12;
+await handleIfScriptMain12(import.meta, definition12, { connectionResolvers });
+
+// scripts/listVideoCategories.ts
+import { defineTool as defineTool13, handleIfScriptMain as handleIfScriptMain13 } from "@zapier/connectors-sdk";
+import { z as z14 } from "zod";
+var inputSchema13 = z14.object({
+  part: z14.string().describe("Resource parts to return. Leave as the default.").default("snippet"),
+  regionCode: z14.string().describe(
+    "ISO 3166-1 alpha-2 country code whose category set to return (e.g. US, GB). Categories vary by region."
+  ).default("US")
+}).strict();
+var outputSchema13 = z14.object({
+  items: z14.array(VideoCategorySchema).describe("The categories for the region.")
+});
+var definition13 = defineTool13({
+  name: "listVideoCategories",
+  title: "List Video Categories",
+  description: "List the assignable video categories for a region (the id/title pairs that categoryId accepts on a video). Resolver for the category an upload or update should use.",
+  inputSchema: inputSchema13,
+  outputSchema: outputSchema13,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(
+      `https://www.googleapis.com/youtube/v3/videoCategories`
+    );
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    if (input.regionCode !== void 0) {
+      url.searchParams.set("regionCode", String(input.regionCode));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET"
+    });
+    await throwForYouTube(res, "listVideoCategories");
+    const payload = await res.json();
+    return { items: payload.items ?? [] };
+  }
+});
+var listVideoCategories_default = definition13;
+await handleIfScriptMain13(import.meta, definition13, { connectionResolvers });
+
+// scripts/postComment.ts
+import { defineTool as defineTool14, handleIfScriptMain as handleIfScriptMain14 } from "@zapier/connectors-sdk";
+import { z as z15 } from "zod";
+var inputSchema14 = z15.object({
+  snippet: z15.object({
+    videoId: z15.string().describe("The video to comment on."),
+    topLevelComment: z15.object({
+      snippet: z15.object({
+        textOriginal: z15.string().describe("The comment text to post.")
+      }).strict()
+    }).strict()
+  }).strict(),
+  part: z15.string().describe("Resource parts being written. Leave as the default.").default("snippet")
+}).strict();
+var outputSchema14 = CommentThreadSchema;
+var definition14 = defineTool14({
+  name: "postComment",
+  title: "Post Comment",
+  description: "Post a new top-level comment on a video. For a reply to an existing comment, use replyToComment instead. Requires the youtube.force-ssl scope.",
+  inputSchema: inputSchema14,
+  outputSchema: outputSchema14,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/commentThreads`);
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    const body = {};
+    if (input.snippet !== void 0) body["snippet"] = input.snippet;
+    const res = await ctx.fetch(url.toString(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    await throwForYouTube(res, "postComment");
+    return res.json();
+  }
+});
+var postComment_default = definition14;
+await handleIfScriptMain14(import.meta, definition14, { connectionResolvers });
+
+// scripts/rateVideo.ts
+import { defineTool as defineTool15, handleIfScriptMain as handleIfScriptMain15 } from "@zapier/connectors-sdk";
+import { z as z16 } from "zod";
+var inputSchema15 = z16.object({
+  id: z16.string().describe("The id of the video to rate."),
+  rating: z16.enum(["like", "dislike", "none"]).describe(
+    "like or dislike to set the rating; none to remove an existing rating."
+  )
+}).strict();
+var outputSchema15 = SuccessResultSchema;
+var definition15 = defineTool15({
+  name: "rateVideo",
+  title: "Rate Video",
+  description: "Like, dislike, or clear the authenticated user's rating on a video (the thumbs up/down action). Use rating=none to remove an existing rating. The API returns no body; the connector synthesizes a success flag.",
+  inputSchema: inputSchema15,
+  outputSchema: outputSchema15,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    // Setting the same rating twice leaves the same state.
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/videos/rate`);
+    url.searchParams.set("id", input.id);
+    url.searchParams.set("rating", input.rating);
+    const res = await ctx.fetch(url.toString(), { method: "POST" });
+    await throwForYouTube(res, "rateVideo");
+    return { success: true };
+  }
+});
+var rateVideo_default = definition15;
+await handleIfScriptMain15(import.meta, definition15, { connectionResolvers });
+
+// scripts/removeVideoFromPlaylist.ts
+import { defineTool as defineTool16, handleIfScriptMain as handleIfScriptMain16 } from "@zapier/connectors-sdk";
+import { z as z17 } from "zod";
+var inputSchema16 = z17.object({
+  id: z17.string().describe(
+    "The playlistItem id to remove (the item's own id from listPlaylistItems, not the video id)."
+  )
+}).strict();
+var outputSchema16 = SuccessResultSchema;
+var definition16 = defineTool16({
+  name: "removeVideoFromPlaylist",
+  title: "Remove Video From Playlist",
+  description: "Remove an item from a playlist. The id is the playlistItem id (NOT the video id) \u2014 get it from listPlaylistItems.",
+  inputSchema: inputSchema16,
+  outputSchema: outputSchema16,
+  annotations: {
+    readOnlyHint: false,
+    // Reversible — the video can be re-added with addVideoToPlaylist.
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/playlistItems`);
+    if (input.id !== void 0) {
+      url.searchParams.set("id", String(input.id));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "DELETE"
+    });
+    await throwForYouTube(res, "removeVideoFromPlaylist");
+    return { success: true };
+  }
+});
+var removeVideoFromPlaylist_default = definition16;
+await handleIfScriptMain16(import.meta, definition16, { connectionResolvers });
+
+// scripts/replyToComment.ts
+import {
+  ConnectorHttpError as ConnectorHttpError2,
+  defineTool as defineTool17,
+  handleIfScriptMain as handleIfScriptMain17
+} from "@zapier/connectors-sdk";
+import { z as z18 } from "zod";
+var inputSchema17 = z18.object({
+  snippet: z18.object({
+    parentId: z18.string().describe(
+      "The TOP-LEVEL comment thread id to reply to (from listComments) \u2014 not a reply id. Replies are single-level: you cannot reply to a reply."
+    ),
+    textOriginal: z18.string().describe("The reply text to post.")
+  }).strict(),
+  part: z18.string().describe("Resource parts being written. Leave as the default.").default("snippet")
+}).strict();
+var outputSchema17 = CommentSchema;
+var definition17 = defineTool17({
+  name: "replyToComment",
+  title: "Reply To Comment",
+  description: "Reply to an existing top-level comment thread. The parentId must be a top-level comment thread id from listComments \u2014 replies are single-level, so you cannot reply to a reply (YouTube rejects it with operationNotSupported). Requires the youtube.force-ssl scope.",
+  inputSchema: inputSchema17,
+  outputSchema: outputSchema17,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/comments`);
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    const body = {};
+    if (input.snippet !== void 0) body["snippet"] = input.snippet;
+    const res = await ctx.fetch(url.toString(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (res.ok) return res.json();
+    if (res.status === 400) {
+      const errBody = await res.json().catch(() => null);
+      if (hasYouTubeReason(errBody, "operationNotSupported")) {
+        throw ConnectorHttpError2.fromResponseBody(res, errBody, {
+          message: "YouTube replyToComment 400: operationNotSupported \u2014 parentId must be a top-level comment thread id (from listComments), not a reply. YouTube does not support nested replies."
+        });
+      }
+      throw ConnectorHttpError2.fromResponseBody(res, errBody, {
+        message: `YouTube replyToComment 400: ${errBody?.error?.message ?? "bad request"}`
+      });
+    }
+    await throwForYouTube(res, "replyToComment");
+    return res.json();
+  }
+});
+var replyToComment_default = definition17;
+await handleIfScriptMain17(import.meta, definition17, { connectionResolvers });
+
+// scripts/searchVideos.ts
+import { defineTool as defineTool18, handleIfScriptMain as handleIfScriptMain18 } from "@zapier/connectors-sdk";
+import { z as z19 } from "zod";
+var inputSchema18 = z19.object({
+  part: z19.string().describe("Resource parts to return. Leave as the default.").default("snippet"),
+  type: z19.string().describe(
+    "Resource type to search. Leave as the default to search videos."
+  ).default("video"),
+  q: z19.string().describe(
+    'Free-text search query. Supports the NOT (-) and OR (|) operators, e.g. "boating|sailing -fishing".'
+  ).optional(),
+  channelId: z19.string().describe(
+    "Restrict results to videos uploaded by this channel id (UC...). Resolve via getChannel."
+  ).optional(),
+  forMine: z19.boolean().describe(
+    "Restrict results to the authenticated user's own videos. Requires type=video. Cannot be combined with channelId."
+  ).optional(),
+  order: z19.enum(["date", "rating", "relevance", "title", "videoCount", "viewCount"]).describe("Sort order for results.").default("relevance"),
+  publishedAfter: z19.string().datetime({ offset: true }).describe(
+    "Only return videos published at or after this RFC3339 datetime, e.g. 2026-01-01T00:00:00Z."
+  ).optional(),
+  publishedBefore: z19.string().datetime({ offset: true }).describe("Only return videos published before this RFC3339 datetime.").optional(),
+  videoDuration: z19.enum(["any", "long", "medium", "short"]).describe(
+    "Filter by length. short = <4 min, medium = 4-20 min, long = >20 min."
+  ).optional(),
+  regionCode: z19.string().describe(
+    "ISO 3166-1 alpha-2 country code (e.g. US, GB) to return results for."
+  ).optional(),
+  relevanceLanguage: z19.string().describe("ISO 639-1 language code (e.g. en, es) to bias results toward.").optional(),
+  maxResults: z19.number().int().gte(1).lte(50).describe(
+    "Max results per page (1-50). Defaults to 10 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  pageToken: z19.string().describe(
+    "Page cursor from a previous response's next_page_token. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema18 = z19.object({
+  items: z19.array(SearchResultSchema).describe("The search hits."),
+  next_page_token: NextPageToken
+});
+var definition18 = defineTool18({
+  name: "searchVideos",
+  title: "Search Videos",
+  description: "Search YouTube for videos by keyword, channel, date, or duration. Returns lightweight results (id + snippet); call getVideo for statistics and contentDetails. Metered against a separate Search Queries quota bucket, independent of the main 10,000-unit pool.",
+  inputSchema: inputSchema18,
+  outputSchema: outputSchema18,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/search`);
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    if (input.type !== void 0) {
+      url.searchParams.set("type", String(input.type));
+    }
+    if (input.q !== void 0) {
+      url.searchParams.set("q", String(input.q));
+    }
+    if (input.channelId !== void 0) {
+      url.searchParams.set("channelId", String(input.channelId));
+    }
+    if (input.forMine !== void 0) {
+      url.searchParams.set("forMine", String(input.forMine));
+    }
+    if (input.order !== void 0) {
+      url.searchParams.set("order", String(input.order));
+    }
+    if (input.publishedAfter !== void 0) {
+      url.searchParams.set("publishedAfter", String(input.publishedAfter));
+    }
+    if (input.publishedBefore !== void 0) {
+      url.searchParams.set("publishedBefore", String(input.publishedBefore));
+    }
+    if (input.videoDuration !== void 0) {
+      url.searchParams.set("videoDuration", String(input.videoDuration));
+    }
+    if (input.regionCode !== void 0) {
+      url.searchParams.set("regionCode", String(input.regionCode));
+    }
+    if (input.relevanceLanguage !== void 0) {
+      url.searchParams.set(
+        "relevanceLanguage",
+        String(input.relevanceLanguage)
+      );
+    }
+    url.searchParams.set("maxResults", String(input.maxResults ?? 10));
+    if (input.pageToken !== void 0) {
+      url.searchParams.set("pageToken", String(input.pageToken));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET"
+    });
+    await throwForYouTube(res, "searchVideos");
+    const payload = await res.json();
+    return {
+      items: payload.items ?? [],
+      next_page_token: payload.nextPageToken
+    };
+  }
+});
+var searchVideos_default = definition18;
+await handleIfScriptMain18(import.meta, definition18, { connectionResolvers });
+
+// scripts/subscribeToChannel.ts
+import {
+  ConnectorHttpError as ConnectorHttpError3,
+  defineTool as defineTool19,
+  handleIfScriptMain as handleIfScriptMain19
+} from "@zapier/connectors-sdk";
+import { z as z20 } from "zod";
+var inputSchema19 = z20.object({
+  snippet: z20.object({
+    resourceId: z20.object({
+      kind: z20.string().default("youtube#channel"),
+      channelId: z20.string().describe("The id (UC...) of the channel to subscribe to.")
+    }).strict().describe(
+      "The channel to subscribe to. Set kind to youtube#channel and channelId to the target channel id."
+    )
+  }).strict(),
+  part: z20.string().describe("Resource parts being written. Leave as the default.").default("snippet")
+}).strict();
+var outputSchema19 = SubscriptionSchema.extend({
+  alreadySatisfied: z20.literal(true).describe("Present and true when the user was already subscribed.").optional(),
+  alreadySatisfiedReason: z20.string().describe('The upstream code, e.g. "subscriptionDuplicate".').optional()
+});
+var definition19 = defineTool19({
+  name: "subscribeToChannel",
+  title: "Subscribe To Channel",
+  description: "Subscribe the authenticated user to a channel. Returns the subscription id (used by unsubscribeFromChannel \u2014 distinct from the channel id). If the user is already subscribed, returns the existing subscription with alreadySatisfied: true rather than failing.",
+  inputSchema: inputSchema19,
+  outputSchema: outputSchema19,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/subscriptions`);
+    url.searchParams.set("part", input.part);
+    const res = await ctx.fetch(url.toString(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ snippet: input.snippet })
+    });
+    if (res.ok) return res.json();
+    if (res.status === 400) {
+      const body = await res.json().catch(() => null);
+      if (hasYouTubeReason(body, "subscriptionDuplicate")) {
+        const channelId = input.snippet.resourceId.channelId;
+        const lookup = new URL(
+          `https://www.googleapis.com/youtube/v3/subscriptions`
+        );
+        lookup.searchParams.set("part", "snippet,contentDetails");
+        lookup.searchParams.set("mine", "true");
+        lookup.searchParams.set("forChannelId", channelId);
+        const lres = await ctx.fetch(lookup.toString(), { method: "GET" });
+        await throwForYouTube(lres, "subscribeToChannel");
+        const lpayload = await lres.json();
+        const existing = lpayload.items?.[0];
+        if (existing) {
+          return {
+            ...existing,
+            alreadySatisfied: true,
+            alreadySatisfiedReason: "subscriptionDuplicate"
+          };
+        }
+      }
+      throw ConnectorHttpError3.fromResponseBody(res, body, {
+        message: `YouTube subscribeToChannel 400: ${body?.error?.message ?? "bad request"}`
+      });
+    }
+    await throwForYouTube(res, "subscribeToChannel");
+    return res.json();
+  }
+});
+var subscribeToChannel_default = definition19;
+await handleIfScriptMain19(import.meta, definition19, { connectionResolvers });
+
+// scripts/unsubscribeFromChannel.ts
+import { defineTool as defineTool20, handleIfScriptMain as handleIfScriptMain20 } from "@zapier/connectors-sdk";
+import { z as z21 } from "zod";
+var inputSchema20 = z21.object({
+  id: z21.string().describe(
+    "The subscription id to delete (from listSubscriptions, not the channel id)."
+  )
+}).strict();
+var outputSchema20 = SuccessResultSchema;
+var definition20 = defineTool20({
+  name: "unsubscribeFromChannel",
+  title: "Unsubscribe From Channel",
+  description: "Unsubscribe the authenticated user from a channel. The id is the subscription id from listSubscriptions (NOT the channel id).",
+  inputSchema: inputSchema20,
+  outputSchema: outputSchema20,
+  annotations: {
+    readOnlyHint: false,
+    // Reversible — the user can re-subscribe with subscribeToChannel.
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/subscriptions`);
+    if (input.id !== void 0) {
+      url.searchParams.set("id", String(input.id));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "DELETE"
+    });
+    await throwForYouTube(res, "unsubscribeFromChannel");
+    return { success: true };
+  }
+});
+var unsubscribeFromChannel_default = definition20;
+await handleIfScriptMain20(import.meta, definition20, { connectionResolvers });
+
+// scripts/updatePlaylist.ts
+import { defineTool as defineTool21, handleIfScriptMain as handleIfScriptMain21 } from "@zapier/connectors-sdk";
+import { z as z22 } from "zod";
+var inputSchema21 = z22.object({
+  id: z22.string().describe("The id of the playlist to update."),
+  snippet: z22.object({
+    title: z22.string().describe("Playlist title (required)."),
+    description: z22.string().describe("Playlist description.").optional(),
+    defaultLanguage: z22.string().describe(
+      "BCP-47 language code of the title/description text, e.g. en."
+    ).optional()
+  }).strict(),
+  status: z22.object({
+    privacyStatus: z22.enum(["public", "unlisted", "private"]).describe("Playlist visibility. Defaults to private if omitted.").optional()
+  }).strict().optional(),
+  part: z22.string().describe("Resource parts being written. Leave as the default.").default("snippet,status")
+}).strict();
+var outputSchema21 = PlaylistSchema;
+var definition21 = defineTool21({
+  name: "updatePlaylist",
+  title: "Update Playlist",
+  description: "Update a playlist's title, description, or privacy. Send the complete desired snippet \u2014 omitted fields within a written part are reset (the API replaces, not merges). Resolve id via listPlaylists.",
+  inputSchema: inputSchema21,
+  outputSchema: outputSchema21,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const url = new URL(`https://www.googleapis.com/youtube/v3/playlists`);
+    if (input.part !== void 0) {
+      url.searchParams.set("part", String(input.part));
+    }
+    const body = {};
+    if (input.id !== void 0) body["id"] = input.id;
+    if (input.snippet !== void 0) body["snippet"] = input.snippet;
+    if (input.status !== void 0) body["status"] = input.status;
+    const res = await ctx.fetch(url.toString(), {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    await throwForYouTube(res, "updatePlaylist");
+    return res.json();
+  }
+});
+var updatePlaylist_default = definition21;
+await handleIfScriptMain21(import.meta, definition21, { connectionResolvers });
+
+// scripts/updateVideo.ts
+import { defineTool as defineTool22, handleIfScriptMain as handleIfScriptMain22 } from "@zapier/connectors-sdk";
+import { z as z23 } from "zod";
+var inputSchema22 = z23.object({
+  video_id: z23.string().describe("The id of the video to update (you must own it)."),
+  title: z23.string().describe("New title. Max 100 characters.").optional(),
+  description: z23.string().describe("New description.").optional(),
+  tags: z23.array(z23.string()).describe("New tag list (replaces the existing tags).").optional(),
+  category_id: z23.string().describe("New category id (from listVideoCategories).").optional(),
+  privacy_status: z23.enum(["private", "public", "unlisted"]).describe("New privacy status.").optional(),
+  publish_at: z23.string().describe(
+    "Reschedule publication (RFC3339). Requires privacy_status=private."
+  ).optional(),
+  made_for_kids: z23.boolean().describe("COPPA self-declaration (status.selfDeclaredMadeForKids).").optional()
+}).strict();
+var outputSchema22 = VideoSchema;
+var definition22 = defineTool22({
+  name: "updateVideo",
+  title: "Update Video",
+  description: "Update an existing video's metadata (title, description, tags, category, privacy) without disturbing the fields you don't change. Reads the current video first, merges your changes, then writes \u2014 so omitting a field leaves it as-is. You must own the video.",
+  inputSchema: inputSchema22,
+  outputSchema: outputSchema22,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "youtube",
+  run: async (input, ctx) => {
+    const getUrl = new URL(`https://www.googleapis.com/youtube/v3/videos`);
+    getUrl.searchParams.set("part", "snippet,status");
+    getUrl.searchParams.set("id", input.video_id);
+    const getRes = await ctx.fetch(getUrl.toString(), { method: "GET" });
+    await throwForYouTube(getRes, "updateVideo");
+    const current = await getRes.json();
+    const video = current.items?.[0];
+    if (!video) {
+      throw new Error(
+        `YouTube updateVideo 404: no video found with id '${input.video_id}'. Verify the id (resolve via searchVideos/getVideo); you can only update videos you own.`
+      );
+    }
+    const cur = video.snippet ?? {};
+    const snippet = {
+      title: input.title ?? cur.title,
+      categoryId: input.category_id ?? cur.categoryId
+    };
+    if (input.description !== void 0)
+      snippet.description = input.description;
+    else if (cur.description !== void 0)
+      snippet.description = cur.description;
+    if (input.tags !== void 0) snippet.tags = input.tags;
+    else if (cur.tags !== void 0) snippet.tags = cur.tags;
+    if (cur.defaultLanguage !== void 0)
+      snippet.defaultLanguage = cur.defaultLanguage;
+    const curStatus = video.status ?? {};
+    const status = {
+      privacyStatus: input.privacy_status ?? curStatus.privacyStatus
+    };
+    if (input.publish_at !== void 0) status.publishAt = input.publish_at;
+    else if (curStatus.publishAt !== void 0)
+      status.publishAt = curStatus.publishAt;
+    if (input.made_for_kids !== void 0)
+      status.selfDeclaredMadeForKids = input.made_for_kids;
+    else if (curStatus.selfDeclaredMadeForKids !== void 0)
+      status.selfDeclaredMadeForKids = curStatus.selfDeclaredMadeForKids;
+    if (curStatus.license !== void 0) status.license = curStatus.license;
+    const putUrl = new URL(`https://www.googleapis.com/youtube/v3/videos`);
+    putUrl.searchParams.set("part", "snippet,status");
+    const putRes = await ctx.fetch(putUrl.toString(), {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ id: input.video_id, snippet, status })
+    });
+    await throwForYouTube(putRes, "updateVideo");
+    return putRes.json();
+  }
+});
+var updateVideo_default = definition22;
+await handleIfScriptMain22(import.meta, definition22, { connectionResolvers });
+
+// index.ts
+var connector = defineConnector({
+  scripts: {
+    addVideoToPlaylist: addVideoToPlaylist_default,
+    createPlaylist: createPlaylist_default,
+    deletePlaylist: deletePlaylist_default,
+    deleteVideo: deleteVideo_default,
+    downloadCaption: downloadCaption_default,
+    getChannel: getChannel_default,
+    getVideo: getVideo_default,
+    listCaptions: listCaptions_default,
+    listComments: listComments_default,
+    listPlaylistItems: listPlaylistItems_default,
+    listPlaylists: listPlaylists_default,
+    listSubscriptions: listSubscriptions_default,
+    listVideoCategories: listVideoCategories_default,
+    postComment: postComment_default,
+    rateVideo: rateVideo_default,
+    removeVideoFromPlaylist: removeVideoFromPlaylist_default,
+    replyToComment: replyToComment_default,
+    searchVideos: searchVideos_default,
+    subscribeToChannel: subscribeToChannel_default,
+    unsubscribeFromChannel: unsubscribeFromChannel_default,
+    updatePlaylist: updatePlaylist_default,
+    updateVideo: updateVideo_default
+  },
+  connectionResolvers
+});
+var index_default = connector;
+var {
+  addVideoToPlaylist,
+  createPlaylist,
+  deletePlaylist,
+  deleteVideo,
+  downloadCaption,
+  getChannel,
+  getVideo,
+  listCaptions,
+  listComments,
+  listPlaylistItems,
+  listPlaylists,
+  listSubscriptions,
+  listVideoCategories,
+  postComment,
+  rateVideo,
+  removeVideoFromPlaylist,
+  replyToComment,
+  searchVideos,
+  subscribeToChannel,
+  unsubscribeFromChannel,
+  updatePlaylist,
+  updateVideo
+} = toFunctions(connector);
+export {
+  addVideoToPlaylist,
+  createPlaylist,
+  index_default as default,
+  deletePlaylist,
+  deleteVideo,
+  downloadCaption,
+  getChannel,
+  getVideo,
+  listCaptions,
+  listComments,
+  listPlaylistItems,
+  listPlaylists,
+  listSubscriptions,
+  listVideoCategories,
+  postComment,
+  rateVideo,
+  removeVideoFromPlaylist,
+  replyToComment,
+  searchVideos,
+  subscribeToChannel,
+  unsubscribeFromChannel,
+  updatePlaylist,
+  updateVideo
+};