@superlayer/webhooks 1.0.67

package/LICENSE.md

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,4 @@
+InterfaceDB SDK
+Derived from Instant (https://github.com/instantdb/instant), revision 7607eda60547e0068f05aeb2c43ac92c6356f65d.
+Original source copyrights and licence notices are retained.
+Modified by InterfaceDB: npm package names, service defaults, tooling and documentation.

package/README.md

@@ -0,0 +1,387 @@
+# @superlayer/webhooks
+
+Webhook handlers for Superlayer.
+
+[Documentation](https://interfacedb.com/docs) · [Source](https://github.com/InterfaceLDN/Superlayer)
+
+Maintained by Superlayer, based on the Instant source. See LICENSE.md and NOTICE for attribution.
+
+Welcome to [Superlayer’s](https://interfacedb.com) webhooks library.
+
+This package gives you the building blocks for working with Instant webhooks: verifying incoming requests, dispatching records to typed handlers, and managing webhook subscriptions and their delivery history.
+
+# Where to use this
+
+The `Webhooks` class is re-exported from a few places. Use whichever fits your setup:
+
+- **From `@superlayer/admin`** — most apps. `db.webhooks` is wired up for you. An admin token is only required if you also want to manage webhooks (`db.webhooks.manager.*`); the receiving side (`processRequest` / `validate`) works without one.
+- **From `@superlayer/platform`** — building on top of Instant on behalf of other users. `api.webhooks(appId)` returns a `Webhooks` instance, and the platform SDK transparently refreshes the OAuth token for manager calls. Auth is only required if you'll use `manager.*`.
+- **Standalone from `@superlayer/webhooks`** — useful if you don't want to pull in the rest of the admin SDK. Again, no admin token is needed unless you'll call `manager.*`.
+
+## From the admin SDK
+
+```ts
+import { init } from '@superlayer/admin';
+import schema from './instant.schema';
+
+// adminToken is optional if you're only using the SDK for the receiving side
+// of webhooks (processRequest / validate / etc.). Include it if you also want
+// to use db.webhooks.manager.* — or any other admin-SDK feature that requires
+// auth, like writes or impersonation.
+const db = init({
+  appId: process.env.INSTANT_APP_ID!,
+  schema,
+});
+
+// db.webhooks is a Webhooks<typeof schema> instance.
+await db.webhooks.processRequest(handlers, req);
+```
+
+## From the platform SDK
+
+```ts
+import { PlatformApi } from '@superlayer/platform';
+import schema from './instant.schema';
+
+// Auth is optional if you're only using PlatformApi for the receiving side of
+// webhooks. Include it if you also want to use webhooks.manager.* (or any
+// other platform-SDK feature). When provided, the platform SDK refreshes the
+// OAuth token transparently for manager calls.
+const api = new PlatformApi({ auth: { token: accessToken } });
+
+const webhooks = api.webhooks(appId, { schema });
+
+await webhooks.processRequest(handlers, req);
+```
+
+## Standalone
+
+```ts
+import { Webhooks } from '@superlayer/webhooks';
+import schema from './instant.schema';
+
+// For receiving only (validate / processRequest / processPayload), the
+// adminToken is optional — you just need appId + schema for typed handlers.
+const webhooks = new Webhooks<typeof schema>({
+  appId: process.env.INSTANT_APP_ID!,
+  schema,
+});
+
+// To also manage webhooks (manager.create, manager.list, …) pass adminToken.
+const webhooksWithManager = new Webhooks<typeof schema>({
+  appId: process.env.INSTANT_APP_ID!,
+  adminToken: process.env.INSTANT_APP_ADMIN_TOKEN!,
+  schema,
+});
+```
+
+`new Webhooks(config)` accepts:
+
+- `appId` — required for `manager.*`; recommended for the receiving side so error messages and helpers are scoped.
+- `adminToken` (or `token`) — required for `manager.*`. Not needed to verify signatures or dispatch handlers.
+- `schema` — optional. Pass your schema to get fully typed `record.before` / `record.after` in handlers and typed `namespaces` on `manager.create` / `manager.update`.
+- `apiURI` — defaults to `https://api.interfacedb.com`. Override for self-hosted or local development.
+- `withAuth` — advanced hook used by the platform SDK to inject a fresh OAuth token per request; you generally won't pass this directly.
+
+The rest of this README uses `db.webhooks` in examples. The same methods exist on a standalone `Webhooks` instance or on `api.webhooks(appId)`.
+
+# Receiving webhooks
+
+## `processRequest(handlers, req, opts?)`
+
+The one-liner for handling an incoming webhook. It:
+
+1. Verifies the `Instant-Signature` header against the raw body.
+2. Fetches the records via the short-lived `payloadUrl` + JWT in the body.
+3. Dispatches each record to the matching handler.
+
+Pass it a Web [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) (Next.js App Router, Cloudflare Workers, Deno, Bun, Hono, etc.):
+
+```ts
+// app/api/instant-webhook/route.ts
+import { init } from '@superlayer/admin';
+import schema from '@/instant.schema';
+
+const db = init({
+  appId: process.env.INSTANT_APP_ID!,
+  schema,
+});
+
+const { typedHandlers, combineHandlers } = db.webhooks.helpers();
+
+const handlers = combineHandlers(
+  typedHandlers('posts', 'create', async (record) => {
+    await sendNewPostEmail(record.after);
+  }),
+  typedHandlers('posts', 'update', (record) => {
+    console.log('post %s changed', record.id, record.before, record.after);
+  }),
+  typedHandlers('$default', (record) => {
+    console.log('unhandled record', record);
+  }),
+);
+
+export async function POST(req: Request) {
+  await db.webhooks.processRequest(handlers, req);
+  return new Response('ok');
+}
+```
+
+Options:
+
+- `tolerance` — max signature age in seconds (default `300`). Protects against replays; raising this weakens that.
+- `receivedAt` — override the "now" used when checking signature age. Mostly useful in tests.
+
+Handler resolution is most-specific-wins: `namespace` + `action` → that namespace's `$default` → top-level `$default`. Records with no matching handler are skipped.
+
+Handlers run concurrently. `processRequest` resolves once all of them settle. If any handler rejects, the call rejects — return a non-2xx response so Instant retries the event.
+
+## `processNodeRequest(handlers, req, opts?)`
+
+Adapter for frameworks that hand you a Node-style `IncomingMessage` instead of a Web `Request` — Next.js Pages Router, Express, Koa, NestJS, Fastify, etc. The raw bytes of the body are required to verify the signature, so **don't put a JSON body parser in front of this route** (`express.json()`, Next's default `bodyParser`, etc.).
+
+The adapter picks up the raw body from, in order: `opts.body`, `req.rawBody`, `req.body` (if it's a `Buffer`/`Uint8Array`/string), then the unconsumed request stream.
+
+Next.js Pages Router:
+
+```ts
+// pages/api/instant-webhook.ts
+import type { NextApiRequest, NextApiResponse } from 'next';
+
+export const config = { api: { bodyParser: false } };
+
+export default async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse,
+) {
+  try {
+    await db.webhooks.processNodeRequest(handlers, req);
+    res.status(200).end();
+  } catch (e) {
+    res.status(400).json({ error: String(e) });
+  }
+}
+```
+
+Express (use `express.raw` on the webhook route only):
+
+```ts
+app.post(
+  '/webhooks/instant',
+  express.raw({ type: 'application/json' }),
+  async (req, res) => {
+    try {
+      await db.webhooks.processNodeRequest(handlers, req);
+      res.status(200).end();
+    } catch (e) {
+      res.status(400).json({ error: String(e) });
+    }
+  },
+);
+```
+
+Koa with `raw-body`:
+
+```ts
+router.post('/webhooks/instant', async (ctx) => {
+  await db.webhooks.processNodeRequest(handlers, ctx.req, {
+    body: rawBody(ctx.req), // adapter awaits the Promise
+  });
+  ctx.status = 200;
+});
+```
+
+NestJS (Express adapter, with `NestFactory.create(AppModule, { rawBody: true })`):
+
+```ts
+@Controller('webhooks')
+export class WebhooksController {
+  @Post('instant')
+  @HttpCode(200)
+  async handle(@Req() req: Request) {
+    await db.webhooks.processNodeRequest(handlers, req);
+  }
+}
+```
+
+If the adapter detects that an upstream parser turned the body into an object, it re-serializes it and tries anyway — but if the bytes don't match what Instant signed, you'll get a targeted error telling you to switch the route off the JSON parser.
+
+## `processPayload(handlers, payload)`
+
+Dispatches a payload you've already fetched. Useful when you'd rather do signature verification yourself (or when you're replaying an event from `manager.getPayload`).
+
+```ts
+const body = await db.webhooks.validate(signatureHeader, rawBody);
+const payload = await db.webhooks.fetchPayloads(body);
+await db.webhooks.processPayload(handlers, payload);
+```
+
+Same resolution rules and concurrency model as `processRequest`: handlers run in parallel, and if any of them rejects the call rejects too — return a non-2xx response so Instant retries the event. If you'd rather have a per-handler failure not fail the whole batch, wrap that handler's body in `try`/`catch`.
+
+## `validate(signatureHeader, body, opts?)`
+
+Parses an `Instant-Signature` header, verifies it against the body, and returns the `{ payloadUrl, token }` you'd use to fetch the records. Throws if the signature doesn't validate, is older than `opts.tolerance` (default 300 seconds), or the body isn't the expected shape.
+
+```ts
+const { payloadUrl, token } = await db.webhooks.validate(
+  signatureHeader,
+  rawBody,
+  { tolerance: 300 },
+);
+```
+
+`body` can be a string or a function returning a `Promise<string>` — pass the function form to defer reading the request stream until after the header has been parsed.
+
+## `validateRequest(req, opts?)`
+
+Convenience wrapper around `validate`: pulls `instant-signature` and the body off a Web `Request` for you.
+
+```ts
+const { payloadUrl, token } = await db.webhooks.validateRequest(req);
+```
+
+## `fetchPayloads({ payloadUrl, token })`
+
+Exchanges the `{ payloadUrl, token }` from a validated body for the full payload of records. Returns a `WebhookPayload<Schema>`.
+
+```ts
+const payload = await db.webhooks.fetchPayloads({ payloadUrl, token });
+console.log(payload.idempotencyKey, payload.data.length);
+```
+
+## `helpers()` and `Webhooks.helpers<Schema>()`
+
+Schema-bound helpers for building typed handler maps:
+
+- `typedHandlers(namespace, action, handler)` — typed entry for one `namespace` + `action`. Pass `'$default'` for `action` to handle every action for that namespace.
+- `typedHandlers('$default', handler)` — top-level catch-all.
+- `combineHandlers(...entries)` — merges entries into a single `WebhookHandlers` object suitable for `processRequest` / `processPayload`.
+
+Two ways to get them:
+
+```ts
+// Instance form — infers Schema from the instance, no type argument needed.
+const { typedHandlers, combineHandlers } = db.webhooks.helpers();
+
+// Static form — useful when you don't have a Webhooks instance handy.
+const { typedHandlers, combineHandlers } = Webhooks.helpers<typeof schema>();
+```
+
+Inside each handler, `record.before` and `record.after` are typed according to your schema and narrowed on `action` (`create` ⇒ `before: null`, `delete` ⇒ `after: null`).
+
+# Managing webhooks
+
+`db.webhooks.manager` exposes CRUD on webhooks and access to their delivery history. All `manager.*` methods require an `adminToken` (admin SDK) or platform OAuth token (platform SDK).
+
+## `manager.list()`
+
+Returns every webhook configured on the app, newest first. Includes both active and disabled webhooks.
+
+```ts
+const webhooks = await db.webhooks.manager.list();
+```
+
+## `manager.create({ url, namespaces, actions })`
+
+Creates a webhook in the `active` state. It starts receiving matching events immediately.
+
+```ts
+const webhook = await db.webhooks.manager.create({
+  url: 'https://example.com/instant',
+  namespaces: ['posts', 'comments'],
+  actions: ['create', 'update'],
+});
+```
+
+The server rejects the request if `url` isn't an HTTPS URL pointing at a public host, if `namespaces` doesn't reference any entity in the app's schema, if `actions` is empty, or if the app has hit its **100 active webhooks** limit.
+
+## `manager.update(webhookId, params)`
+
+Patches `url`, `namespaces`, and/or `actions`. Omitted fields keep their current value. Does not affect status — use `enable` / `disable` for that.
+
+```ts
+await db.webhooks.manager.update(webhook.id, {
+  actions: ['create', 'update'],
+});
+```
+
+## `manager.delete(webhookId)`
+
+Deletes a webhook. No further events will be queued for it. Returns the webhook as it looked just before deletion.
+
+```ts
+await db.webhooks.manager.delete(webhook.id);
+```
+
+## `manager.enable(webhookId)`
+
+Re-enables a disabled webhook. Clears `disabledReason` and resumes delivery for new events. Events that occurred while the webhook was disabled are **not** retroactively delivered.
+
+```ts
+await db.webhooks.manager.enable(webhook.id);
+```
+
+## `manager.disable(webhookId, opts?)`
+
+Stops queuing new events for a webhook. In-flight events already being processed will still complete. Optionally attach a human-readable `reason` that shows up in the dashboard.
+
+```ts
+await db.webhooks.manager.disable(webhook.id, {
+  reason: 'paused for migration',
+});
+```
+
+Instant also disables webhooks automatically after repeated delivery failures.
+
+## `manager.listEvents(webhookId, opts?)`
+
+Returns a page of delivery events for a webhook, newest first. Events are retained for ~60 days.
+
+```ts
+let cursor: string | null = null;
+do {
+  const { events, pageInfo } = await db.webhooks.manager.listEvents(
+    webhook.id,
+    {
+      after: cursor,
+    },
+  );
+  for (const event of events) {
+    console.log(event.isn, event.status, event.attempts);
+  }
+  cursor = pageInfo.hasNextPage ? pageInfo.endCursor : null;
+} while (cursor);
+```
+
+Each event's `attempts` array records, per attempt: HTTP status, response body (first 256 bytes), duration, and an `errorType` tag (`timeout`, `dns`, `connect`, `tls`, `protocol`, `network`, `unknown`) when delivery failed.
+
+## `manager.getEvent(webhookId, isn)`
+
+Fetches a single event by its `isn` (Instant Sequence Number).
+
+```ts
+const event = await db.webhooks.manager.getEvent(webhook.id, isn);
+```
+
+## `manager.getPayload(webhookId, isn)`
+
+Returns the full payload (records + `idempotencyKey`) for an event. Useful for replaying delivery locally with `processPayload`.
+
+```ts
+const payload = await db.webhooks.manager.getPayload(webhook.id, isn);
+await db.webhooks.processPayload(handlers, payload);
+```
+
+## `manager.resendEvent(webhookId, isn)`
+
+Re-queues an event for delivery, regardless of its current status. Use this to retry a `failed` event or force a redelivery of a `success` one.
+
+```ts
+await db.webhooks.manager.resendEvent(webhook.id, isn);
+```
+
+Rate-limited per event — calling it twice in quick succession returns a validation error asking you to wait about a minute.
+
+# Questions?
+
+If you have any questions, feel free to drop us a line on our [issue tracker](https://github.com/InterfaceLDN/Superlayer/issues)

package/dist/commonjs/__types__/typeUtils.d.ts

@@ -0,0 +1,12 @@
+export type Expect<T extends true> = T;
+export type ExpectTrue<T extends true> = T;
+export type ExpectFalse<T extends false> = T;
+export type IsTrue<T extends true> = T;
+export type IsFalse<T extends false> = T;
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type NotAny<T> = true extends IsAny<T> ? false : true;
+export type IsNever<T> = [T] extends [never] ? true : false;
+export type NotNever<T> = true extends IsNever<T> ? false : true;
+//# sourceMappingURL=typeUtils.d.ts.map

package/dist/commonjs/__types__/typeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.d.ts","sourceRoot":"","sources":["../../../src/__types__/typeUtils.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AACvC,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAC3C,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC;AAC7C,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AACvC,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC;AAEzC,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,IACpB,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,GAC/D,IAAI,GACJ,KAAK,CAAC;AACZ,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC;AAGrE,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AACtD,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,IAAI,SAAS,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC;AAE7D,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAC5D,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,IAAI,SAAS,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC"}

package/dist/commonjs/__types__/typeUtils.js

@@ -0,0 +1,5 @@
+"use strict";
+// Type testing utils from
+// https://github.com/type-challenges/type-challenges/blob/main/utils/index.d.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=typeUtils.js.map

package/dist/commonjs/__types__/typeUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.js","sourceRoot":"","sources":["../../../src/__types__/typeUtils.ts"],"names":[],"mappings":";AAAA,0BAA0B;AAC1B,gFAAgF","sourcesContent":["// Type testing utils from\n// https://github.com/type-challenges/type-challenges/blob/main/utils/index.d.ts\n\nexport type Expect<T extends true> = T;\nexport type ExpectTrue<T extends true> = T;\nexport type ExpectFalse<T extends false> = T;\nexport type IsTrue<T extends true> = T;\nexport type IsFalse<T extends false> = T;\n\nexport type Equal<X, Y> =\n  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2\n    ? true\n    : false;\nexport type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;\n\n// https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360\nexport type IsAny<T> = 0 extends 1 & T ? true : false;\nexport type NotAny<T> = true extends IsAny<T> ? false : true;\n\nexport type IsNever<T> = [T] extends [never] ? true : false;\nexport type NotNever<T> = true extends IsNever<T> ? false : true;\n"]}

package/dist/commonjs/__types__/typesTests.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=typesTests.d.ts.map

package/dist/commonjs/__types__/typesTests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typesTests.d.ts","sourceRoot":"","sources":["../../../src/__types__/typesTests.ts"],"names":[],"mappings":""}