@unkey/api 0.12.1 → 0.13.1

package/dist/index.d.mts

@@ -1,395 +1,2153 @@
-type ErrorCode = "NOT_FOUND" | "BAD_REQUEST" | "UNAUTHORIZED" | "INTERNAL_SERVER_ERROR" | "RATELIMITED" | "FORBIDDEN" | "KEY_USAGE_EXCEEDED" | "INVALID_KEY_TYPE" | "NOT_UNIQUE" | "FETCH_ERROR";
-type UnkeyError = {
-    code: ErrorCode;
-    docs: string;
-    message: string;
-    requestId: string;
-};
-type ErrorResponse = {
-    error: UnkeyError;
-};
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
 
-type UnkeyOptions = ({
-    token?: never;
-    /**
-     * The root key from unkey.dev.
-     *
-     * You can create/manage your root keys here:
-     * https://unkey.dev/app/settings/root-keys
-     */
-    rootKey: string;
-} | {
-    /**
-     * The workspace key from unkey.dev
-     *
-     * @deprecated Use `rootKey`
-     */
-    token: string;
-    rootKey?: never;
-}) & {
-    /**
-     * @default https://api.unkey.dev
-     */
-    baseUrl?: string;
-    /**
-     * Retry on network errors
-     */
-    retry?: {
-        /**
-         * How many attempts should be made
-         * The maximum number of requests will be `attempts + 1`
-         * `0` means no retries
-         *
-         * @default 5
-         */
-        attempts?: number;
-        /**
-         * Return how many milliseconds to wait until the next attempt is made
-         *
-         * @default `(retryCount) => Math.round(Math.exp(retryCount) * 10)),`
-         */
-        backoff?: (retryCount: number) => number;
+
+interface paths {
+  "/v1/liveness": {
+    get: {
+      responses: {
+        /** @description The configured services and their status */
+        200: {
+          content: {
+            "application/json": {
+              /** @description The status of the server */
+              status: string;
+              services: {
+                /**
+                 * @description The name of the connected metrics service
+                 * @example AxiomMetrics
+                 */
+                metrics: string;
+                /**
+                 * @description The name of the connected logger service
+                 * @example AxiomLogger or ConsoleLogger
+                 */
+                logger: string;
+                /** @description The name of the connected ratelimit service */
+                ratelimit: string;
+                /** @description The name of the connected usagelimit service */
+                usagelimit: string;
+                /** @description The name of the connected analytics service */
+                analytics: string;
+              };
+            };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
     };
-    /**
-     * Customize the `fetch` cache behaviour
-     */
-    cache?: RequestCache;
-};
-type Result<R> = {
-    result: R;
-    error?: never;
-} | {
-    result?: never;
-    error: UnkeyError;
-};
-declare class Unkey {
-    readonly baseUrl: string;
-    private readonly rootKey;
-    private readonly cache?;
-    readonly retry: {
-        attempts: number;
-        backoff: (retryCount: number) => number;
+  };
+  "/v1/keys.getKey": {
+    get: {
+      parameters: {
+        query: {
+          keyId: string;
+        };
+      };
+      responses: {
+        /** @description The configuration for a single key */
+        200: {
+          content: {
+            "application/json": components["schemas"]["Key"];
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
     };
-    constructor(opts: UnkeyOptions);
-    private fetch;
-    get keys(): {
-        create: (req: {
+  };
+  "/v1/keys.deleteKey": {
+    post: {
+      requestBody: {
+        content: {
+          "application/json": {
             /**
-             * Provide a name to this key if you want for later reference
+             * @description The id of the key to revoke
+             * @example key_1234
              */
-            name?: string;
+            keyId: string;
+          };
+        };
+      };
+      responses: {
+        /** @description The key was successfully revoked, it may take up to 30s for this to take effect in all regions */
+        200: {
+          content: {
+            "application/json": Record<string, never>;
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/keys.createKey": {
+    post: {
+      requestBody: {
+        content: {
+          "application/json": {
             /**
-             * Choose an API where this key should be created.
+             * @description Choose an `API` where this key should be created.
+             * @example api_123
              */
             apiId: string;
             /**
-             * To make it easier for your users to understand which product an api key belongs to, you can add prefix them.
+             * @description To make it easier for your users to understand which product an api key belongs to, you can add prefix them.
              *
              * For example Stripe famously prefixes their customer ids with cus_ or their api keys with sk_live_.
              *
-             * The underscore is automtically added if you are defining a prefix, for example: "prefix": "abc" will result in a key like abc_xxxxxxxxx
+             * The underscore is automatically added if you are defining a prefix, for example: "prefix": "abc" will result in a key like abc_xxxxxxxxx
              */
             prefix?: string;
             /**
-             * The bytelength used to generate your key determines its entropy as well as its length. Higher is better, but keys become longer and more annoying to handle.
-             *
-             * The default is 16 bytes, or 2128 possible combinations
+             * @description The name for your Key. This is not customer facing.
+             * @example my key
+             */
+            name?: string;
+            /**
+             * @description The byte length used to generate your key determines its entropy as well as its length. Higher is better, but keys become longer and more annoying to handle. The default is 16 bytes, or 2^^128 possible combinations.
+             * @default 16
              */
             byteLength?: number;
             /**
-             * Your user’s Id. This will provide a link between Unkey and your customer record.
-             *
+             * @description Your user’s Id. This will provide a link between Unkey and your customer record.
              * When validating a key, we will return this back to you, so you can clearly identify your user from their api key.
+             * @example team_123
              */
             ownerId?: string;
             /**
-             * This is a place for dynamic meta data, anything that feels useful for you should go here
-             *
-             * Example:
-             *
-             * ```json
-             * {
-             *   "billingTier":"PRO",
+             * @description This is a place for dynamic meta data, anything that feels useful for you should go here
+             * @example {
+             *   "billingTier": "PRO",
              *   "trialEnds": "2023-06-16T17:16:37.161Z"
              * }
-             * ```
              */
-            meta?: unknown;
+            meta?: {
+              [key: string]: unknown;
+            };
             /**
-             * You can auto expire keys by providing a unix timestamp in milliseconds.
-             *
-             * Once keys expire they will automatically be deleted and are no longer valid.
+             * @description You can auto expire keys by providing a unix timestamp in milliseconds. Once Keys expire they will automatically be disabled and are no longer valid unless you enable them again.
+             * @example 1623869797161
              */
             expires?: number;
             /**
-             * Unkey comes with per-key ratelimiting out of the box.
-             *
-             * @see https://unkey.dev/docs/features/ratelimiting
+             * @description You can limit the number of requests a key can make. Once a key reaches 0 remaining requests, it will automatically be disabled and is no longer valid unless you update it.
+             * @example 1000
+             */
+            remaining?: number;
+            /**
+             * @description Unkey comes with per-key ratelimiting out of the box.
+             * @example {
+             *   "type": "fast",
+             *   "limit": 10,
+             *   "refillRate": 1,
+             *   "refillInterval": 60
+             * }
              */
             ratelimit?: {
-                type: "fast" | "consistent";
+              /**
+               * @description Fast ratelimiting doesn't add latency, while consistent ratelimiting is more accurate.
+               * @default fast
+               * @enum {string}
+               */
+              type: "fast" | "consistent";
+              /** @description The total amount of burstable requests. */
+              limit: number;
+              /** @description How many tokens to refill during each refillInterval. */
+              refillRate: number;
+              /** @description Determines the speed at which tokens are refilled, in milliseconds. */
+              refillInterval: number;
+            };
+          };
+        };
+      };
+      responses: {
+        /** @description The configuration for an api */
+        200: {
+          content: {
+            "application/json": {
+              /**
+               * @description The id of the key. This is not a secret and can be stored as a reference if you wish. You need the keyId to update or delete a key later.
+               * @example key_123
+               */
+              keyId: string;
+              /**
+               * @description The newly created api key, do not store this on your own system but pass it along to your user.
+               * @example prefix_xxxxxxxxx
+               */
+              key: string;
+            };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/keys.verifyKey": {
+    post: {
+      requestBody: {
+        content: {
+          "application/json": {
+            /**
+             * @description The id of the api where the key belongs to. This is optional for now but will be required soon.
+             * The key will be verified against the api's configuration. If the key does not belong to the api, the verification will fail.
+             * @example api_1234
+             */
+            apiId?: string;
+            /**
+             * @description The key to verify
+             * @example sk_1234
+             */
+            key: string;
+          };
+        };
+      };
+      responses: {
+        /** @description The verification result */
+        200: {
+          content: {
+            "application/json": {
+              /**
+               * @description The id of the key
+               * @example key_1234
+               */
+              keyId?: string;
+              /**
+               * @description Whether the key is valid or not.
+               * A key could be invalid for a number of reasons, for example if it has expired, has no more verifications left or if it has been deleted.
+               * @example true
+               */
+              valid: boolean;
+              /**
+               * @description The name of the key, give keys a name to easily identifiy their purpose
+               * @example Customer X
+               */
+              name?: string;
+              /**
+               * @description The id of the tenant associated with this key. Use whatever reference you have in your system to identify the tenant. When verifying the key, we will send this field back to you, so you know who is accessing your API.
+               * @example user_123
+               */
+              ownerId?: string;
+              /**
+               * @description Any additional metadata you want to store with the key
+               * @example {
+               *   "roles": [
+               *     "admin",
+               *     "user"
+               *   ],
+               *   "stripeCustomerId": "cus_1234"
+               * }
+               */
+              meta?: {
+                [key: string]: unknown;
+              };
+              /**
+               * @description The unix timestamp in milliseconds when the key will expire. If this field is null or undefined, the key is not expiring.
+               * @example 123
+               */
+              expires?: number;
+              /**
+               * @description The ratelimit configuration for this key. If this field is null or undefined, the key has no ratelimit.
+               * @example {
+               *   "limit": 10,
+               *   "remaining": 9,
+               *   "reset": 3600000
+               * }
+               */
+              ratelimit?: {
                 /**
-                 * The total amount of burstable requests.
+                 * @description Maximum number of requests that can be made inside a window
+                 * @example 10
                  */
                 limit: number;
                 /**
-                 * How many tokens to refill during each refillInterval
+                 * @description Remaining requests after this verification
+                 * @example 9
                  */
-                refillRate: number;
+                remaining: number;
                 /**
-                 * Determines the speed at which tokens are refilled.
-                 * In milliseconds.
+                 * @description Unix timestamp in milliseconds when the ratelimit will reset
+                 * @example 3600000
                  */
-                refillInterval: number;
+                reset: number;
+              };
+              /**
+               * @description The number of requests that can be made with this key before it becomes invalid. If this field is null or undefined, the key has no request limit.
+               * @example 1000
+               */
+              remaining?: number;
+              /**
+               * @description If the key is invalid this field will be set to the reason why it is invalid.
+               * Possible values are:
+               * - NOT_FOUND: the key does not exist or has expired
+               * - FORBIDDEN: the key is not allowed to access the api
+               * - KEY_USAGE_EXCEEDED: the key has exceeded its request limit
+               * - RATELIMITED: the key has been ratelimited,
+               *
+               * @enum {string}
+               */
+              code?: "NOT_FOUND" | "FORBIDDEN" | "KEY_USAGE_EXCEEDED" | "RATELIMITED";
             };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/keys.updateKey": {
+    post: {
+      requestBody: {
+        content: {
+          "application/json": {
             /**
-             * Unkey allows you to set/update usage limits on individual keys
-             *
-             * @see https://unkey.dev/docs/features/remaining
-             */
-            remaining?: number;
-        }) => Promise<Result<{
-            key: string;
-            keyId: string;
-        }>>;
-        update: (req: {
-            /**
-             * The id of the key to update.
+             * @description The id of the key you want to modify
+             * @example key_123
              */
             keyId: string;
             /**
-             * Update the name
+             * @description The name of the key
+             * @example Customer X
              */
             name?: string | null;
             /**
-             * Update the owner id
+             * @description The id of the tenant associated with this key. Use whatever reference you have in your system to identify the tenant. When verifying the key, we will send this field back to you, so you know who is accessing your API.
+             * @example user_123
              */
             ownerId?: string | null;
             /**
-             * This is a place for dynamic meta data, anything that feels useful for you should go here
-             *
-             * Example:
-             *
-             * ```json
-             * {
-             *   "billingTier":"PRO",
-             *   "trialEnds": "2023-06-16T17:16:37.161Z"
+             * @description Any additional metadata you want to store with the key
+             * @example {
+             *   "roles": [
+             *     "admin",
+             *     "user"
+             *   ],
+             *   "stripeCustomerId": "cus_1234"
              * }
-             * ```
              */
-            meta?: unknown | null;
+            meta?: {
+              [key: string]: unknown;
+            } | null;
             /**
-             * Update the expiration time, Unix timstamp in milliseconds
-             *
-             *
+             * @description The unix timestamp in milliseconds when the key will expire. If this field is null or undefined, the key is not expiring.
+             * @example 0
              */
             expires?: number | null;
             /**
-             * Update the ratelimit
-             *
-             * @see https://unkey.dev/docs/features/ratelimiting
+             * @description Unkey comes with per-key ratelimiting out of the box. Set `null` to disable.
+             * @example {
+             *   "type": "fast",
+             *   "limit": 10,
+             *   "refillRate": 1,
+             *   "refillInterval": 60
+             * }
              */
-            ratelimit?: {
-                type: "fast" | "consistent";
-                /**
-                 * The total amount of burstable requests.
-                 */
-                limit: number;
-                /**
-                 * How many tokens to refill during each refillInterval
-                 */
-                refillRate: number;
-                /**
-                 * Determines the speed at which tokens are refilled.
-                 * In milliseconds.
-                 */
-                refillInterval: number;
-            } | null;
+            ratelimit?: ({
+              /**
+               * @description Fast ratelimiting doesn't add latency, while consistent ratelimiting is more accurate.
+               * @enum {string}
+               */
+              type: "fast" | "consistent";
+              /** @description The total amount of burstable requests. */
+              limit: number;
+              /** @description How many tokens to refill during each refillInterval. */
+              refillRate: number;
+              /** @description Determines the speed at which tokens are refilled, in milliseconds. */
+              refillInterval: number;
+            }) | null;
             /**
-             * Update the remaining verifications.
-             *
-             * @see https://unkey.dev/docs/features/remaining
+             * @description The number of requests that can be made with this key before it becomes invalid. Set `null` to disable.
+             * @example 1000
              */
             remaining?: number | null;
-        }) => Promise<Result<{
-            key: string;
+          };
+        };
+      };
+      responses: {
+        /** @description The key was successfully updated, it may take up to 30s for this to take effect in all regions */
+        200: {
+          content: {
+            "application/json": Record<string, never>;
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/keys.updateRemaining": {
+    post: {
+      requestBody: {
+        content: {
+          "application/json": {
+            /**
+             * @description The id of the key you want to modify
+             * @example key_123
+             */
             keyId: string;
-        }>>;
-        verify: (req: {
             /**
-             * The key to verify
+             * @description The operation you want to perform on the remaining count
+             * @enum {string}
              */
-            key: string;
+            op: "increment" | "decrement" | "set";
             /**
-             * The api id to verify against
-             *
-             * This will be required soon.
+             * @description The value you want to set, add or subtract the remaining count by
+             * @example 1
              */
-            apiId?: string;
-        }) => Promise<Result<{
+            value: number | null;
+          };
+        };
+      };
+      responses: {
+        /** @description The configuration for an api */
+        200: {
+          content: {
+            "application/json": {
+              /**
+               * @description The number of remaining requests for this key after updating it. `null` means unlimited.
+               * @example 100
+               */
+              remaining: number | null;
+            };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/apis.getApi": {
+    get: {
+      parameters: {
+        query: {
+          apiId: string;
+        };
+      };
+      responses: {
+        /** @description The configuration for an api */
+        200: {
+          content: {
+            "application/json": {
+              /**
+               * @description The id of the key
+               * @example key_1234
+               */
+              id: string;
+              /**
+               * @description The id of the workspace that owns the api
+               * @example ws_1234
+               */
+              workspaceId: string;
+              /**
+               * @description The name of the api. This is internal and your users will not see this.
+               * @example Unkey - Production
+               */
+              name?: string;
+            };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/apis.createApi": {
+    post: {
+      requestBody: {
+        content: {
+          "application/json": {
             /**
-             * Whether or not this key is valid and has passed the ratelimit. If false you should not grant access to whatever the user is requesting
+             * @description The name for your API. This is not customer facing.
+             * @example my-api
              */
-            valid: boolean;
+            name: string;
+          };
+        };
+      };
+      responses: {
+        /** @description The configuration for an api */
+        200: {
+          content: {
+            "application/json": {
+              /**
+               * @description The id of the api
+               * @example api_134
+               */
+              apiId: string;
+            };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/apis.listKeys": {
+    get: {
+      parameters: {
+        query: {
+          apiId: string;
+          limit?: number;
+          cursor?: string;
+          ownerId?: string;
+        };
+      };
+      responses: {
+        /** @description The configuration for an api */
+        200: {
+          content: {
+            "application/json": {
+              keys: components["schemas"]["Key"][];
+              /**
+               * @description The cursor to use for the next page of results, if no cursor is returned, there are no more results
+               * @example eyJrZXkiOiJrZXlfMTIzNCJ9
+               */
+              cursor?: string;
+              /** @description The total number of keys for this api */
+              total: number;
+            };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/apis.deleteApi": {
+    post: {
+      requestBody: {
+        content: {
+          "application/json": {
             /**
-             * If you have set an ownerId on this key it is returned here. You can use this to clearly authenticate a user in your system.
+             * @description The id of the api to delete
+             * @example api_1234
              */
-            ownerId?: string;
+            apiId: string;
+          };
+        };
+      };
+      responses: {
+        /** @description The api was successfully deleted, it may take up to 30s for this to take effect in all regions */
+        200: {
+          content: {
+            "application/json": Record<string, never>;
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/keys/{keyId}": {
+    put: {
+      parameters: {
+        header: {
+          authorization: string;
+        };
+        path: {
+          keyId: string;
+        };
+      };
+      requestBody: {
+        content: {
+          "application/json": {
             /**
-             * This is the meta data you have set when creating the key.
-             *
-             * Example:
-             *
-             * ```json
-             * {
-             *   "billingTier":"PRO",
-             *   "trialEnds": "2023-06-16T17:16:37.161Z"
-             * }
-             * ```
+             * @description The name of the key
+             * @example Customer X
              */
-            meta?: unknown;
+            name?: string | null;
             /**
-             *  Unix timestamp in milliseconds when this key expires
-             * Only available when the key automatically expires
+             * @description The id of the tenant associated with this key. Use whatever reference you have in your system to identify the tenant. When verifying the key, we will send this field back to you, so you know who is accessing your API.
+             * @example user_123
              */
-            expires?: number;
+            ownerId?: string | null;
             /**
-             * How many verifications are remaining after the current request.
+             * @description Any additional metadata you want to store with the key
+             * @example {
+             *   "roles": [
+             *     "admin",
+             *     "user"
+             *   ],
+             *   "stripeCustomerId": "cus_1234"
+             * }
              */
-            remaining?: number;
+            meta?: {
+              [key: string]: unknown;
+            } | null;
             /**
-             * Ratelimit data if the key is ratelimited.
+             * @description The unix timestamp in milliseconds when the key will expire. If this field is null or undefined, the key is not expiring.
+             * @example 0
              */
-            ratelimit?: {
-                /**
-                 * The maximum number of requests for bursting.
-                 */
-                limit: number;
-                /**
-                 * How many requests are remaining until `reset`
-                 */
-                remaining: number;
-                /**
-                 * Unix timestamp in millisecond when the ratelimit is refilled.
-                 */
-                reset: number;
-            };
+            expires?: number | null;
             /**
-             * Machine readable code that explains why a key is invalid or could not be verified
+             * @description Unkey comes with per-key ratelimiting out of the box. Set `null` to disable.
+             * @example {
+             *   "type": "fast",
+             *   "limit": 10,
+             *   "refillRate": 1,
+             *   "refillInterval": 60
+             * }
              */
-            code?: "NOT_FOUND" | "FORBIDDEN" | "RATELIMITED" | "KEY_USAGE_EXCEEDED";
-        }>>;
-        revoke: (req: {
-            keyId: string;
-        }) => Promise<Result<void>>;
-    };
-    get apis(): {
-        create: (req: {
+            ratelimit?: ({
+              /**
+               * @description Fast ratelimiting doesn't add latency, while consistent ratelimiting is more accurate.
+               * @enum {string}
+               */
+              type: "fast" | "consistent";
+              /** @description The total amount of burstable requests. */
+              limit: number;
+              /** @description How many tokens to refill during each refillInterval. */
+              refillRate: number;
+              /** @description Determines the speed at which tokens are refilled, in milliseconds. */
+              refillInterval: number;
+            }) | null;
             /**
-             * A name for you to identify your API.
+             * @description The number of requests that can be made with this key before it becomes invalid. Set `null` to disable.
+             * @example 1000
              */
-            name: string;
-        }) => Promise<Result<{
+            remaining?: number | null;
+          };
+        };
+      };
+      responses: {
+        /** @description The key was successfully updated, it may take up to 30s for this to take effect in all regions */
+        200: {
+          content: {
+            "application/json": Record<string, never>;
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/keys/:keyId": {
+    get: {
+      parameters: {
+        header: {
+          authorization: string;
+        };
+      };
+      responses: {
+        /** @description The configuration for a single key */
+        200: {
+          content: {
+            "application/json": components["schemas"]["Key"];
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+    delete: {
+      parameters: {
+        header: {
+          authorization: string;
+        };
+      };
+      responses: {
+        /** @description The key was successfully revoked, it may take up to 30s for this to take effect in all regions */
+        200: {
+          content: {
+            "application/json": Record<string, never>;
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/keys": {
+    post: {
+      parameters: {
+        header: {
+          authorization: string;
+        };
+      };
+      requestBody: {
+        content: {
+          "application/json": {
             /**
-             * The global unique identifier of your api.
-             * You'll need this for other api requests.
+             * @description Choose an `API` where this key should be created.
+             * @example api_123
              */
             apiId: string;
-        }>>;
-        remove: (req: {
             /**
-             * The global unique identifier of your api.
-             * You'll need this for other api requests.
+             * @description To make it easier for your users to understand which product an api key belongs to, you can add prefix them.
+             *
+             * For example Stripe famously prefixes their customer ids with cus_ or their api keys with sk_live_.
+             *
+             * The underscore is automatically added if you are defining a prefix, for example: "prefix": "abc" will result in a key like abc_xxxxxxxxx
              */
-            apiId: string;
-        }) => Promise<Result<{
+            prefix?: string;
             /**
-             * The global unique identifier of your api.
-             * You'll need this for other api requests.
+             * @description The name for your Key. This is not customer facing.
+             * @example my key
              */
-            apiId: string;
-        }>>;
-        get: (req: {
+            name?: string;
             /**
-             * The api id
+             * @description The byte length used to generate your key determines its entropy as well as its length. Higher is better, but keys become longer and more annoying to handle. The default is 16 bytes, or 2^^128 possible combinations.
+             * @default 16
              */
-            apiId: string;
-        }) => Promise<Result<{
-            id: string;
-            name: string;
-            workspaceId: string;
-        }>>;
-        listKeys: (req: {
+            byteLength?: number;
             /**
-             * The api id
+             * @description Your user’s Id. This will provide a link between Unkey and your customer record.
+             * When validating a key, we will return this back to you, so you can clearly identify your user from their api key.
+             * @example team_123
              */
-            apiId: string;
+            ownerId?: string;
             /**
-             * Limit the number of returned keys, the maximum is 100.
-             *
-             * @default 100
+             * @description This is a place for dynamic meta data, anything that feels useful for you should go here
+             * @example {
+             *   "billingTier": "PRO",
+             *   "trialEnds": "2023-06-16T17:16:37.161Z"
+             * }
              */
-            limit?: number;
+            meta?: {
+              [key: string]: unknown;
+            };
             /**
-             * Specify an offset for pagination.
-             * @example:
-             * An offset of 4 will skip the first 4 keys and return keys starting at the 5th position.
-             *
-             * @default 0
+             * @description You can auto expire keys by providing a unix timestamp in milliseconds. Once Keys expire they will automatically be disabled and are no longer valid unless you enable them again.
+             * @example 1623869797161
              */
-            offset?: number;
+            expires?: number;
             /**
-             * If provided, this will only return keys where the ownerId matches.
+             * @description You can limit the number of requests a key can make. Once a key reaches 0 remaining requests, it will automatically be disabled and is no longer valid unless you update it.
+             * @example 1000
              */
-            ownerId?: string;
-        }) => Promise<Result<{
-            keys: {
-                id: string;
-                apiId: string;
-                ownerId?: string;
-                workspaceId: string;
-                start: string;
-                createdAt: number;
-                name?: string;
-                expires?: number;
-                remaining?: number;
-                meta?: unknown;
-                ratelimit?: {
-                    type: "fast" | "consistent";
-                    limit: number;
-                    refillRate: number;
-                    refillInterval: number;
-                };
-            }[];
-            total: number;
-        }>>;
+            remaining?: number;
+            /**
+             * @description Unkey comes with per-key ratelimiting out of the box.
+             * @example {
+             *   "type": "fast",
+             *   "limit": 10,
+             *   "refillRate": 1,
+             *   "refillInterval": 60
+             * }
+             */
+            ratelimit?: {
+              /**
+               * @description Fast ratelimiting doesn't add latency, while consistent ratelimiting is more accurate.
+               * @default fast
+               * @enum {string}
+               */
+              type: "fast" | "consistent";
+              /** @description The total amount of burstable requests. */
+              limit: number;
+              /** @description How many tokens to refill during each refillInterval. */
+              refillRate: number;
+              /** @description Determines the speed at which tokens are refilled, in milliseconds. */
+              refillInterval: number;
+            };
+          };
+        };
+      };
+      responses: {
+        /** @description The configuration for an api */
+        200: {
+          content: {
+            "application/json": {
+              /**
+               * @description The id of the key. This is not a secret and can be stored as a reference if you wish. You need the keyId to update or delete a key later.
+               * @example key_123
+               */
+              keyId: string;
+              /**
+               * @description The newly created api key, do not store this on your own system but pass it along to your user.
+               * @example prefix_xxxxxxxxx
+               */
+              key: string;
+            };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
     };
-    /**
-     * Must be authenticated via app token
-     */
-    get _internal(): {
-        createRootKey: (req: {
+  };
+  "/v1/keys/verify": {
+    post: {
+      requestBody: {
+        content: {
+          "application/json": {
             /**
-             * Provide a name to this key if you want for later reference
+             * @description The id of the api where the key belongs to. This is optional for now but will be required soon.
+             * The key will be verified against the api's configuration. If the key does not belong to the api, the verification will fail.
+             * @example api_1234
              */
-            name?: string;
+            apiId?: string;
             /**
-             * You can auto expire keys by providing a unix timestamp in milliseconds.
-             *
-             * Once keys expire they will automatically be deleted and are no longer valid.
+             * @description The key to verify
+             * @example sk_1234
              */
-            expires?: number;
-            forWorkspaceId: string;
-        }) => Promise<Result<{
             key: string;
-            keyId: string;
-        }>>;
-        deleteRootKey: (req: {
+          };
+        };
+      };
+      responses: {
+        /** @description The verification result */
+        200: {
+          content: {
+            "application/json": {
+              /**
+               * @description The id of the key
+               * @example key_1234
+               */
+              keyId?: string;
+              /**
+               * @description Whether the key is valid or not.
+               * A key could be invalid for a number of reasons, for example if it has expired, has no more verifications left or if it has been deleted.
+               * @example true
+               */
+              valid: boolean;
+              /**
+               * @description The name of the key, give keys a name to easily identifiy their purpose
+               * @example Customer X
+               */
+              name?: string;
+              /**
+               * @description The id of the tenant associated with this key. Use whatever reference you have in your system to identify the tenant. When verifying the key, we will send this field back to you, so you know who is accessing your API.
+               * @example user_123
+               */
+              ownerId?: string;
+              /**
+               * @description Any additional metadata you want to store with the key
+               * @example {
+               *   "roles": [
+               *     "admin",
+               *     "user"
+               *   ],
+               *   "stripeCustomerId": "cus_1234"
+               * }
+               */
+              meta?: {
+                [key: string]: unknown;
+              };
+              /**
+               * @description The unix timestamp in milliseconds when the key was created
+               * @example 0
+               */
+              createdAt: number;
+              /**
+               * @description The unix timestamp in milliseconds when the key was deleted. We don't delete the key outright, you can restore it later.
+               * @example 0
+               */
+              deletedAt?: number;
+              /**
+               * @description The unix timestamp in milliseconds when the key will expire. If this field is null or undefined, the key is not expiring.
+               * @example 123
+               */
+              expires?: number;
+              /**
+               * @description The ratelimit configuration for this key. If this field is null or undefined, the key has no ratelimit.
+               * @example {
+               *   "limit": 10,
+               *   "remaining": 9,
+               *   "reset": 3600000
+               * }
+               */
+              ratelimit?: {
+                /**
+                 * @description Maximum number of requests that can be made inside a window
+                 * @example 10
+                 */
+                limit: number;
+                /**
+                 * @description Remaining requests after this verification
+                 * @example 9
+                 */
+                remaining: number;
+                /**
+                 * @description Unix timestamp in milliseconds when the ratelimit will reset
+                 * @example 3600000
+                 */
+                reset: number;
+              };
+              /**
+               * @description The number of requests that can be made with this key before it becomes invalid. If this field is null or undefined, the key has no request limit.
+               * @example 1000
+               */
+              remaining?: number;
+              /**
+               * @description If the key is invalid this field will be set to the reason why it is invalid.
+               * Possible values are:
+               * - NOT_FOUND: the key does not exist or has expired
+               * - FORBIDDEN: the key is not allowed to access the api
+               * - KEY_USAGE_EXCEEDED: the key has exceeded its request limit
+               * - RATELIMITED: the key has been ratelimited,
+               *
+               * @example NOT_FOUND
+               * @enum {string}
+               */
+              code?: "NOT_FOUND" | "FORBIDDEN" | "KEY_USAGE_EXCEEDED" | "RATELIMITED";
+            };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/apis": {
+    post: {
+      requestBody: {
+        content: {
+          "application/json": {
             /**
-             *  Used to create root keys from the frontend, please ignore
+             * @description The name for your API. This is not customer facing.
+             * @example my-api
              */
-            keyId: string;
-        }) => Promise<Result<void>>;
+            name: string;
+          };
+        };
+      };
+      responses: {
+        /** @description The configuration for an api */
+        200: {
+          content: {
+            "application/json": {
+              /**
+               * @description The id of the api
+               * @example api_134
+               */
+              apiId: string;
+            };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/apis/{apiId}": {
+    get: {
+      parameters: {
+        path: {
+          apiId: string;
+        };
+      };
+      responses: {
+        /** @description The configuration for an api */
+        200: {
+          content: {
+            "application/json": {
+              /**
+               * @description The id of the key
+               * @example key_1234
+               */
+              id: string;
+              /**
+               * @description The id of the workspace that owns the api
+               * @example ws_1234
+               */
+              workspaceId: string;
+              /**
+               * @description The name of the api. This is internal and your users will not see this.
+               * @example Unkey - Production
+               */
+              name?: string;
+            };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+    delete: {
+      parameters: {
+        header: {
+          authorization: string;
+        };
+        path: {
+          apiId: string;
+        };
+      };
+      responses: {
+        /** @description The api was successfully deleted, it may take up to 30s for this to take effect in all regions */
+        200: {
+          content: {
+            "application/json": Record<string, never>;
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+  "/v1/apis/{apiId}/keys": {
+    get: {
+      parameters: {
+        query?: {
+          limit?: number;
+          offset?: number | null;
+          ownerId?: string;
+        };
+        path: {
+          apiId: string;
+        };
+      };
+      responses: {
+        /** @description Keys belonging to the api */
+        200: {
+          content: {
+            "application/json": {
+              keys: components["schemas"]["Key"][];
+              /** @description The total number of keys for this api */
+              total: number;
+            };
+          };
+        };
+        /** @description The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing). */
+        400: {
+          content: {
+            "application/json": components["schemas"]["ErrBadRequest"];
+          };
+        };
+        /** @description Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response. */
+        401: {
+          content: {
+            "application/json": components["schemas"]["ErrUnauthorized"];
+          };
+        };
+        /** @description The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server. */
+        403: {
+          content: {
+            "application/json": components["schemas"]["ErrForbidden"];
+          };
+        };
+        /** @description The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web. */
+        404: {
+          content: {
+            "application/json": components["schemas"]["ErrNotFound"];
+          };
+        };
+        /** @description This response is sent when a request conflicts with the current state of the server. */
+        409: {
+          content: {
+            "application/json": components["schemas"]["ErrConflict"];
+          };
+        };
+        /** @description The user has sent too many requests in a given amount of time ("rate limiting") */
+        429: {
+          content: {
+            "application/json": components["schemas"]["ErrTooManyRequests"];
+          };
+        };
+        /** @description The server has encountered a situation it does not know how to handle. */
+        500: {
+          content: {
+            "application/json": components["schemas"]["ErrInternalServerError"];
+          };
+        };
+      };
+    };
+  };
+}
+
+interface components {
+  schemas: {
+    ErrBadRequest: {
+      error: {
+        /**
+         * @description A machine readable error code.
+         * @example BAD_REQUEST
+         * @enum {string}
+         */
+        code: "BAD_REQUEST";
+        /**
+         * @description A link to our documentation with more details about this error code
+         * @example https://docs.unkey.dev/api-reference/errors/code/BAD_REQUEST
+         */
+        docs: string;
+        /** @description A human readable explanation of what went wrong */
+        message: string;
+        /**
+         * @description Please always include the requestId in your error report
+         * @example req_1234
+         */
+        requestId: string;
+      };
+    };
+    ErrUnauthorized: {
+      error: {
+        /**
+         * @description A machine readable error code.
+         * @example UNAUTHORIZED
+         * @enum {string}
+         */
+        code: "UNAUTHORIZED";
+        /**
+         * @description A link to our documentation with more details about this error code
+         * @example https://docs.unkey.dev/api-reference/errors/code/UNAUTHORIZED
+         */
+        docs: string;
+        /** @description A human readable explanation of what went wrong */
+        message: string;
+        /**
+         * @description Please always include the requestId in your error report
+         * @example req_1234
+         */
+        requestId: string;
+      };
+    };
+    ErrForbidden: {
+      error: {
+        /**
+         * @description A machine readable error code.
+         * @example FORBIDDEN
+         * @enum {string}
+         */
+        code: "FORBIDDEN";
+        /**
+         * @description A link to our documentation with more details about this error code
+         * @example https://docs.unkey.dev/api-reference/errors/code/FORBIDDEN
+         */
+        docs: string;
+        /** @description A human readable explanation of what went wrong */
+        message: string;
+        /**
+         * @description Please always include the requestId in your error report
+         * @example req_1234
+         */
+        requestId: string;
+      };
+    };
+    ErrNotFound: {
+      error: {
+        /**
+         * @description A machine readable error code.
+         * @example NOT_FOUND
+         * @enum {string}
+         */
+        code: "NOT_FOUND";
+        /**
+         * @description A link to our documentation with more details about this error code
+         * @example https://docs.unkey.dev/api-reference/errors/code/NOT_FOUND
+         */
+        docs: string;
+        /** @description A human readable explanation of what went wrong */
+        message: string;
+        /**
+         * @description Please always include the requestId in your error report
+         * @example req_1234
+         */
+        requestId: string;
+      };
+    };
+    ErrConflict: {
+      error: {
+        /**
+         * @description A machine readable error code.
+         * @example CONFLICT
+         * @enum {string}
+         */
+        code: "CONFLICT";
+        /**
+         * @description A link to our documentation with more details about this error code
+         * @example https://docs.unkey.dev/api-reference/errors/code/CONFLICT
+         */
+        docs: string;
+        /** @description A human readable explanation of what went wrong */
+        message: string;
+        /**
+         * @description Please always include the requestId in your error report
+         * @example req_1234
+         */
+        requestId: string;
+      };
+    };
+    ErrTooManyRequests: {
+      error: {
+        /**
+         * @description A machine readable error code.
+         * @example TOO_MANY_REQUESTS
+         * @enum {string}
+         */
+        code: "TOO_MANY_REQUESTS";
+        /**
+         * @description A link to our documentation with more details about this error code
+         * @example https://docs.unkey.dev/api-reference/errors/code/TOO_MANY_REQUESTS
+         */
+        docs: string;
+        /** @description A human readable explanation of what went wrong */
+        message: string;
+        /**
+         * @description Please always include the requestId in your error report
+         * @example req_1234
+         */
+        requestId: string;
+      };
+    };
+    ErrInternalServerError: {
+      error: {
+        /**
+         * @description A machine readable error code.
+         * @example INTERNAL_SERVER_ERROR
+         * @enum {string}
+         */
+        code: "INTERNAL_SERVER_ERROR";
+        /**
+         * @description A link to our documentation with more details about this error code
+         * @example https://docs.unkey.dev/api-reference/errors/code/INTERNAL_SERVER_ERROR
+         */
+        docs: string;
+        /** @description A human readable explanation of what went wrong */
+        message: string;
+        /**
+         * @description Please always include the requestId in your error report
+         * @example req_1234
+         */
+        requestId: string;
+      };
+    };
+    Key: {
+      /**
+       * @description The id of the key
+       * @example key_1234
+       */
+      id: string;
+      /**
+       * @description The first few characters of the key to visually identify it
+       * @example sk_5j1
+       */
+      start: string;
+      /**
+       * @description The id of the workspace that owns the key
+       * @example ws_1234
+       */
+      workspaceId: string;
+      /**
+       * @description The id of the api that this key is for
+       * @example api_1234
+       */
+      apiId?: string;
+      /**
+       * @description The name of the key, give keys a name to easily identifiy their purpose
+       * @example Customer X
+       */
+      name?: string;
+      /**
+       * @description The id of the tenant associated with this key. Use whatever reference you have in your system to identify the tenant. When verifying the key, we will send this field back to you, so you know who is accessing your API.
+       * @example user_123
+       */
+      ownerId?: string;
+      /**
+       * @description Any additional metadata you want to store with the key
+       * @example {
+       *   "roles": [
+       *     "admin",
+       *     "user"
+       *   ],
+       *   "stripeCustomerId": "cus_1234"
+       * }
+       */
+      meta?: {
+        [key: string]: unknown;
+      };
+      /**
+       * @description The unix timestamp in milliseconds when the key was created
+       * @example 0
+       */
+      createdAt: number;
+      /**
+       * @description The unix timestamp in milliseconds when the key was deleted. We don't delete the key outright, you can restore it later.
+       * @example 0
+       */
+      deletedAt?: number;
+      /**
+       * @description The unix timestamp in milliseconds when the key will expire. If this field is null or undefined, the key is not expiring.
+       * @example 0
+       */
+      expires?: number;
+      /**
+       * @description The number of requests that can be made with this key before it becomes invalid. If this field is null or undefined, the key has no request limit.
+       * @example 1000
+       */
+      remaining?: number;
+      /**
+       * @description Unkey comes with per-key ratelimiting out of the box.
+       * @example {
+       *   "type": "fast",
+       *   "limit": 10,
+       *   "refillRate": 1,
+       *   "refillInterval": 60
+       * }
+       */
+      ratelimit?: {
+        /**
+         * @description Fast ratelimiting doesn't add latency, while consistent ratelimiting is more accurate.
+         * @default fast
+         * @enum {string}
+         */
+        type: "fast" | "consistent";
+        /** @description The total amount of burstable requests. */
+        limit: number;
+        /** @description How many tokens to refill during each refillInterval. */
+        refillRate: number;
+        /** @description Determines the speed at which tokens are refilled, in milliseconds. */
+        refillInterval: number;
+      };
+    };
+  };
+  responses: never;
+  parameters: {
+  };
+  requestBodies: never;
+  headers: never;
+  pathItems: never;
+}
+
+type ErrorResponse = paths["/v1/liveness"]["get"]["responses"]["500"]["content"]["application/json"];
+
+type UnkeyOptions = ({
+    token?: never;
+    /**
+     * The root key from unkey.dev.
+     *
+     * You can create/manage your root keys here:
+     * https://unkey.dev/app/settings/root-keys
+     */
+    rootKey: string;
+} | {
+    /**
+     * The workspace key from unkey.dev
+     *
+     * @deprecated Use `rootKey`
+     */
+    token: string;
+    rootKey?: never;
+}) & {
+    /**
+     * @default https://api.unkey.dev
+     */
+    baseUrl?: string;
+    /**
+     * Retry on network errors
+     */
+    retry?: {
+        /**
+         * How many attempts should be made
+         * The maximum number of requests will be `attempts + 1`
+         * `0` means no retries
+         *
+         * @default 5
+         */
+        attempts?: number;
+        /**
+         * Return how many milliseconds to wait until the next attempt is made
+         *
+         * @default `(retryCount) => Math.round(Math.exp(retryCount) * 10)),`
+         */
+        backoff?: (retryCount: number) => number;
+    };
+    /**
+     * Customize the `fetch` cache behaviour
+     */
+    cache?: RequestCache;
+    /**
+     * The version of the SDK instantiating this client.
+     *
+     * This is used for internal metrics and is not covered by semver, and may change at any time.
+     *
+     * You can leave this blank unless you are building a wrapper around this SDK.
+     */
+    wrapperSdkVersion?: `v${string}`;
+};
+type Result<R> = {
+    result: R;
+    error?: never;
+} | {
+    result?: never;
+    error: ErrorResponse["error"];
+};
+declare class Unkey {
+    readonly baseUrl: string;
+    private readonly rootKey;
+    private readonly cache?;
+    private readonly sdkVersions;
+    readonly retry: {
+        attempts: number;
+        backoff: (retryCount: number) => number;
+    };
+    constructor(opts: UnkeyOptions);
+    private fetch;
+    get keys(): {
+        create: (req: paths["/v1/keys.createKey"]["post"]["requestBody"]["content"]["application/json"]) => Promise<Result<paths["/v1/keys.createKey"]["post"]["responses"]["200"]["content"]["application/json"]>>;
+        update: (req: paths["/v1/keys.updateKey"]["post"]["requestBody"]["content"]["application/json"]) => Promise<Result<paths["/v1/keys.updateKey"]["post"]["responses"]["200"]["content"]["application/json"]>>;
+        verify: (req: paths["/v1/keys.verifyKey"]["post"]["requestBody"]["content"]["application/json"]) => Promise<Result<paths["/v1/keys.verifyKey"]["post"]["responses"]["200"]["content"]["application/json"]>>;
+        delete: (req: paths["/v1/keys.deleteKey"]["post"]["requestBody"]["content"]["application/json"]) => Promise<Result<paths["/v1/keys.deleteKey"]["post"]["responses"]["200"]["content"]["application/json"]>>;
+        updateRemaining: (req: paths["/v1/keys.updateRemaining"]["post"]["requestBody"]["content"]["application/json"]) => Promise<Result<paths["/v1/keys.updateRemaining"]["post"]["responses"]["200"]["content"]["application/json"]>>;
+        get: (req: paths["/v1/keys.getKey"]["get"]["parameters"]["query"]) => Promise<Result<paths["/v1/keys.getKey"]["get"]["responses"]["200"]["content"]["application/json"]>>;
+    };
+    get apis(): {
+        create: (req: paths["/v1/apis.createApi"]["post"]["requestBody"]["content"]["application/json"]) => Promise<Result<paths["/v1/apis.createApi"]["post"]["responses"]["200"]["content"]["application/json"]>>;
+        delete: (req: paths["/v1/apis.deleteApi"]["post"]["requestBody"]["content"]["application/json"]) => Promise<Result<paths["/v1/apis.deleteApi"]["post"]["responses"]["200"]["content"]["application/json"]>>;
+        get: (req: paths["/v1/apis.getApi"]["get"]["parameters"]["query"]) => Promise<Result<paths["/v1/apis.getApi"]["get"]["responses"]["200"]["content"]["application/json"]>>;
+        listKeys: (req: paths["/v1/apis.listKeys"]["get"]["parameters"]["query"]) => Promise<Result<paths["/v1/apis.listKeys"]["get"]["responses"]["200"]["content"]["application/json"]>>;
     };
 }
 
@@ -419,22 +2177,31 @@ declare function verifyKey(req: string | {
     apiId: string;
 }): Promise<{
     result?: undefined;
-    error: UnkeyError;
+    error: {
+        code: "INTERNAL_SERVER_ERROR";
+        docs: string;
+        message: string;
+        requestId: string;
+    };
 } | {
     result: {
+        keyId?: string | undefined;
         valid: boolean;
+        name?: string | undefined;
         ownerId?: string | undefined;
-        meta?: unknown;
+        meta?: {
+            [key: string]: unknown;
+        } | undefined;
         expires?: number | undefined;
-        remaining?: number | undefined;
         ratelimit?: {
             limit: number;
             remaining: number;
             reset: number;
         } | undefined;
-        code?: "NOT_FOUND" | "RATELIMITED" | "FORBIDDEN" | "KEY_USAGE_EXCEEDED" | undefined;
+        remaining?: number | undefined;
+        code?: "NOT_FOUND" | "FORBIDDEN" | "KEY_USAGE_EXCEEDED" | "RATELIMITED" | undefined;
     };
     error?: undefined;
 }>;
 
-export { ErrorCode, ErrorResponse, Unkey, UnkeyError, UnkeyOptions, verifyKey };
+export { ErrorResponse, Unkey, UnkeyOptions, verifyKey };