/**

* @file Coder is starting to import the Coder API file into more and more

* external projects, as a "pseudo-SDK". We are not at a stage where we are

* ready to commit to maintaining a public SDK, but we need equivalent

* functionality in other places.

*

* Message somebody from Team Blueberry if you need more context, but so far,

* these projects are importing the file:

*

* - The Coder VS Code extension

* @see {@link https://github.com/coder/vscode-coder}

* - The Coder Backstage plugin

* @see {@link https://github.com/coder/backstage-plugins}

*

* It is important that this file not do any aliased imports, or else the other

* consumers could break (particularly for platforms that limit how much you can

* touch their configuration files, like Backstage). Relative imports are still

* safe, though.

*

* For example, `utils/delay` must be imported using `../utils/delay` instead.

*/

import globalAxios, { type AxiosInstance, isAxiosError } from "axios";

import type dayjs from "dayjs";

import userAgentParser from "ua-parser-js";

import { delay } from "../utils/delay";

import {

OneWayWebSocket,

type OneWayWebSocketApi,

} from "../utils/OneWayWebSocket";

import { type FieldError, isApiError } from "./errors";

import type {

AdvisorConfig,

DeleteExternalAuthByIDResponse,

DynamicParametersRequest,

PostWorkspaceUsageRequest,

UpdateAdvisorConfigRequest,

UsersRequest,

} from "./typesGenerated";

import * as TypesGen from "./typesGenerated";

/**

* Originally from codersdk/client.go.

* The below declaration is required to stop Knip from complaining.

* @public

*/

export const SessionTokenCookie = "coder_session_token";

/**

* @param agentId

* @returns {OneWayWebSocket} A OneWayWebSocket that emits Server-Sent Events.

*/

export const watchAgentMetadata = (

agentId: string,

): OneWayWebSocket<TypesGen.ServerSentEvent> => {

return new OneWayWebSocket({

apiRoute: `/api/v2/workspaceagents/${agentId}/watch-metadata-ws`,

});

};

/**

* @returns {OneWayWebSocket} A OneWayWebSocket that emits Server-Sent Events.

*/

export const watchWorkspace = (

workspaceId: string,

): OneWayWebSocket<TypesGen.ServerSentEvent> => {

return new OneWayWebSocket({

apiRoute: `/api/v2/workspaces/${workspaceId}/watch-ws`,

});

};

export const watchChat = (

chatId: string,

afterMessageId?: number,

): OneWayWebSocketApi<TypesGen.ChatStreamEvent[]> => {

const params = new URLSearchParams();

if (afterMessageId !== undefined && afterMessageId > 0) {

params.set("after_id", afterMessageId.toString());

}

const token = API.getSessionToken();

if (token) {

params.set(SessionTokenCookie, token);

}

const query = params.toString();

const route = `/api/experimental/chats/${chatId}/stream${query ? `?${query}` : ""}`;

return new OneWayWebSocket({

apiRoute: route,

});

};

export const watchChats = (): OneWayWebSocket<TypesGen.ChatWatchEvent> => {

const searchParams: Record<string, string> = {};

const token = API.getSessionToken();

if (token) {

searchParams[SessionTokenCookie] = token;

}

return new OneWayWebSocket({

apiRoute: "/api/experimental/chats/watch",

searchParams,

});

};

export const watchChatGit = (chatId: string): WebSocket => {

return createWebSocket(`/api/experimental/chats/${chatId}/stream/git`);

};

export const watchChatDesktop = (chatId: string): WebSocket => {

const socket = createWebSocket(

`/api/experimental/chats/${chatId}/stream/desktop`,

);

// RFB is a binary protocol — noVNC expects arraybuffer, not blob.

socket.binaryType = "arraybuffer";

return socket;

};

export const watchAgentContainers = (

agentId: string,

): OneWayWebSocket<TypesGen.WorkspaceAgentListContainersResponse> => {

return new OneWayWebSocket({

apiRoute: `/api/v2/workspaceagents/${agentId}/containers/watch`,

});

};

type WatchInboxNotificationsParams = Readonly<{

read_status?: "read" | "unread" | "all";

}>;

export function watchInboxNotifications(

params?: WatchInboxNotificationsParams,

): OneWayWebSocket<TypesGen.GetInboxNotificationResponse> {

return new OneWayWebSocket({

apiRoute: "/api/v2/notifications/inbox/watch",

searchParams: params,

});

}

export const getURLWithSearchParams = (

basePath: string,

options?: object,

): string => {

if (!options) {

return basePath;

}

const searchParams = new URLSearchParams();

for (const [key, value] of Object.entries(options)) {

if (value !== undefined && value !== "") {

searchParams.append(key, value.toString());

}

}

const searchString = searchParams.toString();

return searchString ? `${basePath}?${searchString}` : basePath;

};

// withDefaultFeatures sets all unspecified features to not_entitled and

// disabled.

export const withDefaultFeatures = (

fs: Partial<TypesGen.Entitlements["features"]>,

): TypesGen.Entitlements["features"] => {

for (const feature of TypesGen.FeatureNames) {

// Skip fields that are already filled.

if (fs[feature] !== undefined) {

continue;

}

fs[feature] = {

enabled: false,

entitlement: "not_entitled",

};

}

return fs as TypesGen.Entitlements["features"];

};

type WatchBuildLogsByTemplateVersionIdOptions = {

after?: number;

onMessage: (log: TypesGen.ProvisionerJobLog) => void;

onDone?: () => void;

onError: (error: Error) => void;

};

export const watchBuildLogsByTemplateVersionId = (

versionId: string,

{

onMessage,

onDone,

onError,

after,

}: WatchBuildLogsByTemplateVersionIdOptions,

) => {

const searchParams = new URLSearchParams({ follow: "true" });

if (after !== undefined) {

searchParams.append("after", after.toString());

}

const socket = createWebSocket(

`/api/v2/templateversions/${versionId}/logs`,

searchParams,

);

socket.addEventListener("message", (event) =>

onMessage(JSON.parse(event.data) as TypesGen.ProvisionerJobLog),

);

socket.addEventListener("error", () => {

onError(new Error("Connection for logs failed."));

socket.close();

});

socket.addEventListener("close", () => {

// When the socket closes, logs have finished streaming!

onDone?.();

});

return socket;

};

export const watchWorkspaceAgentLogs = (

agentId: string,

params?: WatchWorkspaceAgentLogsParams,

) => {

const searchParams = new URLSearchParams({

follow: "true",

after: params?.after?.toString() ?? "",

});

/**

* WebSocket compression in Safari (confirmed in 16.5) is broken when

* the server sends large messages. The following error is seen:

* WebSocket connection to 'wss://...' failed: The operation couldn't be completed.

*/

if (userAgentParser(navigator.userAgent).browser.name === "Safari") {

searchParams.set("no_compression", "");

}

return new OneWayWebSocket<TypesGen.WorkspaceAgentLog[]>({

apiRoute: `/api/v2/workspaceagents/${agentId}/logs`,

searchParams,

});

};

type WatchWorkspaceAgentLogsParams = {

after?: number;

};

type WatchBuildLogsByBuildIdOptions = {

after?: number;

onMessage: (log: TypesGen.ProvisionerJobLog) => void;

onDone?: () => void;

onError?: (error: Error) => void;

};

export const watchBuildLogsByBuildId = (

buildId: string,

{ onMessage, onDone, onError, after }: WatchBuildLogsByBuildIdOptions,

) => {

const searchParams = new URLSearchParams({ follow: "true" });

if (after !== undefined) {

searchParams.append("after", after.toString());

}

const socket = createWebSocket(

`/api/v2/workspacebuilds/${buildId}/logs`,

searchParams,

);

socket.addEventListener("message", (event) =>

onMessage(JSON.parse(event.data) as TypesGen.ProvisionerJobLog),

);

socket.addEventListener("error", () => {

if (socket.readyState === socket.CLOSED) {

return;

}

onError?.(new Error("Connection for logs failed."));

socket.close();

});

socket.addEventListener("close", () => {

// When the socket closes, logs have finished streaming!

onDone?.();

});

return socket;

};

// This is the base header that is used for several requests. This is defined as

// a readonly value, but only copies of it should be passed into the API calls,

// because Axios is able to mutate the headers

const BASE_CONTENT_TYPE_JSON = {

"Content-Type": "application/json",

} as const satisfies HeadersInit;

export type GetTemplatesOptions = Readonly<{

readonly deprecated?: boolean;

}>;

export type GetTemplatesQuery = Readonly<{

readonly q: string;

}>;

function normalizeGetTemplatesOptions(

options: GetTemplatesOptions | GetTemplatesQuery = {},

): Record<string, string> {

if ("q" in options) {

return options;

}

const params: Record<string, string> = {};

if (options.deprecated !== undefined) {

params.deprecated = String(options.deprecated);

}

return params;

}

type SearchParamOptions = TypesGen.Pagination & {

q?: string;

};

type RestartWorkspaceParameters = Readonly<{

workspace: TypesGen.Workspace;

buildParameters?: TypesGen.WorkspaceBuildParameter[];

}>;

export type DeleteWorkspaceOptions = Pick<

TypesGen.CreateWorkspaceBuildRequest,

"log_level" | "orphan"

>;

export type DeploymentConfig = Readonly<{

config: TypesGen.DeploymentValues;

options: TypesGen.SerpentOption[];

}>;

/**

* Fetches `items` in concurrent batches of at most `batchSize`, resolving

* with one response per batch, in input order.

*/

async function fetchInBatches<Item, Response>(

items: readonly Item[],

batchSize: number,

fetchBatch: (batch: readonly Item[]) => Promise<Response>,

): Promise<Response[]> {

const batches: Promise<Response>[] = [];

for (let i = 0; i < items.length; i += batchSize) {

batches.push(fetchBatch(items.slice(i, i + batchSize)));

}

return Promise.all(batches);

}

/** The AI spend endpoints reject requests with more than 100 IDs. */

const aiSpendBatchSize = 100;

const aiProviderConfigsPath = "/api/v2/ai/providers";

const aiGatewayPath = "/api/v2/ai-gateway";

const chatModelConfigsPath = "/api/experimental/chats/model-configs";

const userSkillsPath = (user: string) =>

`/api/experimental/users/${encodeURIComponent(user)}/skills`;

const userSkillPath = (user: string, name: string) =>

`${userSkillsPath(user)}/${encodeURIComponent(name)}`;

const userAIProviderKeysPath = (user = "me") =>

`/api/experimental/users/${encodeURIComponent(user)}/ai-provider-keys`;

const mcpServerConfigsPath = "/api/experimental/mcp/servers";

type Claims = {

license_expires: number;

// nbf is a standard JWT claim for "not before" - the license valid from date

nbf?: number;

account_type?: string;

account_id?: string;

trial: boolean;

all_features: boolean;

// feature_set is omitted on legacy licenses

feature_set?: string;

addons?: string[];

version: number;

features: Record<string, number>;

require_telemetry?: boolean;

};

export type GetLicensesResponse = Omit<TypesGen.License, "claims"> & {

claims: Claims;

expires_at: string;

};

export type InsightsParams = {

start_time: string;

end_time: string;

template_ids: string;

};

export type InsightsTemplateParams = InsightsParams & {

interval: "day" | "week";

};

export class ParameterValidationError extends Error {

constructor(

public readonly versionId: string,

public readonly validations: FieldError[],

) {

super("Parameters are not valid for new template version");

}

}

export type GetProvisionerJobsParams = {

status?: string;

limit?: number;

// IDs separated by comma

ids?: string;

};

export type GetProvisionerDaemonsParams = {

// IDs separated by comma

ids?: string;

// Stringified JSON Object

tags?: string;

limit?: number;

// Include offline provisioner daemons?

offline?: boolean;

};

/**

* This is the container for all API methods. It's split off to make it more

* clear where API methods should go, but it is eventually merged into the Api

* class with a more flat hierarchy

*

* All public methods should be defined as arrow functions to ensure that they

* can be passed around the React UI without losing their `this` context.

*

* This is one of the few cases where you have to worry about the difference

* between traditional methods and arrow function properties. Arrow functions

* disable JS's dynamic scope, and force all `this` references to resolve via

* lexical scope.

*/

class ApiMethods {

experimental: ExperimentalApiMethods;

constructor(protected readonly axios: AxiosInstance) {

this.experimental = new ExperimentalApiMethods(this.axios);

}

login = async (

email: string,

password: string,

): Promise<TypesGen.LoginWithPasswordResponse> => {

const payload = JSON.stringify({ email, password });

const response = await this.axios.post<TypesGen.LoginWithPasswordResponse>(

"/api/v2/users/login",

payload,

{ headers: { ...BASE_CONTENT_TYPE_JSON } },

);

return response.data;

};

convertToOAUTH = async (request: TypesGen.ConvertLoginRequest) => {

const response = await this.axios.post<TypesGen.OAuthConversionResponse>(

"/api/v2/users/me/convert-login",

request,

);

return response.data;

};

logout = async (): Promise<void> => {

return this.axios.post("/api/v2/users/logout");

};

getAuthenticatedUser = async () => {

const response = await this.axios.get<TypesGen.User>("/api/v2/users/me");

return response.data;

};

getUserAISpend = async (): Promise<TypesGen.UserAISpendStatus> => {

const response = await this.axios.get<TypesGen.UserAISpendStatus>(

"/api/v2/users/me/ai/spend",

);

return response.data;

};

getUser = async (usernameOrId: string) => {

const response = await this.axios.get<TypesGen.User>(

`/api/v2/users/${encodeURIComponent(usernameOrId)}`,

);

return response.data;

};

getUserParameters = async (templateID: string) => {

const response = await this.axios.get<TypesGen.UserParameter[]>(

`/api/v2/users/me/autofill-parameters?template_id=${templateID}`,

);

return response.data;

};

getAuthMethods = async (): Promise<TypesGen.AuthMethods> => {

const response = await this.axios.get<TypesGen.AuthMethods>(

"/api/v2/users/authmethods",

);

return response.data;

};

getUserLoginType = async (): Promise<TypesGen.UserLoginType> => {

const response = await this.axios.get<TypesGen.UserLoginType>(

"/api/v2/users/me/login-type",

);

return response.data;

};

checkAuthorization = async <TResponse extends TypesGen.AuthorizationResponse>(

params: TypesGen.AuthorizationRequest,

) => {

const response = await this.axios.post<TResponse>(

"/api/v2/authcheck",

params,

);

return response.data;

};

getApiKey = async (): Promise<TypesGen.GenerateAPIKeyResponse> => {

const response = await this.axios.post<TypesGen.GenerateAPIKeyResponse>(

"/api/v2/users/me/keys",

);

return response.data;

};

getTokens = async (

params: TypesGen.TokensFilter,

): Promise<TypesGen.APIKeyWithOwner[]> => {

const response = await this.axios.get<TypesGen.APIKeyWithOwner[]>(

"/api/v2/users/me/keys/tokens",

{ params },

);

return response.data;

};

deleteToken = async (keyId: string): Promise<void> => {

await this.axios.delete(`/api/v2/users/me/keys/${keyId}`);

};

createToken = async (

params: TypesGen.CreateTokenRequest,

): Promise<TypesGen.GenerateAPIKeyResponse> => {

const response = await this.axios.post(

"/api/v2/users/me/keys/tokens",

params,

);

return response.data;

};

getTokenConfig = async (): Promise<TypesGen.TokenConfig> => {

const response = await this.axios.get(

"/api/v2/users/me/keys/tokens/tokenconfig",

);

return response.data;

};

getUsers = async (

options: TypesGen.UsersRequest,

signal?: AbortSignal,

): Promise<TypesGen.GetUsersResponse> => {

const url = getURLWithSearchParams("/api/v2/users", options);

const response = await this.axios.get<TypesGen.GetUsersResponse>(

url.toString(),

{ signal },

);

return response.data;

};

/**

* Get users for workspace owner selection. Requires

* permission to create workspaces for other users in the

* organization. Returns minimal user data (no email, roles,

* etc.).

*/

getWorkspaceAvailableUsers = async (

organizationId: string,

options: TypesGen.UsersRequest,

signal?: AbortSignal,

): Promise<TypesGen.MinimalUser[]> => {

const url = getURLWithSearchParams(

`/api/v2/organizations/${organizationId}/members/me/workspaces/available-users`,

options,

);

const response = await this.axios.get<TypesGen.MinimalUser[]>(

url.toString(),

{ signal },

);

return response.data;

};

createOrganization = async (params: TypesGen.CreateOrganizationRequest) => {

const response = await this.axios.post<TypesGen.Organization>(

"/api/v2/organizations",

params,

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

updateOrganization = async (

organization: string,

params: TypesGen.UpdateOrganizationRequest,

) => {

const response = await this.axios.patch<TypesGen.Organization>(

`/api/v2/organizations/${organization}`,

params,

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

deleteOrganization = async (organization: string) => {

await this.axios.delete<TypesGen.Organization>(

`/api/v2/organizations/${organization}`,

);

};

/**

* @param organization Can be the organization's ID or name

*/

getOrganization = async (

organization: string,

): Promise<TypesGen.Organization> => {

const response = await this.axios.get<TypesGen.Organization>(

`/api/v2/organizations/${organization}`,

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

getOrganizationMembers = async (organization: string) => {

const response = await this.axios.get<

TypesGen.OrganizationMemberWithUserData[]

>(`/api/v2/organizations/${organization}/members`);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

* @param options Pagination options

*/

getOrganizationPaginatedMembers = async (

organization: string,

options?: TypesGen.UsersRequest,

) => {

const url = getURLWithSearchParams(

`/api/v2/organizations/${organization}/paginated-members`,

options,

);

const response =

await this.axios.get<TypesGen.PaginatedMembersResponse>(url);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

getOrganizationRoles = async (organization: string) => {

const response = await this.axios.get<TypesGen.AssignableRoles[]>(

`/api/v2/organizations/${organization}/members/roles`,

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

updateOrganizationMemberRoles = async (

organization: string,

userId: string,

roles: TypesGen.SlimRole["name"][],

): Promise<TypesGen.User> => {

const response = await this.axios.put<TypesGen.User>(

`/api/v2/organizations/${organization}/members/${userId}/roles`,

{ roles },

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

createOrganizationRole = async (

organization: string,

role: TypesGen.Role,

): Promise<TypesGen.Role> => {

const response = await this.axios.post<TypesGen.Role>(

`/api/v2/organizations/${organization}/members/roles`,

role,

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

updateOrganizationRole = async (

organization: string,

role: TypesGen.Role,

): Promise<TypesGen.Role> => {

const response = await this.axios.put<TypesGen.Role>(

`/api/v2/organizations/${organization}/members/roles`,

role,

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

deleteOrganizationRole = async (organization: string, roleName: string) => {

await this.axios.delete(

`/api/v2/organizations/${organization}/members/roles/${roleName}`,

);

};

/**

* @param organization Can be the organization's ID or name

*/

addOrganizationMember = async (organization: string, userId: string) => {

const response = await this.axios.post<TypesGen.OrganizationMember>(

`/api/v2/organizations/${organization}/members/${userId}`,

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

removeOrganizationMember = async (organization: string, userId: string) => {

await this.axios.delete(

`/api/v2/organizations/${organization}/members/${userId}`,

);

};

getOrganizations = async (): Promise<TypesGen.Organization[]> => {

const response = await this.axios.get<TypesGen.Organization[]>(

"/api/v2/organizations",

);

return response.data;

};

getMyOrganizations = async (): Promise<TypesGen.Organization[]> => {

const response = await this.axios.get<TypesGen.Organization[]>(

"/api/v2/users/me/organizations",

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

getWorkspaceSharingSettings = async (

organization: string,

): Promise<TypesGen.WorkspaceSharingSettings> => {

const response = await this.axios.get<TypesGen.WorkspaceSharingSettings>(

`/api/v2/organizations/${organization}/settings/workspace-sharing`,

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

patchWorkspaceSharingSettings = async (

organization: string,

data: TypesGen.UpdateWorkspaceSharingSettingsRequest,

): Promise<TypesGen.WorkspaceSharingSettings> => {

const response = await this.axios.patch<TypesGen.WorkspaceSharingSettings>(

`/api/v2/organizations/${organization}/settings/workspace-sharing`,

data,

);

return response.data;

};

getProvisionerDaemonsByOrganization = async (

organization: string,

params?: GetProvisionerDaemonsParams,

): Promise<TypesGen.ProvisionerDaemon[]> => {

const response = await this.axios.get<TypesGen.ProvisionerDaemon[]>(

`/api/v2/organizations/${organization}/provisionerdaemons`,

{ params },

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

getProvisionerDaemonGroupsByOrganization = async (

organization: string,

): Promise<TypesGen.ProvisionerKeyDaemons[]> => {

const response = await this.axios.get<TypesGen.ProvisionerKeyDaemons[]>(

`/api/v2/organizations/${organization}/provisionerkeys/daemons`,

);

return response.data;

};

getOrganizationIdpSyncSettings =

async (): Promise<TypesGen.OrganizationSyncSettings> => {

const response = await this.axios.get<TypesGen.OrganizationSyncSettings>(

"/api/v2/settings/idpsync/organization",

);

return response.data;

};

patchOrganizationIdpSyncSettings = async (

data: TypesGen.OrganizationSyncSettings,

) => {

const response = await this.axios.patch<TypesGen.Response>(

"/api/v2/settings/idpsync/organization",

data,

);

return response.data;

};

/**

* @param data

* @param organization Can be the organization's ID or name

*/

patchGroupIdpSyncSettings = async (

data: TypesGen.GroupSyncSettings,

organization: string,

) => {

const response = await this.axios.patch<TypesGen.Response>(

`/api/v2/organizations/${organization}/settings/idpsync/groups`,

data,

);

return response.data;

};

/**

* @param data

* @param organization Can be the organization's ID or name

*/

patchRoleIdpSyncSettings = async (

data: TypesGen.RoleSyncSettings,

organization: string,

) => {

const response = await this.axios.patch<TypesGen.Response>(

`/api/v2/organizations/${organization}/settings/idpsync/roles`,

data,

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

getGroupIdpSyncSettingsByOrganization = async (

organization: string,

): Promise<TypesGen.GroupSyncSettings> => {

const response = await this.axios.get<TypesGen.GroupSyncSettings>(

`/api/v2/organizations/${organization}/settings/idpsync/groups`,

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

getRoleIdpSyncSettingsByOrganization = async (

organization: string,

): Promise<TypesGen.RoleSyncSettings> => {

const response = await this.axios.get<TypesGen.RoleSyncSettings>(

`/api/v2/organizations/${organization}/settings/idpsync/roles`,

);

return response.data;

};

getDeploymentIdpSyncFieldValues = async (

field: string,

): Promise<readonly string[]> => {

const params = new URLSearchParams();

params.set("claimField", field);

const response = await this.axios.get<readonly string[]>(

`/api/v2/settings/idpsync/field-values?${params}`,

);

return response.data;

};

getOrganizationIdpSyncClaimFieldValues = async (

organization: string,

field: string,

) => {

const params = new URLSearchParams();

params.set("claimField", field);

const response = await this.axios.get<readonly string[]>(

`/api/v2/organizations/${organization}/settings/idpsync/field-values?${params}`,

);

return response.data;

};

getTemplate = async (templateId: string): Promise<TypesGen.Template> => {

const response = await this.axios.get<TypesGen.Template>(

`/api/v2/templates/${templateId}`,

);

return response.data;

};

getTemplates = async (

options?: GetTemplatesOptions | GetTemplatesQuery,

): Promise<TypesGen.Template[]> => {

const params = normalizeGetTemplatesOptions(options);

const response = await this.axios.get<TypesGen.Template[]>(

"/api/v2/templates",

{ params },

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

getTemplatesByOrganization = async (

organization: string,

options?: GetTemplatesOptions,

): Promise<TypesGen.Template[]> => {

const params = normalizeGetTemplatesOptions(options);

const response = await this.axios.get<TypesGen.Template[]>(

`/api/v2/organizations/${organization}/templates`,

{ params },

);

return response.data;

};

/**

* @param organization Can be the organization's ID or name

*/

getTemplateByName = async (

organization: string,

name: string,

): Promise<TypesGen.Template> => {

const response = await this.axios.get<TypesGen.Template>(

`/api/v2/organizations/${organization}/templates/${name}`,

);

return response.data;

};

getTemplateVersion = async (

versionId: string,

): Promise<TypesGen.TemplateVersion> => {

const response = await this.axios.get<TypesGen.TemplateVersion>(

`/api/v2/templateversions/${versionId}`,

);

return response.data;

};

getTemplateVersionResources = async (

versionId: string,

): Promise<TypesGen.WorkspaceResource[]> => {

const response = await this.axios.get<TypesGen.WorkspaceResource[]>(

`/api/v2/templateversions/${versionId}/resources`,

);

return response.data;

};

getTemplateVersionVariables = async (

versionId: string,

): Promise<TypesGen.TemplateVersionVariable[]> => {

// Defined as separate variable to avoid wonky Prettier formatting because

// the type definition is so long

type VerArray = TypesGen.TemplateVersionVariable[];

const response = await this.axios.get<VerArray>(

`/api/v2/templateversions/${versionId}/variables`,

);

return response.data;

};

getTemplateVersions = async (