REST API

Copyexport const document = createDocument({
  openapi: "3.0.3",
  info: {
    title: "Dub API",
    description:
      "Dub is the modern link attribution platform for short links, conversion tracking, and affiliate programs.",
    version: "0.0.1",
    contact: {
      name: "Dub Support",
      email: "support@dub.co",
      url: "https://dub.co/support",
    },
    license: {
      name: "AGPL-3.0 license",
      url: "https://github.com/dubinc/dub/blob/main/LICENSE.md",
    },
  },
  servers: [
    {
      url: "https://api.dub.co",
      description: "Production API",
    },
  ],

Copyimport { analyticsPath } from "./analytics";
import { bountiesPaths } from "./bounties";
import { commissionsPaths } from "./commissions";
import { customersPaths } from "./customers";
import { discountCodesPaths } from "./discount-codes";
import { domainsPaths } from "./domains";
import { embedTokensPaths } from "./embed-tokens";
import { eventsPath } from "./events";
import { foldersPaths } from "./folders";
import { linksPaths } from "./links";
import { partnersPaths } from "./partners";
import { payoutsPaths } from "./payouts";
import { programApplicationsPaths } from "./program-applications";
import { qrCodePaths } from "./qr";
import { openApiErrorResponsesComponents } from "./responses";
import { tagsPaths } from "./tags";
import { trackPaths } from "./track";

Copycomponents: {
  schemas: {
    LinkSchema,
    LinkTagSchema,
    FolderSchema,
    DomainSchema,
    DiscountCodeSchema,
    webhookEventSchema,
    LinkErrorSchema,
  },
  securitySchemes: {
    token: {
      type: "http",
      description: "Default authentication mechanism",
      scheme: "bearer",
      "x-speakeasy-example": "DUB_API_KEY",
    },
  },
  responses: {
    ...openApiErrorResponsesComponents,
  },
},

Copyexport function GET() {
  return NextResponse.json(document, {
    headers: {
      // cache indefinitely till next deployment
      "Vercel-CDN-Cache-Control": "s-maxage=31536000",
      "Cache-Control": "public, max-age=31536000",
    },
  });

Copyconst authorizationHeader = requestHeaders.get("Authorization");
if (authorizationHeader) {
  if (!authorizationHeader.startsWith("Bearer ")) {
    throw new DubApiError({
      code: "bad_request",
      message:
        "Misconfigured authorization header. Did you forget to add 'Bearer '? Learn more: https://d.to/auth",
    });
  }
  apiKey = authorizationHeader.replace("Bearer ", "");
}
 
let workspaceId: string | undefined;
let workspaceSlug: string | undefined;
let permissions: PermissionAction[] = [];
const isRestrictedToken = apiKey?.startsWith("dub_");
 

Copyif (apiKey) {
  const hashedKey = await hashToken(apiKey);
 
  const cachedToken = await tokenCache.get({
    hashedKey,
  });
 
  if (!cachedToken) {
    const prismaArgs = {
      where: {
        hashedKey,
      },
      select: {
        id: true,
        expires: true,
        ...(isRestrictedToken && {
          scopes: true,
          projectId: true,
          installationId: true,
          project: {
            select: {
              plan: true,
              trialEndsAt: true,
            },
          },
        }),
        user: true,
      },
    };
 
    if (isRestrictedToken) {
      token = await prisma.restrictedToken.findUnique(prismaArgs);
    } else {
      token = await prisma.token.findUnique(prismaArgs);
    }
  }

Copyif (!token || !token.user) {
  throw new DubApiError({
    code: "unauthorized",
    message: "Unauthorized: Invalid API key.",
  });
}
 
if (token.expires && token.expires < new Date()) {
  throw new DubApiError({
    code: "unauthorized",
    message: "Unauthorized: Access token expired.",
  });
}

Copyconst idOrSlug =
  params?.idOrSlug ||
  searchParams.workspaceId ||
  params?.slug ||
  searchParams.projectSlug;
 
/*
  if there's no workspace ID or slug and it's not a restricted token:
  - special case for anonymous link creation
  - missing authorization header
  - user is still using personal API keys
*/
if (!idOrSlug && !isRestrictedToken) {
  // special case for anonymous link creation
  if (
    requestHeaders.has("dub-anonymous-link-creation") &&
    ["/links", "/api/links"].includes(req.nextUrl.pathname)
  ) {
    // @ts-expect-error
    return await handler({
      req: clonedReq,
      params,
      searchParams,
      headers: responseHeaders,
    });
    // missing authorization header
  } else if (!authorizationHeader) {
    throw new DubApiError({
      code: "unauthorized",
      message: "Missing Authorization header.",
    });
    // in case user is still using personal API keys
  } else {
    throw new DubApiError({
      code: "not_found",
      message:
        "Workspace ID not found. Did you forget to include a `workspaceId` query parameter? It looks like you might be using personal API keys, we also recommend refactoring to workspace API keys: https://d.to/keys",
    });
  }
}
 
if (idOrSlug) {
  if (idOrSlug.startsWith("ws_")) {
    workspaceId = normalizeWorkspaceId(idOrSlug);
  } else {
    workspaceSlug = idOrSlug;
  }
}

Copyexport const GET = withWorkspace(
  async ({ workspace }) => {
    const integrations = await prisma.integration.findMany({
      where: {
        installations: {
          some: {
            project: {
              slug: workspace.slug,
            },
          },
        },
      },
      orderBy: {
        createdAt: "desc",
      },
    });
 
    return NextResponse.json(
      integrations.map((integration) =>
        installedIntegrationSchema.parse(integration),
      ),
    );
  },
  {
    requiredPermissions: ["workspaces.read"],
  },

Copy// workspace exists but user is not part of it
if (workspace.users.length === 0) {
  const pendingInvites = await prisma.projectInvite.findUnique({
    where: {
      email_projectId: {
        email: session.user.email,
        projectId: workspace.id,
      },
    },
    select: {
      expires: true,
    },
  });
 
  // Clear so non-member denials are not attributed to this workspace
  // in API logs or Axiom error context.
  workspace = undefined;
 
  if (!pendingInvites) {
    throw new DubApiError({
      code: "not_found",
      message: "Workspace not found.",
    });
  } else if (pendingInvites.expires < new Date()) {
    throw new DubApiError({
      code: "invite_expired",
      message: "Workspace invite expired.",
    });
  } else {
    throw new DubApiError({
      code: "invite_pending",
      message: "Workspace invite pending.",
    });
  }
}

Copy// Rate limit checks for API keys
let limit = 0;
let interval: `${number} s` | `${number} m` = isAnalytics
  ? "1 s"
  : "1 m";
 
const planLimit = getRatelimitForPlan(token.project?.plan || "free", {
  trialEndsAt: token.project?.trialEndsAt ?? null,
});
limit = planLimit.limits[isAnalytics ? "analyticsApi" : "api"];
 
const { success, headers } = await rateLimitRequest({
  identifier: `workspace:ratelimit:${hashedKey}`,
  requests: limit,
  interval,
});

Copyconst { success, headers } = await rateLimitRequest({
  identifier: `workspace:ratelimit:${hashedKey}`,
  requests: limit,
  interval,
});
 
if (headers) {
  for (const [key, value] of Object.entries(headers)) {
    responseHeaders.set(key, value);
  }
}
 
if (!success) {
  throw new DubApiError({
    code: "rate_limit_exceeded",
    message: "Too many requests.",
  });
}
 
// Find workspaceId if it's a restricted token
if (isRestrictedToken && token?.projectId) {
  workspaceId = token.projectId;
}
 
waitUntil(
  // update last used time for the token (only once every minute)
  (async () => {
    try {
      const { success } = await ratelimit(1, "1 m").limit(
        `last-used-${hashedKey}`,
      );
 
      if (success) {
        const prismaArgs = {
          where: {
            hashedKey,
          },
          data: {
            lastUsed: new Date(),
          },
        };
 
        if (isRestrictedToken) {
          await prisma.restrictedToken.update(prismaArgs);
        } else {
          await prisma.token.update(prismaArgs);
        }
      }
    } catch (error) {
      console.error(error);
    }
  })(),
);

Copyconst authorizationHeader = requestHeaders.get("Authorization");
if (authorizationHeader) {
  if (!authorizationHeader.startsWith("Bearer ")) {
    throw new DubApiError({
      code: "bad_request",
      message: "Invalid or missing publishable key.",
    });
  }
 
  const publishableKey = authorizationHeader.replace("Bearer ", "");
  if (!publishableKey.startsWith("dub_pk_")) {
    throw new DubApiError({
      code: "bad_request",
      message: "Invalid or missing publishable key.",
    });
  }

Copyconst { success, limit, reset, remaining } = await ratelimit(
  600,
  "1 m",
).limit(publishableKey);
 
responseHeaders.set("Retry-After", reset.toString());
responseHeaders.set("X-RateLimit-Limit", limit.toString());
responseHeaders.set("X-RateLimit-Remaining", remaining.toString());
responseHeaders.set("X-RateLimit-Reset", reset.toString());
 
if (!success) {
  throw new DubApiError({
    code: "rate_limit_exceeded",
    message: "Too many requests.",
  });
}

Copyworkspace = await prisma.project.findUnique({
  where: {
    publishableKey,
  },
});
 
if (!workspace) {
  throw new DubApiError({
    code: "unauthorized",
    message: "Invalid publishable key.",
  });
}
 
const normalizedWorkspacePlan = [
  "business plus",
  "business max",
  "business extra",
].includes(workspace.plan)
  ? "business"
  : workspace.plan;
 
if (!requiredPlan.includes(normalizedWorkspacePlan)) {
  throw new DubApiError({
    code: "forbidden",
    message: "Unauthorized: Need higher plan.",
  });
}

CopywaitUntil(
  captureRequestLog({
    req: reqForLog,
    response,
    workspace,
    session: undefined,
    token: null,
    url,
    requestHeaders,
    startTime,
  }),
);

Copyconst authorizationHeader = requestHeaders.get("Authorization");
if (authorizationHeader) {
  if (!authorizationHeader.startsWith("Bearer ")) {
    throw new DubApiError({
      code: "bad_request",
      message: "Invalid or missing publishable key.",
    });
  }
 
  const publishableKey = authorizationHeader.replace("Bearer ", "");
  if (!publishableKey.startsWith("dub_pk_")) {
    throw new DubApiError({
      code: "bad_request",
      message: "Invalid or missing publishable key.",
    });
  }
 
  const { success, limit, reset, remaining } = await ratelimit(
    600,
    "1 m",
  ).limit(publishableKey);
 
  responseHeaders.set("Retry-After", reset.toString());
  responseHeaders.set("X-RateLimit-Limit", limit.toString());
  responseHeaders.set("X-RateLimit-Remaining", remaining.toString());
  responseHeaders.set("X-RateLimit-Reset", reset.toString());
 
  if (!success) {
    throw new DubApiError({
      code: "rate_limit_exceeded",
      message: "Too many requests.",
    });
  }
 
  workspace = await prisma.project.findUnique({
    where: {
      publishableKey,
    },
  });
 
  if (!workspace) {
    throw new DubApiError({
      code: "unauthorized",
      message: "Invalid publishable key.",
    });
  }
 
  const normalizedWorkspacePlan = [
    "business plus",
    "business max",
    "business extra",
  ].includes(workspace.plan)
    ? "business"
    : workspace.plan;
 
  if (!requiredPlan.includes(normalizedWorkspacePlan)) {
    throw new DubApiError({
      code: "forbidden",
      message: "Unauthorized: Need higher plan.",
    });
  }

Copyexport const linksPaths: ZodOpenApiPathsObject = {
  "/links": {
    post: createLink,
    get: getLinks,
  },
  "/links/count": {
    get: getLinksCount,
  },
  "/links/info": {
    get: getLinkInfo,
  },
  "/links/{linkId}": {
    patch: updateLink,
    delete: deleteLink,
  },
  "/links/bulk": {
    post: bulkCreateLinks,
    patch: bulkUpdateLinks,
    delete: bulkDeleteLinks,
  },
  "/links/upsert": {
    put: upsertLink,
  },
};

Copyexport const getLinks: ZodOpenApiOperationObject = {
  operationId: "getLinks",
  "x-speakeasy-name-override": "list",
  "x-speakeasy-pagination": {
    type: "offsetLimit",
    inputs: [
      {
        name: "page",
        in: "parameters",
        type: "page",
      },
      {
        name: "pageSize",
        in: "parameters",
        type: "limit",
      },
    ],
    outputs: {
      results: "$",
    },
  },
  summary: "List all links",
  description:
    "Retrieve a paginated list of links for the authenticated workspace.",
  requestParams: {
    query: getLinksQuerySchemaBase,
  },
  responses: {
    "200": {
      description: "A list of links",
      content: {
        "application/json": {
          schema: z.array(LinkSchema),
        },
      },
    },
    ...openApiErrorResponses,
  },
  tags: ["Links"],
  security: [{ token: [] }],
};

Copyexport const getLinkInfo: ZodOpenApiOperationObject = {
  operationId: "getLinkInfo",
  "x-speakeasy-name-override": "get",
  summary: "Retrieve a link",
  description: "Retrieve the info for a link.",
  requestParams: {
    query: getLinkInfoQuerySchema,
  },
  responses: {
    "200": {
      description: "The retrieved link",
      content: {
        "application/json": {
          schema: LinkSchema,
        },
      },
    },
    ...openApiErrorResponses,
  },
  tags: ["Links"],
  security: [{ token: [] }],
};

Copyexport const getLinksCount: ZodOpenApiOperationObject = {
  operationId: "getLinksCount",
  "x-speakeasy-name-override": "count",
  summary: "Retrieve links count",
  description: "Retrieve the number of links for the authenticated workspace.",
  requestParams: {
    query: getLinksCountQuerySchema,
  },
  responses: {
    "200": {
      description: "A list of links",
      content: {
        "application/json": {
          schema: z.number().meta({
            description: "The number of links matching the query.",
          }),
        },
      },
    },
    ...openApiErrorResponses,
  },
  tags: ["Links"],
  security: [{ token: [] }],
};

Copy"/links/count": {
  get: getLinksCount,
},
"/links/info": {
  get: getLinkInfo,
},

Copyconst retrieveAnalytics: ZodOpenApiOperationObject = {
  operationId: "retrieveAnalytics",
  "x-speakeasy-name-override": "retrieve",
  summary:
    "Retrieve analytics for a link, a domain, or the authenticated workspace.",
  description:
    "Retrieve analytics for a link, a domain, or the authenticated workspace. The response type depends on the `event` and `type` query parameters.",
  requestParams: {
    query: analyticsQuerySchema,
  },

Copy"200": {
  description: "Analytics data",
  content: {
    "application/json": {
      schema: z.union([
        analyticsResponse.count.meta({
          id: "AnalyticsCount",
        }),
        z.array(
          analyticsResponse.timeseries.meta({
            id: "AnalyticsTimeseries",
          }),
        ),
        z.array(
          analyticsResponse.continents.meta({
            id: "AnalyticsContinents",
          }),
        ),
        z.array(
          analyticsResponse.countries.meta({
            id: "AnalyticsCountries",
          }),
        ),
        z.array(
          analyticsResponse.regions.meta({
            id: "AnalyticsRegions",
          }),
        ),
        z.array(
          analyticsResponse.cities.meta({
            id: "AnalyticsCities",
          }),
        ),
        z.array(
          analyticsResponse.devices.meta({
            id: "AnalyticsDevices",
          }),
        ),
        z.array(
          analyticsResponse.browsers.meta({
            id: "AnalyticsBrowsers",
          }),
        ),
        z.array(
          analyticsResponse.os.meta({
            id: "AnalyticsOS",
          }),
        ),
        z.array(
          analyticsResponse.triggers.meta({
            id: "AnalyticsTriggers",
          }),
        ),
        z.array(
          analyticsResponse.event_names.meta({
            id: "AnalyticsEventNames",
          }),
        ),
        z.array(
          analyticsResponse.referers.meta({
            id: "AnalyticsReferers",
          }),
        ),
        z.array(
          analyticsResponse.referer_urls.meta({
            id: "AnalyticsRefererUrls",
          }),
        ),
        z.array(
          analyticsResponse.top_links.meta({
            id: "AnalyticsTopLinks",
          }),
        ),
        z.array(
          analyticsResponse.top_urls.meta({
            id: "AnalyticsTopUrls",
          }),
        ),
      ]),
    },

Copyexport const listEvents: ZodOpenApiOperationObject = {
  operationId: "listEvents",
  "x-speakeasy-name-override": "list",
  summary: "List all events",
  description:
    "Retrieve a paginated list of events for the authenticated workspace.",
  requestParams: {
    query: eventsQuerySchema,
  },

Copyresponses: {
  "200": {
    description: "A list of events",
    content: {
      "application/json": {
        schema: z.array(
          z.discriminatedUnion("event", [
            clickEventResponseSchema,
            leadEventResponseSchema,
            saleEventResponseSchema,
          ]),
        ),
      },
    },
  },

Copyschema: z.array(
  z.discriminatedUnion("event", [
    clickEventResponseSchema,
    leadEventResponseSchema,
    saleEventResponseSchema,
  ]),

Copyexport const listDomains: ZodOpenApiOperationObject = {
  operationId: "listDomains",
  "x-speakeasy-name-override": "list",
  "x-speakeasy-pagination": {
    type: "offsetLimit",
    inputs: [
      {
        name: "page",
        in: "parameters",
        type: "page",
      },
      {
        name: "pageSize",
        in: "parameters",
        type: "limit",
      },
    ],
    outputs: {
      results: "$",
    },
  },

Copysummary: "List all domains",
description:
  "Retrieve a paginated list of domains for the authenticated workspace.",
requestParams: {
  query: getDomainsQuerySchema,
},
responses: {
  "200": {
    description: "The domains were retrieved.",
    content: {
      "application/json": {
        schema: z.array(DomainSchema),
      },
    },
  },
  ...openApiErrorResponses,
},
tags: ["Domains"],
security: [{ token: [] }],

Copyexport const getTags: ZodOpenApiOperationObject = {
  operationId: "getTags",
  "x-speakeasy-name-override": "list",
  summary: "List all tags",
  description:
    "Retrieve a paginated list of tags for the authenticated workspace.",
  requestParams: {
    query: getTagsQuerySchema,
  },
  responses: {
    "200": {
      description: "A list of tags",
      content: {
        "application/json": {
          schema: z.array(LinkTagSchema),
        },
      },
    },
    ...openApiErrorResponses,
  },
  tags: ["Tags"],
  security: [{ token: [] }],

Copyexport const tagsPaths: ZodOpenApiPathsObject = {
  "/tags": {
    post: createTag,
    get: getTags,
  },
  "/tags/{id}": {
    patch: updateTag,
    delete: deleteTag,
  },
};

Copyexport const listFolders: ZodOpenApiOperationObject = {
  operationId: "listFolders",
  "x-speakeasy-name-override": "list",
  summary: "List all folders",
  description:
    "Retrieve a paginated list of folders for the authenticated workspace.",
  requestParams: {
    query: listFoldersQuerySchema,
  },
  responses: {
    "200": {
      description: "A list of folders",
      content: {
        "application/json": {
          schema: z.array(FolderSchema),
        },
      },
    },
    ...openApiErrorResponses,
  },
  tags: ["Folders"],
  security: [{ token: [] }],

CopyrequestParams: {
  query: getDomainsQuerySchema,
},
responses: {
  "200": {
    description: "The domains were retrieved.",
    content: {
      "application/json": {
        schema: z.array(DomainSchema),
      },
    },
  },
…
requestParams: {
  query: getTagsQuerySchema,
},
responses: {
  "200": {
    description: "A list of tags",
    content: {
      "application/json": {
        schema: z.array(LinkTagSchema),
      },
…
requestParams: {
  query: listFoldersQuerySchema,
},
responses: {
  "200": {
    description: "A list of folders",
    content: {
      "application/json": {
        schema: z.array(FolderSchema),
      },

Copyexport const getCustomers: ZodOpenApiOperationObject = {
  operationId: "getCustomers",
  "x-speakeasy-name-override": "list",
  "x-speakeasy-pagination": {
    type: "cursor",
    inputs: [
      {
        name: "startingAfter",
        in: "parameters",
        type: "cursor",
      },
    ],
    outputs: {
      nextCursor: "$[-1].id",
    },
  },
  summary: "List all customers",
  description:
    "Retrieve a paginated list of customers for the authenticated workspace.",
  requestParams: {
    query: getCustomersQuerySchema,
  },
  responses: {
    "200": {
      description: "The list of customers.",
      content: {
        "application/json": {
          schema: z.array(CustomerEnrichedSchema),
        },
      },
    },
    ...openApiErrorResponses,
  },
  tags: ["Customers"],
  security: [{ token: [] }],
};

Copyexport const getCustomer: ZodOpenApiOperationObject = {
  operationId: "getCustomer",
  "x-speakeasy-name-override": "get",
  summary: "Retrieve a customer",
  description:
    "Retrieve a customer by ID for the authenticated workspace. To retrieve a customer by external ID, prefix the ID with `ext_`.",
  requestParams: {
    path: CustomerEnrichedSchema.pick({ id: true }),
    query: getCustomersQuerySchema.pick({ includeExpandedFields: true }),
  },
  responses: {
    "200": {
      description: "The customer object.",
      content: {
        "application/json": {
          schema: CustomerEnrichedSchema,
        },
      },
    },
    ...openApiErrorResponses,
  },
  tags: ["Customers"],
  security: [{ token: [] }],
};

Copyexport const listDiscountCodes: ZodOpenApiOperationObject = {
  operationId: "listDiscountCodes",
  "x-speakeasy-name-override": "list",
  summary: "List discount codes",
  description:
    "Retrieve a paginated list of discount codes in a program or filtered by partner, discount, or code.",
  requestParams: {
    query: getDiscountCodesQuerySchema,
  },
  responses: {
    "200": {
      description: "The list of discount codes.",
      content: {
        "application/json": {
          schema: z.array(DiscountCodeSchema),
        },
      },
    },
    ...openApiErrorResponses,
  },
  tags: ["Discount Codes"],
  security: [{ token: [] }],
};

Copyexport const discountCodesPaths: ZodOpenApiPathsObject = {
  "/discount-codes": {
    get: listDiscountCodes,
    post: createDiscountCode,
  },
  "/discount-codes/{idOrCode}": {
    delete: deleteDiscountCode,
  },
};

Copysummary: "List all customers",
description:
  "Retrieve a paginated list of customers for the authenticated workspace.",
requestParams: {
  query: getCustomersQuerySchema,
},
responses: {
  "200": {
    description: "The list of customers.",
    content: {
      "application/json": {
        schema: z.array(CustomerEnrichedSchema),
      },
    },
  },
  ...openApiErrorResponses,
},
tags: ["Customers"],
…
summary: "Retrieve a customer",
description:
  "Retrieve a customer by ID for the authenticated workspace. To retrieve a customer by external ID, prefix the ID with `ext_`.",
requestParams: {
  path: CustomerEnrichedSchema.pick({ id: true }),
  query: getCustomersQuerySchema.pick({ includeExpandedFields: true }),
},
responses: {
  "200": {
    description: "The customer object.",
    content: {
      "application/json": {
        schema: CustomerEnrichedSchema,
      },
    },
  },
  ...openApiErrorResponses,
},
tags: ["Customers"],
…
summary: "List discount codes",
description:
  "Retrieve a paginated list of discount codes in a program or filtered by partner, discount, or code.",
requestParams: {
  query: getDiscountCodesQuerySchema,
},
responses: {
  "200": {
    description: "The list of discount codes.",
    content: {
      "application/json": {
        schema: z.array(DiscountCodeSchema),
      },
    },
  },
  ...openApiErrorResponses,
},
tags: ["Discount Codes"],
…
summary: "Retrieve a partner's links.",
description: "Retrieve a partner's links by their partner ID or tenant ID.",
requestParams: {
  query: retrievePartnerLinksSchema,
},
responses: {
  "200": {
    description: "The retrieved partner links.",
    content: {
      "application/json": {
        schema: z.array(ProgramPartnerLinkSchema),
      },
    },
  },
  ...openApiErrorResponses,
},
tags: ["Partners"],

Copyexport const retrievePartnerLinks: ZodOpenApiOperationObject = {
  operationId: "retrievePartnerLinks",
  "x-speakeasy-name-override": "retrieveLinks",
  summary: "Retrieve a partner's links.",
  description: "Retrieve a partner's links by their partner ID or tenant ID.",
  requestParams: {
    query: retrievePartnerLinksSchema,
  },
  responses: {
    "200": {
      description: "The retrieved partner links.",
      content: {
        "application/json": {
          schema: z.array(ProgramPartnerLinkSchema),
        },
      },
    },
    ...openApiErrorResponses,
  },
  tags: ["Partners"],
  security: [{ token: [] }],
};

Copyexport const retrievePartnerAnalytics: ZodOpenApiOperationObject = {
  operationId: "retrievePartnerAnalytics",
  "x-speakeasy-name-override": "analytics",
  summary: "Retrieve analytics for a partner",
  description:
    "Retrieve analytics for a partner within a program. The response type vary based on the `groupBy` query parameter.",
  requestParams: {
    query: partnerAnalyticsQuerySchema,
  },
  responses: {
    "200": {
      description: "Partner analytics data",
      content: {
        "application/json": {
          schema: z.union([
            partnerAnalyticsResponseSchema.count.meta({
              id: "PartnerAnalyticsCount",
            }),
            z.array(
              partnerAnalyticsResponseSchema.timeseries.meta({
                id: "PartnerAnalyticsTimeseries",
              }),
            ),
            z.array(
              partnerAnalyticsResponseSchema.top_links.meta({
                id: "PartnerAnalyticsTopLinks",
              }),
            ),
          ]),
        },
      },
    },
    ...openApiErrorResponses,
  },
  tags: ["Partners"],
  security: [{ token: [] }],
};

Copyexport const programApplicationsPaths: ZodOpenApiPathsObject = {
  "/program-applications": {
    get: listProgramApplications,
  },
  "/program-applications/approve": {
    post: approveProgramApplication,
  },
  "/program-applications/reject": {
    post: rejectProgramApplication,
  },
};