@netlify/api 13.3.5

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2020 Netlify <team@netlify.com>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,182 @@
+A Netlify [OpenAPI](https://github.com/netlify/open-api) client that works in the browser and Node.js.
+
+## Usage
+
+```js
+import { NetlifyAPI } from '@netlify/api'
+
+const client = new NetlifyAPI('1234myAccessToken')
+const sites = await client.listSites()
+```
+
+## Using OpenAPI operations
+
+```js
+import { NetlifyAPI } from '@netlify/api'
+
+const client = new NetlifyAPI('1234myAccessToken')
+
+// Fetch sites
+const sites = await client.listSites()
+
+// Create a site. Notice `body` here for sending OpenAPI body
+const site = await client.createSite({
+  body: {
+    name: `my-awesome-site`,
+    // ... https://open-api.netlify.com/#/default/createSite
+  },
+})
+
+// Delete site. Notice `site_id` is a path parameter https://open-api.netlify.com/#/default/deleteSite
+await client.deleteSite({ site_id: siteId })
+```
+
+## API
+
+### `client = new NetlifyAPI([accessToken], [opts])`
+
+Create a new instance of the Netlify API client with the provided `accessToken`.
+
+`accessToken` is optional. Without it, you can't make authorized requests.
+
+`opts` includes:
+
+```js
+const opts = {
+  userAgent: 'netlify/js-client',
+  scheme: 'https',
+  host: 'api.netlify.com',
+  pathPrefix: '/api/v1',
+  accessToken: '1234myAccessToken',
+  agent: undefined, // e.g. HttpsProxyAgent
+  globalParams: {}, // parameters you want available for every request.
+  // Global params are only sent of the OpenAPI spec specifies the provided params.
+}
+```
+
+### `client.accessToken`
+
+A setter/getter that returns the `accessToken` that the client is configured to use. You can set this after the class is
+instantiated, and all subsequent calls will use the newly set `accessToken`.
+
+### `client.basePath`
+
+A getter that returns the formatted base URL of the endpoint the client is configured to use.
+
+### OpenAPI Client methods
+
+The client is dynamically generated from the [OpenAPI](https://github.com/netlify/open-api) definition file. Each method
+is is named after the `operationId` name of each operation. **To see a list of available operations, please see the
+[OpenAPI website](https://open-api.netlify.com/)**.
+
+Every OpenAPI operation has the following signature:
+
+#### `response = await client.operationId([params], [opts])`
+
+Performs a call to the given endpoint corresponding with the `operationId`. Returns a promise resolved with the body of
+the response, or rejected with an error with the details about the request attached. Rejects if the `status` > 400.
+
+- `params` is an object that includes any of the required or optional endpoint parameters.
+- `params.body` should be an object which gets serialized to JSON automatically. Any object can live here but refer to
+  the OpenAPI specification for allowed fields in a particular request body. It can also be a function returning an
+  object.
+- If the endpoint accepts `binary`, `params.body` can be a Node.js readable stream or a function returning one (e.g.
+  `() => fs.createReadStream('./foo')`). Using a function is recommended.
+
+```js
+// example params
+const params = {
+  any_param_needed: anyParamNeeded,
+  paramsCanAlsoBeCamelCase,
+  body: {
+    an: 'arbitrary js object',
+  },
+}
+```
+
+Optional `opts` can include any property you want passed to [`node-fetch`](https://github.com/bitinn/node-fetch). The
+`headers` property is merged with some `defaultHeaders`.
+
+```js
+// example opts
+const opts = {
+  headers: {
+    // Default headers
+    'User-agent': 'netlify-js-client',
+    accept: 'application/json',
+  },
+  // any other properties for node-fetch
+}
+```
+
+All operations are conveniently consumed with async/await:
+
+```js
+try {
+  const siteDeploy = await client.getSiteDeploy({
+    siteId: '1234abcd',
+    deploy_id: '4567',
+  })
+  // Calls may fail!
+} catch {
+  // handle error
+}
+```
+
+If the response includes `json` in the `contentType` header, fetch will deserialize the JSON body. Otherwise the `text`
+of the response is returned.
+
+### API Flow Methods
+
+Some methods have been added in addition to the open API operations that make certain actions simpler to perform.
+
+#### `accessToken = await client.getAccessToken(ticket, [opts])`
+
+Pass in a [`ticket`](https://open-api.netlify.com/#model-ticket) and get back an `accessToken`. Call this with the
+response from a `client.createTicket({ client_id })` call. Automatically sets the `accessToken` to `this.accessToken`
+and returns `accessToken` for the consumer to save for later.
+
+Optional `opts` include:
+
+```js
+const opts = {
+  poll: 1000, // number of ms to wait between polling
+  timeout: 3.6e6, // number of ms to wait before timing out
+}
+```
+
+See the [authenticating](https://www.netlify.com/docs/api/#authenticating) docs for more context.
+
+```js
+import open from 'open'
+
+const ticket = await client.createTicket({ clientId: CLIENT_ID })
+// Open browser for authentication
+await open(`https://app.netlify.com/authorize?response_type=ticket&ticket=${ticket.id}`)
+
+// API is also set up to use the returned access token as a side effect
+// Save this for later so you can quickly set up an authenticated client
+const accessToken = await client.getAccessToken(ticket)
+```
+
+## Proxy support
+
+**Node.js only**: If this client is used behind a corporate proxy, you can pass an `HttpsProxyAgent` or any other
+`http.Agent` that can handle your situation as `agent` option:
+
+```js
+import HttpsProxyAgent from 'https-proxy-agent'
+
+const proxyUri = 'http(s)://[user:password@]proxyhost:port'
+const agent = new HttpsProxyAgent(proxyUri)
+const client = new NetlifyAPI('1234myAccessToken', { agent })
+```
+
+## Site deployment
+
+Support for site deployment has been removed from this package in version 7.0.0. You should consider using the
+[`deploy` command](https://cli.netlify.com/commands/deploy/) of Netlify CLI.
+
+## License
+
+MIT. See [LICENSE](./LICENSE) for more details.

package/lib/index.d.ts

@@ -0,0 +1,54 @@
+import type { DynamicMethods } from './types.js';
+type APIOptions = {
+    /** @example 'netlify/js-client' */
+    userAgent?: string;
+    /** @example 'https' */
+    scheme?: string;
+    /** @example 'api.netlify.com' */
+    host?: string;
+    /** @example '/api/v1' */
+    pathPrefix?: string;
+    accessToken?: string;
+    /** @example 'HttpsProxyAgent' */
+    agent?: string;
+    /**
+     * parameters you want available for every request.
+     * Global params are only sent of the OpenAPI spec specifies the provided params.
+     */
+    globalParams?: Record<string, unknown>;
+};
+/**
+ * The Netlify API client.
+ * @see {@link https://open-api.netlify.com | Open API Reference}
+ * @see {@link https://docs.netlify.com/api/get-started | Online Documentation}
+ *
+ * @example
+ * ```ts
+ * const client = new NetlifyAPI('YOUR_ACCESS_TOKEN')
+ * const sites = await client.listSites()
+ * ```
+ */
+export interface NetlifyAPI extends DynamicMethods {
+}
+export declare class NetlifyAPI {
+    #private;
+    defaultHeaders: Record<string, string>;
+    /** The protocol is used like `https` */
+    scheme: string;
+    host: string;
+    pathPrefix: string;
+    agent?: string;
+    globalParams: Record<string, unknown>;
+    constructor(options?: APIOptions);
+    constructor(accessToken: string | undefined, options?: APIOptions);
+    /** Retrieves the access token */
+    get accessToken(): string | undefined | null;
+    set accessToken(token: string | undefined | null);
+    get basePath(): string;
+    getAccessToken(ticket: any, { poll, timeout }?: {
+        poll?: number | undefined;
+        timeout?: number | undefined;
+    }): Promise<string | undefined>;
+}
+export declare const methods: any[];
+export {};

package/lib/index.js

@@ -0,0 +1,78 @@
+import pWaitFor from 'p-wait-for';
+import { getMethods } from './methods/index.js';
+import { openApiSpec } from './open_api.js';
+import { getOperations } from './operations.js';
+// 1 second
+const DEFAULT_TICKET_POLL = 1e3;
+// 1 hour
+const DEFAULT_TICKET_TIMEOUT = 3.6e6;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+export class NetlifyAPI {
+    #accessToken = null;
+    defaultHeaders = {
+        accept: 'application/json',
+    };
+    /** The protocol is used like `https` */
+    scheme;
+    host;
+    pathPrefix;
+    agent;
+    globalParams = {};
+    constructor(firstArg, secondArg) {
+        // variadic arguments
+        const [accessTokenInput, options = {}] = typeof firstArg === 'object' ? [null, firstArg] : [firstArg, secondArg];
+        this.globalParams = options.globalParams || {};
+        this.agent = options.agent;
+        this.scheme = options.scheme || openApiSpec.schemes[0];
+        this.host = options.host || openApiSpec.host;
+        this.pathPrefix = options.pathPrefix || openApiSpec.basePath;
+        // use the setter to set the header as well
+        this.accessToken = options.accessToken || accessTokenInput || null;
+        this.defaultHeaders['User-agent'] = options.userAgent || 'netlify/js-client';
+        const methods = getMethods({
+            basePath: this.basePath,
+            defaultHeaders: this.defaultHeaders,
+            agent: this.agent,
+            globalParams: this.globalParams,
+        });
+        Object.assign(this, { ...methods });
+    }
+    /** Retrieves the access token */
+    get accessToken() {
+        return this.#accessToken;
+    }
+    set accessToken(token) {
+        if (!token) {
+            delete this.defaultHeaders.Authorization;
+            this.#accessToken = null;
+            return;
+        }
+        this.#accessToken = token;
+        this.defaultHeaders.Authorization = `Bearer ${this.#accessToken}`;
+    }
+    get basePath() {
+        return `${this.scheme}://${this.host}${this.pathPrefix}`;
+    }
+    async getAccessToken(ticket, { poll = DEFAULT_TICKET_POLL, timeout = DEFAULT_TICKET_TIMEOUT } = {}) {
+        const { id } = ticket;
+        // ticket capture
+        let authorizedTicket;
+        const checkTicket = async () => {
+            const t = await this.showTicket({ ticketId: id });
+            if (t.authorized) {
+                authorizedTicket = t;
+            }
+            return Boolean(t.authorized);
+        };
+        await pWaitFor(checkTicket, {
+            interval: poll,
+            timeout,
+            message: 'Timeout while waiting for ticket grant',
+        });
+        const accessTokenResponse = await this.exchangeTicket({ ticketId: authorizedTicket.id });
+        // See https://open-api.netlify.com/#/default/exchangeTicket for shape
+        this.accessToken = accessTokenResponse.access_token;
+        return accessTokenResponse.access_token;
+    }
+}
+export const methods = getOperations();

package/lib/methods/body.d.ts

@@ -0,0 +1 @@
+export function addBody(body: any, parameters: any, opts: any): any;

package/lib/methods/body.js

@@ -0,0 +1,25 @@
+// Handle request body
+export const addBody = function (body, parameters, opts) {
+    if (!body) {
+        return opts;
+    }
+    const bodyA = typeof body === 'function' ? body() : body;
+    if (isBinaryBody(parameters)) {
+        return {
+            ...opts,
+            body: bodyA,
+            headers: { 'Content-Type': 'application/octet-stream', ...opts.headers },
+        };
+    }
+    return {
+        ...opts,
+        body: JSON.stringify(bodyA),
+        headers: { 'Content-Type': 'application/json', ...opts.headers },
+    };
+};
+const isBinaryBody = function (parameters) {
+    return Object.values(parameters.body).some(isBodyParam);
+};
+const isBodyParam = function ({ schema }) {
+    return schema && schema.format === 'binary';
+};

package/lib/methods/index.d.ts

@@ -0,0 +1,6 @@
+export function getMethods({ basePath, defaultHeaders, agent, globalParams }: {
+    basePath: any;
+    defaultHeaders: any;
+    agent: any;
+    globalParams: any;
+}): any;

package/lib/methods/index.js

@@ -0,0 +1,84 @@
+import fetch from 'node-fetch';
+import { getOperations } from '../operations.js';
+import { addBody } from './body.js';
+import { getRequestParams } from './params.js';
+import { parseResponse, getFetchError } from './response.js';
+import { shouldRetry, waitForRetry, MAX_RETRY } from './retry.js';
+import { getUrl } from './url.js';
+// For each OpenAPI operation, add a corresponding method.
+// The `operationId` is the method name.
+export const getMethods = function ({ basePath, defaultHeaders, agent, globalParams }) {
+    const operations = getOperations();
+    const methods = operations.map((method) => getMethod({ method, basePath, defaultHeaders, agent, globalParams }));
+    return Object.assign({}, ...methods);
+};
+const getMethod = function ({ method, basePath, defaultHeaders, agent, globalParams }) {
+    return {
+        [method.operationId](params, opts) {
+            return callMethod({ method, basePath, defaultHeaders, agent, globalParams, params, opts });
+        },
+    };
+};
+const callMethod = async function ({ method, basePath, defaultHeaders, agent, globalParams, params, opts }) {
+    const requestParams = { ...globalParams, ...params };
+    const url = getUrl(method, basePath, requestParams);
+    const response = await makeRequestOrRetry({ url, method, defaultHeaders, agent, requestParams, opts });
+    const parsedResponse = await parseResponse(response);
+    return parsedResponse;
+};
+const getOpts = function ({ method: { verb, parameters }, defaultHeaders, agent, requestParams, opts }) {
+    const { body } = requestParams;
+    const optsA = addHttpMethod(verb, opts);
+    const optsB = addHeaderParams(parameters, requestParams, optsA);
+    const optsC = addDefaultHeaders(defaultHeaders, optsB);
+    const optsD = addBody(body, parameters, optsC);
+    const optsE = addAgent(agent, optsD);
+    return optsE;
+};
+// Add header parameters
+const addHeaderParams = function (parameters, requestParams, opts) {
+    if (parameters.header === undefined) {
+        return opts;
+    }
+    return { ...opts, headers: getRequestParams(parameters.header, requestParams, 'header parameter') };
+};
+// Add the HTTP method based on the OpenAPI definition
+const addHttpMethod = function (verb, opts) {
+    return { ...opts, method: verb.toUpperCase() };
+};
+// Assign default HTTP headers
+const addDefaultHeaders = function (defaultHeaders, opts) {
+    return { ...opts, headers: { ...defaultHeaders, ...opts.headers } };
+};
+// Assign fetch agent (like for example HttpsProxyAgent) if there is one
+const addAgent = function (agent, opts) {
+    if (agent) {
+        return { ...opts, agent };
+    }
+    return opts;
+};
+const makeRequestOrRetry = async function ({ url, method, defaultHeaders, agent, requestParams, opts }) {
+    // Using a loop is simpler here
+    for (let index = 0; index <= MAX_RETRY; index++) {
+        const optsA = getOpts({ method, defaultHeaders, agent, requestParams, opts });
+        const { response, error } = await makeRequest(url, optsA);
+        if (shouldRetry({ response, error, method }) && index !== MAX_RETRY) {
+            await waitForRetry(response);
+            continue;
+        }
+        if (error !== undefined) {
+            throw error;
+        }
+        return response;
+    }
+};
+const makeRequest = async function (url, opts) {
+    try {
+        const response = await fetch(url, opts);
+        return { response };
+    }
+    catch (error) {
+        const errorA = getFetchError(error, url, opts);
+        return { error: errorA };
+    }
+};

package/lib/methods/params.d.ts

@@ -0,0 +1 @@
+export function getRequestParams(params: any, requestParams: any, name: any): any;

package/lib/methods/params.js

@@ -0,0 +1,14 @@
+import { camelCase } from 'lodash-es';
+export const getRequestParams = function (params, requestParams, name) {
+    const entries = Object.values(params).map((param) => getRequestParam(param, requestParams, name));
+    return Object.assign({}, ...entries);
+};
+const getRequestParam = function (param, requestParams, name) {
+    const value = requestParams[param.name] || requestParams[camelCase(param.name)];
+    if (value !== undefined) {
+        return { [param.name]: value };
+    }
+    if (param.required) {
+        throw new Error(`Missing required ${name} '${param.name}'`);
+    }
+};

package/lib/methods/response.d.ts

@@ -0,0 +1,2 @@
+export function parseResponse(response: any): Promise<any>;
+export function getFetchError(error: any, url: any, opts: any): any;

package/lib/methods/response.js

@@ -0,0 +1,44 @@
+import { JSONHTTPError, TextHTTPError } from 'micro-api-client';
+import omit from '../omit.js';
+// Read and parse the HTTP response
+export const parseResponse = async function (response) {
+    const responseType = getResponseType(response);
+    const textResponse = await response.text();
+    const parsedResponse = parseJsonResponse(response, textResponse, responseType);
+    if (!response.ok) {
+        const ErrorType = responseType === 'json' ? JSONHTTPError : TextHTTPError;
+        throw addFallbackErrorMessage(new ErrorType(response, parsedResponse), textResponse);
+    }
+    return parsedResponse;
+};
+const getResponseType = function ({ headers }) {
+    const contentType = headers.get('Content-Type');
+    if (contentType != null && contentType.includes('json')) {
+        return 'json';
+    }
+    return 'text';
+};
+const parseJsonResponse = function (response, textResponse, responseType) {
+    if (responseType === 'text') {
+        return textResponse;
+    }
+    try {
+        return JSON.parse(textResponse);
+    }
+    catch {
+        throw addFallbackErrorMessage(new TextHTTPError(response, textResponse), textResponse);
+    }
+};
+const addFallbackErrorMessage = function (error, textResponse) {
+    error.message = error.message || textResponse;
+    return error;
+};
+export const getFetchError = function (error, url, opts) {
+    const data = omit(opts, ['Authorization']);
+    if (error.name !== 'FetchError') {
+        error.name = 'FetchError';
+    }
+    error.url = url;
+    error.data = data;
+    return error;
+};

package/lib/methods/retry.d.ts

@@ -0,0 +1,7 @@
+export function shouldRetry({ response, error, method }: {
+    response?: {} | undefined;
+    error?: {} | undefined;
+    method?: {} | undefined;
+}): boolean;
+export function waitForRetry(response: any): Promise<void>;
+export const MAX_RETRY: 5;

package/lib/methods/retry.js

@@ -0,0 +1,40 @@
+// We retry:
+//  - when receiving a rate limiting response
+//  - on network failures due to timeouts
+export const shouldRetry = function ({ response = {}, error = {}, method = {} }) {
+    if (response.status === RATE_LIMIT_STATUS || RETRY_ERROR_CODES.has(error.code)) {
+        return true;
+    }
+    // Special case for the `getLatestPluginRuns` endpoint.
+    // See https://github.com/netlify/bitballoon/issues/9616.
+    if (method.operationId === 'getLatestPluginRuns' && response.status === 500) {
+        return true;
+    }
+    return false;
+};
+export const waitForRetry = async function (response) {
+    const delay = getDelay(response);
+    await sleep(delay);
+};
+const getDelay = function (response) {
+    if (response === undefined) {
+        return DEFAULT_RETRY_DELAY;
+    }
+    const rateLimitReset = response.headers.get(RATE_LIMIT_HEADER);
+    if (!rateLimitReset) {
+        return DEFAULT_RETRY_DELAY;
+    }
+    return Math.max(Number(rateLimitReset) * SECS_TO_MSECS - Date.now(), MIN_RETRY_DELAY);
+};
+const sleep = function (ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+};
+const DEFAULT_RETRY_DELAY = 5e3;
+const MIN_RETRY_DELAY = 1e3;
+const SECS_TO_MSECS = 1e3;
+export const MAX_RETRY = 5;
+const RATE_LIMIT_STATUS = 429;
+const RATE_LIMIT_HEADER = 'X-RateLimit-Reset';
+const RETRY_ERROR_CODES = new Set(['ETIMEDOUT', 'ECONNRESET']);

package/lib/methods/url.d.ts

@@ -0,0 +1,4 @@
+export function getUrl({ path, parameters }: {
+    path: any;
+    parameters: any;
+}, basePath: any, requestParams: any): any;

package/lib/methods/url.js

@@ -0,0 +1,24 @@
+import queryString from 'qs';
+import { getRequestParams } from './params.js';
+// Replace path parameters and query parameters in the URI, using the OpenAPI
+// definition
+export const getUrl = function ({ path, parameters }, basePath, requestParams) {
+    const url = `${basePath}${path}`;
+    const urlA = addPathParams(url, parameters, requestParams);
+    const urlB = addQueryParams(urlA, parameters, requestParams);
+    return urlB;
+};
+const addPathParams = function (url, parameters, requestParams) {
+    const pathParams = getRequestParams(parameters.path, requestParams, 'path variable');
+    return Object.entries(pathParams).reduce(addPathParam, url);
+};
+const addPathParam = function (url, [name, value]) {
+    return url.replace(`{${name}}`, value);
+};
+const addQueryParams = function (url, parameters, requestParams) {
+    const queryParams = getRequestParams(parameters.query, requestParams, 'query variable');
+    if (Object.keys(queryParams).length === 0) {
+        return url;
+    }
+    return `${url}?${queryString.stringify(queryParams, { arrayFormat: 'brackets' })}`;
+};

package/lib/omit.d.ts

@@ -0,0 +1 @@
+export default function omit<T extends Record<string | number | symbol, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;

package/lib/omit.js

@@ -0,0 +1,7 @@
+export default function omit(obj, keys) {
+    const shallowCopy = { ...obj };
+    for (const key of keys) {
+        delete shallowCopy[key];
+    }
+    return shallowCopy;
+}

package/lib/open_api.d.ts

@@ -0,0 +1 @@
+export const openApiSpec: any;

package/lib/open_api.js

@@ -0,0 +1,5 @@
+import { createRequire } from 'module';
+// TODO: remove once Node.js supports JSON imports with pure ES modules without
+// any experimental flags
+const require = createRequire(import.meta.url);
+export const openApiSpec = require('@netlify/open-api');

package/lib/operations.d.ts

@@ -0,0 +1 @@
+export function getOperations(): any[];

package/lib/operations.js

@@ -0,0 +1,19 @@
+import omit from './omit.js';
+import { openApiSpec } from './open_api.js';
+// Retrieve all OpenAPI operations
+export const getOperations = function () {
+    return Object.entries(openApiSpec.paths).flatMap(([path, pathItem]) => {
+        const operations = omit(pathItem, ['parameters']);
+        return Object.entries(operations).map(([method, operation]) => {
+            const parameters = getParameters(pathItem.parameters, operation.parameters);
+            return { ...operation, verb: method, path, parameters };
+        });
+    });
+};
+const getParameters = function (pathParameters = [], operationParameters = []) {
+    const parameters = [...pathParameters, ...operationParameters];
+    return parameters.reduce(addParameter, { path: {}, query: {}, body: {} });
+};
+const addParameter = function (parameters, param) {
+    return { ...parameters, [param.in]: { ...parameters[param.in], [param.name]: param } };
+};

package/lib/types.d.ts

@@ -0,0 +1,129 @@
+import type { ReadStream } from 'node:fs';
+import type { operations } from '@netlify/open-api';
+import type { RequestInit } from 'node-fetch';
+/**
+ * Determines whether all keys in T are optional.
+ */
+type AreAllOptional<T> = keyof T extends never ? true : T extends Record<string, any> ? {
+    [K in keyof T]-?: undefined extends T[K] ? never : K;
+}[keyof T] extends never ? true : false : false;
+/**
+ * Determines whether `path` and `query` are both optional.
+ */
+type IsPathAndQueryOptional<K extends keyof operations> = 'parameters' extends keyof operations[K] ? AreAllOptional<'path' extends keyof operations[K]['parameters'] ? operations[K]['parameters']['path'] : object> extends true ? AreAllOptional<'query' extends keyof operations[K]['parameters'] ? operations[K]['parameters']['query'] : object> extends true ? true : false : false : true;
+/**
+ * Converts snake_case to camelCase for TypeScript types.
+ */
+type CamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<CamelCase<U>>}` : S;
+/**
+ * Creates a union of both snake_case and camelCase keys with their respective types.
+ */
+type SnakeToCamel<T> = {
+    [K in keyof T as CamelCase<K & string>]: T[K];
+};
+/**
+ * Combines snake_case and camelCase parameters into one Params type.
+ */
+type Params<T> = SnakeToCamel<T> | T;
+type HasRequestBody<K extends keyof operations> = 'requestBody' extends keyof operations[K] ? operations[K]['requestBody'] extends {
+    content: any;
+} ? 'application/json' extends keyof operations[K]['requestBody']['content'] ? true : 'application/octet-stream' extends keyof operations[K]['requestBody']['content'] ? true : false : false : false;
+/**
+ * Extracts the request body type from the operation.
+ */
+type RequestBody<K extends keyof operations> = 'requestBody' extends keyof operations[K] ? operations[K]['requestBody'] extends {
+    content: any;
+} ? 'application/json' extends keyof operations[K]['requestBody']['content'] ? operations[K]['requestBody']['content']['application/json'] : 'application/octet-stream' extends keyof operations[K]['requestBody']['content'] ? ReadStream | (() => ReadStream) : never : never : never;
+type IsRequestBodyJson<K extends keyof operations> = 'requestBody' extends keyof operations[K] ? operations[K]['requestBody'] extends {
+    content: any;
+} ? 'application/json' extends keyof operations[K]['requestBody']['content'] ? true : false : false : false;
+type IsRequestBodyOctetStream<K extends keyof operations> = 'requestBody' extends keyof operations[K] ? operations[K]['requestBody'] extends {
+    content: any;
+} ? 'application/octet-stream' extends keyof operations[K]['requestBody']['content'] ? true : false : false : false;
+type RequestBodyParam<K extends keyof operations> = HasRequestBody<K> extends true ? IsRequestBodyOptional<K> extends true ? DetailedRequestBodyOptional<K> : DetailedRequestBody<K> : never;
+type DetailedRequestBody<K extends keyof operations> = IsRequestBodyJson<K> extends true ? {
+    /**
+     * The request body for `application/json`.
+     * Automatically serialized to JSON based on the operation.
+     * Can be a JSON object or a function returning one.
+     */
+    body: RequestBody<K> | (() => RequestBody<K>);
+} : IsRequestBodyOctetStream<K> extends true ? {
+    /**
+     * The request body for `application/octet-stream`.
+     * Can be a Node.js readable stream or a function returning one
+     * @example
+     * fs.createReadStream('./file')
+     * @example
+     * () => fs.createReadStream('./file')
+     */
+    body: ReadStream | (() => ReadStream);
+} : never;
+type DetailedRequestBodyOptional<K extends keyof operations> = IsRequestBodyJson<K> extends true ? {
+    /**
+     * The request body for `application/json`.
+     * Automatically serialized to JSON based on the operation.
+     * Can be a JSON object or a function returning one.
+     */
+    body?: RequestBody<K> | (() => RequestBody<K>);
+} : IsRequestBodyOctetStream<K> extends true ? {
+    /**
+     * The request body for `application/octet-stream`.
+     * Can be a Node.js readable stream or a function returning one
+     * @example
+     * fs.createReadStream('./file')
+     * @example
+     * () => fs.createReadStream('./file')
+     */
+    body?: ReadStream | (() => ReadStream);
+} : never;
+/**
+ * Determines whether all properties in the request body are optional.
+ */
+type IsRequestBodyOptional<K extends keyof operations> = HasRequestBody<K> extends true ? (AreAllOptional<RequestBody<K>> extends true ? true : false) : true;
+/**
+ * Determines whether any parameters or request body are required.
+ */
+type IsParamsOrRequestBodyRequired<K extends keyof operations> = 'parameters' extends keyof operations[K] ? IsPathAndQueryOptional<K> extends true ? IsRequestBodyOptional<K> extends true ? false : true : true : false;
+/**
+ * Extracts and combines `path` and `query` parameters into a single type.
+ */
+type ExtractPathAndQueryParameters<K extends keyof operations> = 'parameters' extends keyof operations[K] ? 'path' extends keyof operations[K]['parameters'] ? 'query' extends keyof operations[K]['parameters'] ? Params<Omit<operations[K]['parameters']['path'], keyof operations[K]['parameters']['query']> & operations[K]['parameters']['query']> : Params<operations[K]['parameters']['path']> : 'query' extends keyof operations[K]['parameters'] ? Params<operations[K]['parameters']['query']> : undefined : undefined;
+/**
+ * Combines path, query, and request body parameters into a single type.
+ */
+type CombinedParamsAndRequestBody<K extends keyof operations> = HasRequestBody<K> extends true ? ExtractPathAndQueryParameters<K> & RequestBodyParam<K> : ExtractPathAndQueryParameters<K>;
+type OperationParams<K extends keyof operations> = IsParamsOrRequestBodyRequired<K> extends false ? CombinedParamsAndRequestBody<K> | void | undefined : CombinedParamsAndRequestBody<K>;
+type SuccessHttpStatusCodes = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+/**
+ * Extracts the response type from the operation.
+ */
+type OperationResponse<K extends keyof operations> = 'responses' extends keyof operations[K] ? SuccessHttpStatusCodes extends infer StatusKeys ? StatusKeys extends keyof operations[K]['responses'] ? 'content' extends keyof operations[K]['responses'][StatusKeys] ? 'application/json' extends keyof operations[K]['responses'][StatusKeys]['content'] ? operations[K]['responses'][StatusKeys]['content']['application/json'] : never : never : never : never : never;
+export type DynamicMethods = {
+    [K in keyof operations]: (params: OperationParams<K>, 
+    /**
+     * Any properties you want passed to `node-fetch`.
+     *
+     * The `headers` property is merged with some `defaultHeaders`:
+     * ```ts
+     * {
+     *  'User-agent': 'netlify-js-client',
+     *  'accept': 'application/json',
+     * }
+     * ```
+     *
+     * @example
+     * ```ts
+     * const site = await client.getSite(
+     *  { site_id: 'YOUR_SITE_ID' },
+     *  {
+     *    headers: {
+     *      'X-Example-Header': 'Example Value',
+     *    },
+     *  },
+     * )
+     * ```
+     */
+    opts?: RequestInit | void | undefined) => Promise<OperationResponse<K>>;
+};
+export {};

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@netlify/api",
+  "description": "Netlify Node.js API client",
+  "version": "13.3.5",
+  "type": "module",
+  "exports": "./lib/index.js",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib/**"
+  ],
+  "scripts": {
+    "prebuild": "rm -rf lib",
+    "build": "tsc",
+    "test": "ava",
+    "test:dev": "ava -w",
+    "test:ci": "c8 -r lcovonly -r text -r json ava"
+  },
+  "license": "MIT",
+  "author": "Netlify Inc.",
+  "contributors": [
+    "Mathias Biilmann <matt@netlify.com> (https://twitter.com/biilmann)",
+    "David Calavera <david@netlify.com> (https://twitter.com/calavera)",
+    "David Wells <david.wells@netlify.com> (https://davidwells.io/)",
+    "Bret Comnes <bcomnes@gmail.com> (https://bret.io)",
+    "Lukas Holzer <lukas.holzer@netlify.com> (https://twitter.com/luka5c0m)"
+  ],
+  "homepage": "https://github.com/netlify/build",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/netlify/build.git",
+    "directory": "packages/js-client"
+  },
+  "bugs": {
+    "url": "https://github.com/netlify/build/issues"
+  },
+  "keywords": [
+    "api client",
+    "js client",
+    "netlify",
+    "node client"
+  ],
+  "dependencies": {
+    "@netlify/open-api": "^2.37.0",
+    "lodash-es": "^4.17.21",
+    "micro-api-client": "^3.3.0",
+    "node-fetch": "^3.0.0",
+    "p-wait-for": "^5.0.0",
+    "qs": "^6.9.6"
+  },
+  "devDependencies": {
+    "@types/lodash-es": "^4.17.6",
+    "@types/node": "^14.18.53",
+    "ava": "^4.0.0",
+    "c8": "^7.11.0",
+    "from2-string": "^1.1.0",
+    "nock": "^13.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.0",
+    "uuid": "^9.0.0"
+  },
+  "engines": {
+    "node": "^14.16.0 || >=16.0.0"
+  },
+  "gitHead": "27ddc1b91d3d66780166483b42a0f6efddaa14ea"
+}