@stackframe/stack-shared 2.8.8 → 2.8.11

package/dist/esm/crud.js

@@ -0,0 +1,60 @@
+// src/crud.tsx
+import { yupObject, yupString } from "./schema-fields";
+import { filterUndefined } from "./utils/objects";
+function createCrud(options) {
+  const docs = options.docs ?? {};
+  const client = {
+    createSchema: options.clientCreateSchema,
+    createDocs: docs.clientCreate,
+    readSchema: options.clientReadSchema,
+    readDocs: docs.clientRead,
+    listDocs: docs.clientList,
+    updateSchema: options.clientUpdateSchema,
+    updateDocs: docs.clientUpdate,
+    deleteSchema: options.clientDeleteSchema,
+    deleteDocs: docs.clientDelete
+  };
+  const serverOverrides = filterUndefined({
+    createSchema: options.serverCreateSchema,
+    createDocs: docs.serverCreate,
+    readSchema: options.serverReadSchema,
+    readDocs: docs.serverRead,
+    listDocs: docs.serverList,
+    updateSchema: options.serverUpdateSchema,
+    updateDocs: docs.serverUpdate,
+    deleteSchema: options.serverDeleteSchema,
+    deleteDocs: docs.serverDelete
+  });
+  const server = {
+    ...client,
+    ...serverOverrides
+  };
+  const adminOverrides = filterUndefined({
+    createSchema: options.adminCreateSchema,
+    createDocs: docs.adminCreate,
+    readSchema: options.adminReadSchema,
+    readDocs: docs.adminRead,
+    listDocs: docs.adminList,
+    updateSchema: options.adminUpdateSchema,
+    updateDocs: docs.adminUpdate,
+    deleteSchema: options.adminDeleteSchema,
+    deleteDocs: docs.adminDelete
+  });
+  const admin = {
+    ...server,
+    ...adminOverrides
+  };
+  return {
+    client,
+    server,
+    admin,
+    hasCreate: !!admin.createSchema,
+    hasRead: !!admin.readSchema,
+    hasUpdate: !!admin.updateSchema,
+    hasDelete: !!admin.deleteSchema
+  };
+}
+export {
+  createCrud
+};
+//# sourceMappingURL=crud.js.map

package/dist/esm/crud.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/crud.tsx"],"sourcesContent":["import * as yup from 'yup';\nimport { yupObject, yupString } from './schema-fields';\nimport { filterUndefined } from './utils/objects';\nimport { NullishCoalesce } from './utils/types';\n\nexport type AccessType = \"client\" | \"server\" | \"admin\";\nexport type CrudOperation = \"create\" | \"read\" | \"update\" | \"delete\";\nexport type CrudlOperation = \"create\" | \"read\" | \"update\" | \"delete\" | \"list\";\nexport type AccessTypeXCrudOperation = `${AccessType}${Capitalize<CrudOperation>}`;\nexport type AccessTypeXCrudlOperation = `${AccessType}${Capitalize<CrudlOperation>}`;\n\ndeclare module 'yup' {\n  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions\n  export interface CustomSchemaMetadata {\n    openapiField?: {\n      description?: string,\n      exampleValue?: any,\n      hidden?: boolean,\n      onlyShowInOperations?: Capitalize<CrudlOperation>[],\n    },\n  }\n}\n\ntype ShownEndpointDocumentation = {\n  summary: string,\n  description: string,\n  tags?: string[],\n  crudOperation?: Capitalize<CrudlOperation>,\n};\nexport type EndpointDocumentation =\n  | ({ hidden: true } & Partial<ShownEndpointDocumentation>)\n  | ({ hidden?: boolean } & ShownEndpointDocumentation);\n\n\ntype InnerCrudSchema<\n  CreateSchema extends yup.AnySchema | undefined = yup.AnySchema | undefined,\n  ReadSchema extends yup.AnySchema | undefined = yup.AnySchema | undefined,\n  UpdateSchema extends yup.AnySchema | undefined = yup.AnySchema | undefined,\n  DeleteSchema extends yup.AnySchema | undefined = yup.AnySchema | undefined,\n> = {\n  createSchema: CreateSchema,\n  createDocs: EndpointDocumentation | undefined,\n\n  readSchema: ReadSchema,\n  readDocs: EndpointDocumentation | undefined,\n  listDocs: EndpointDocumentation | undefined,\n\n  updateSchema: UpdateSchema,\n  updateDocs: EndpointDocumentation | undefined,\n\n  deleteSchema: DeleteSchema,\n  deleteDocs: EndpointDocumentation | undefined,\n};\n\nexport type CrudSchema<\n  ClientSchema extends InnerCrudSchema = InnerCrudSchema,\n  ServerSchema extends InnerCrudSchema = InnerCrudSchema,\n  AdminSchema extends InnerCrudSchema = InnerCrudSchema,\n> = {\n  client: ClientSchema,\n  server: ServerSchema,\n  admin: AdminSchema,\n\n  hasCreate: boolean,\n  hasRead: boolean,\n  hasUpdate: boolean,\n  hasDelete: boolean,\n};\n\nexport type CrudSchemaCreationOptions = {\n  [K in AccessTypeXCrudOperation as `${K}Schema`]?: yup.AnySchema\n};\n\ntype FillInOptionalsPrepareStep<O extends CrudSchemaCreationOptions> =\n  & { [K in keyof Required<CrudSchemaCreationOptions>]: K extends keyof O ? O[K] : undefined };\n\ntype FillInOptionalsStep<O extends FillInOptionalsPrepareStep<CrudSchemaCreationOptions>> = {\n  clientCreateSchema: NullishCoalesce<O['clientCreateSchema'], undefined>,\n  clientReadSchema: NullishCoalesce<O['clientReadSchema'], undefined>,\n  clientUpdateSchema: NullishCoalesce<O['clientUpdateSchema'], undefined>,\n  clientDeleteSchema: NullishCoalesce<O['clientDeleteSchema'], undefined>,\n\n  serverCreateSchema: NullishCoalesce<O['serverCreateSchema'], O['clientCreateSchema']>,\n  serverReadSchema: NullishCoalesce<O['serverReadSchema'], O['clientReadSchema']>,\n  serverUpdateSchema: NullishCoalesce<O['serverUpdateSchema'], O['clientUpdateSchema']>,\n  serverDeleteSchema: NullishCoalesce<O['serverDeleteSchema'], O['clientDeleteSchema']>,\n\n  adminCreateSchema: NullishCoalesce<O['adminCreateSchema'], O['serverCreateSchema']>,\n  adminReadSchema: NullishCoalesce<O['adminReadSchema'], O['serverReadSchema']>,\n  adminUpdateSchema: NullishCoalesce<O['adminUpdateSchema'], O['serverUpdateSchema']>,\n  adminDeleteSchema: NullishCoalesce<O['adminDeleteSchema'], O['serverDeleteSchema']>,\n};\n\ntype FillInOptionals<O extends CrudSchemaCreationOptions> = FillInOptionalsStep<FillInOptionalsStep<FillInOptionalsStep<FillInOptionalsPrepareStep<O>>>>;\n\ntype CrudSchemaFromOptionsInner<O extends FillInOptionals<any>> = CrudSchema<\n  InnerCrudSchema<O['clientCreateSchema'], O['clientReadSchema'], O['clientUpdateSchema'], O['clientDeleteSchema']>,\n  InnerCrudSchema<O['serverCreateSchema'], O['serverReadSchema'], O['serverUpdateSchema'], O['serverDeleteSchema']>,\n  InnerCrudSchema<O['adminCreateSchema'], O['adminReadSchema'], O['adminUpdateSchema'], O['adminDeleteSchema']>\n>;\n\nexport type CrudSchemaFromOptions<O extends CrudSchemaCreationOptions> = CrudSchemaFromOptionsInner<FillInOptionals<O>>;\n\ntype InnerCrudTypeOf<S extends InnerCrudSchema> =\n  & (S['createSchema'] extends {} ? { Create: yup.InferType<S['createSchema']> } : {})\n  & (S['readSchema'] extends {} ? { Read: yup.InferType<S['readSchema']> } : {})\n  & (S['updateSchema'] extends {} ? { Update: yup.InferType<S['updateSchema']> } : {})\n  & (S['deleteSchema'] extends {} ? { Delete: yup.InferType<S['deleteSchema']> } : {})\n  & (S['readSchema'] extends {} ? { List: {\n    items: yup.InferType<S['readSchema']>[],\n    is_paginated: boolean,\n    pagination?: {\n      next_cursor: string | null,\n    },\n  }, } : {});\n\nexport type CrudTypeOf<S extends CrudSchema> = {\n  Client: InnerCrudTypeOf<S['client']>,\n  Server: InnerCrudTypeOf<S['server']>,\n  Admin: InnerCrudTypeOf<S['admin']>,\n}\n\ntype CrudDocsCreationOptions<SO extends CrudSchemaCreationOptions> = {\n  [X in AccessTypeXCrudlOperation]?: EndpointDocumentation\n};\n\nexport function createCrud<SO extends CrudSchemaCreationOptions>(options: SO & { docs?: CrudDocsCreationOptions<SO> }): CrudSchemaFromOptions<SO> {\n  const docs = options.docs ?? {};\n  const client = {\n    createSchema: options.clientCreateSchema,\n    createDocs: docs.clientCreate,\n\n    readSchema: options.clientReadSchema,\n    readDocs: docs.clientRead,\n    listDocs: docs.clientList,\n\n    updateSchema: options.clientUpdateSchema,\n    updateDocs: docs.clientUpdate,\n\n    deleteSchema: options.clientDeleteSchema,\n    deleteDocs: docs.clientDelete,\n  };\n\n  const serverOverrides = filterUndefined({\n    createSchema: options.serverCreateSchema,\n    createDocs: docs.serverCreate,\n\n    readSchema: options.serverReadSchema,\n    readDocs: docs.serverRead,\n    listDocs: docs.serverList,\n\n    updateSchema: options.serverUpdateSchema,\n    updateDocs: docs.serverUpdate,\n\n    deleteSchema: options.serverDeleteSchema,\n    deleteDocs: docs.serverDelete,\n  });\n  const server = {\n    ...client,\n    ...serverOverrides,\n  };\n\n  const adminOverrides = filterUndefined({\n    createSchema: options.adminCreateSchema,\n    createDocs: docs.adminCreate,\n\n    readSchema: options.adminReadSchema,\n    readDocs: docs.adminRead,\n    listDocs: docs.adminList,\n\n    updateSchema: options.adminUpdateSchema,\n    updateDocs: docs.adminUpdate,\n\n    deleteSchema: options.adminDeleteSchema,\n    deleteDocs: docs.adminDelete,\n  });\n  const admin = {\n    ...server,\n    ...adminOverrides,\n  };\n\n  return {\n    client: client as any,\n    server: server as any,\n    admin: admin as any,\n\n    hasCreate: !!admin.createSchema,\n    hasRead: !!admin.readSchema,\n    hasUpdate: !!admin.updateSchema,\n    hasDelete: !!admin.deleteSchema,\n  };\n}\n\nundefined?.test(\"createCrud\", ({ expect }) => {\n  // Test with empty options\n  const emptyCrud = createCrud({});\n  expect(emptyCrud.hasCreate).toBe(false);\n  expect(emptyCrud.hasRead).toBe(false);\n  expect(emptyCrud.hasUpdate).toBe(false);\n  expect(emptyCrud.hasDelete).toBe(false);\n  expect(emptyCrud.client.createSchema).toBeUndefined();\n  expect(emptyCrud.server.createSchema).toBeUndefined();\n  expect(emptyCrud.admin.createSchema).toBeUndefined();\n\n  // Test with client schemas only\n  const mockSchema = yupObject().shape({\n    name: yupString().defined(),\n  });\n\n  const clientOnlyCrud = createCrud({\n    clientCreateSchema: mockSchema,\n    clientReadSchema: mockSchema,\n  });\n  expect(clientOnlyCrud.hasCreate).toBe(true);\n  expect(clientOnlyCrud.hasRead).toBe(true);\n  expect(clientOnlyCrud.hasUpdate).toBe(false);\n  expect(clientOnlyCrud.hasDelete).toBe(false);\n  expect(clientOnlyCrud.client.createSchema).toBe(mockSchema);\n  expect(clientOnlyCrud.server.createSchema).toBe(mockSchema);\n  expect(clientOnlyCrud.admin.createSchema).toBe(mockSchema);\n\n  // Test with server overrides\n  const serverSchema = yupObject().shape({\n    name: yupString().defined(),\n    internalField: yupString().defined(),\n  });\n\n  const serverOverrideCrud = createCrud({\n    clientCreateSchema: mockSchema,\n    serverCreateSchema: serverSchema,\n  });\n  expect(serverOverrideCrud.hasCreate).toBe(true);\n  expect(serverOverrideCrud.client.createSchema).toBe(mockSchema);\n  expect(serverOverrideCrud.server.createSchema).toBe(serverSchema);\n  expect(serverOverrideCrud.admin.createSchema).toBe(serverSchema);\n\n  // Test with admin overrides\n  const adminSchema = yupObject().shape({\n    name: yupString().defined(),\n    internalField: yupString().defined(),\n    adminField: yupString().defined(),\n  });\n\n  const fullOverrideCrud = createCrud({\n    clientCreateSchema: mockSchema,\n    serverCreateSchema: serverSchema,\n    adminCreateSchema: adminSchema,\n  });\n  expect(fullOverrideCrud.hasCreate).toBe(true);\n  expect(fullOverrideCrud.client.createSchema).toBe(mockSchema);\n  expect(fullOverrideCrud.server.createSchema).toBe(serverSchema);\n  expect(fullOverrideCrud.admin.createSchema).toBe(adminSchema);\n\n  // Test with documentation\n  const crudWithDocs = createCrud({\n    clientCreateSchema: mockSchema,\n    docs: {\n      clientCreate: {\n        summary: \"Create a resource\",\n        description: \"Creates a new resource\",\n        tags: [\"resources\"],\n      },\n    },\n  });\n  expect(crudWithDocs.client.createDocs).toEqual({\n    summary: \"Create a resource\",\n    description: \"Creates a new resource\",\n    tags: [\"resources\"],\n  });\n  expect(crudWithDocs.server.createDocs).toEqual({\n    summary: \"Create a resource\",\n    description: \"Creates a new resource\",\n    tags: [\"resources\"],\n  });\n});\n"],"mappings":";AACA,SAAS,WAAW,iBAAiB;AACrC,SAAS,uBAAuB;AA4HzB,SAAS,WAAiD,SAAiF;AAChJ,QAAM,OAAO,QAAQ,QAAQ,CAAC;AAC9B,QAAM,SAAS;AAAA,IACb,cAAc,QAAQ;AAAA,IACtB,YAAY,KAAK;AAAA,IAEjB,YAAY,QAAQ;AAAA,IACpB,UAAU,KAAK;AAAA,IACf,UAAU,KAAK;AAAA,IAEf,cAAc,QAAQ;AAAA,IACtB,YAAY,KAAK;AAAA,IAEjB,cAAc,QAAQ;AAAA,IACtB,YAAY,KAAK;AAAA,EACnB;AAEA,QAAM,kBAAkB,gBAAgB;AAAA,IACtC,cAAc,QAAQ;AAAA,IACtB,YAAY,KAAK;AAAA,IAEjB,YAAY,QAAQ;AAAA,IACpB,UAAU,KAAK;AAAA,IACf,UAAU,KAAK;AAAA,IAEf,cAAc,QAAQ;AAAA,IACtB,YAAY,KAAK;AAAA,IAEjB,cAAc,QAAQ;AAAA,IACtB,YAAY,KAAK;AAAA,EACnB,CAAC;AACD,QAAM,SAAS;AAAA,IACb,GAAG;AAAA,IACH,GAAG;AAAA,EACL;AAEA,QAAM,iBAAiB,gBAAgB;AAAA,IACrC,cAAc,QAAQ;AAAA,IACtB,YAAY,KAAK;AAAA,IAEjB,YAAY,QAAQ;AAAA,IACpB,UAAU,KAAK;AAAA,IACf,UAAU,KAAK;AAAA,IAEf,cAAc,QAAQ;AAAA,IACtB,YAAY,KAAK;AAAA,IAEjB,cAAc,QAAQ;AAAA,IACtB,YAAY,KAAK;AAAA,EACnB,CAAC;AACD,QAAM,QAAQ;AAAA,IACZ,GAAG;AAAA,IACH,GAAG;AAAA,EACL;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IAEA,WAAW,CAAC,CAAC,MAAM;AAAA,IACnB,SAAS,CAAC,CAAC,MAAM;AAAA,IACjB,WAAW,CAAC,CAAC,MAAM;AAAA,IACnB,WAAW,CAAC,CAAC,MAAM;AAAA,EACrB;AACF;","names":[]}

package/dist/esm/global.d.js

@@ -0,0 +1 @@
+//# sourceMappingURL=global.d.js.map

package/dist/esm/global.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/helpers/password.js

@@ -0,0 +1,17 @@
+// src/helpers/password.ts
+import { KnownErrors } from "..";
+var minLength = 8;
+var maxLength = 70;
+function getPasswordError(password) {
+  if (password.length < minLength) {
+    return new KnownErrors.PasswordTooShort(minLength);
+  }
+  if (password.length > maxLength) {
+    return new KnownErrors.PasswordTooLong(maxLength);
+  }
+  return void 0;
+}
+export {
+  getPasswordError
+};
+//# sourceMappingURL=password.js.map

package/dist/esm/helpers/password.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/helpers/password.ts"],"sourcesContent":["import { KnownErrors } from \"..\";\n\nconst minLength = 8;\nconst maxLength = 70;\n\nexport function getPasswordError(password: string): KnownErrors[\"PasswordRequirementsNotMet\"] | undefined {\n  if (password.length < minLength) {\n    return new KnownErrors.PasswordTooShort(minLength);\n  }\n\n  if (password.length > maxLength) {\n    return new KnownErrors.PasswordTooLong(maxLength);\n  }\n\n  return undefined;\n}\n"],"mappings":";AAAA,SAAS,mBAAmB;AAE5B,IAAM,YAAY;AAClB,IAAM,YAAY;AAEX,SAAS,iBAAiB,UAAyE;AACxG,MAAI,SAAS,SAAS,WAAW;AAC/B,WAAO,IAAI,YAAY,iBAAiB,SAAS;AAAA,EACnD;AAEA,MAAI,SAAS,SAAS,WAAW;AAC/B,WAAO,IAAI,YAAY,gBAAgB,SAAS;AAAA,EAClD;AAEA,SAAO;AACT;","names":[]}

package/dist/esm/helpers/production-mode.js

@@ -0,0 +1,50 @@
+// src/helpers/production-mode.ts
+import { StackAssertionError, captureError } from "../utils/errors";
+import { isLocalhost } from "../utils/urls";
+function getProductionModeErrors(project) {
+  const errors = [];
+  const domainsFixUrl = `/projects/${project.id}/domains`;
+  if (project.config.allow_localhost) {
+    errors.push({
+      message: "Localhost is not allowed in production mode, turn off 'Allow localhost' in project settings",
+      relativeFixUrl: domainsFixUrl
+    });
+  }
+  for (const { domain } of project.config.domains) {
+    let url;
+    try {
+      url = new URL(domain);
+    } catch (e) {
+      captureError("production-mode-domain-not-valid", new StackAssertionError("Domain was somehow not a valid URL; we should've caught this when setting the domain in the first place", {
+        domain,
+        projectId: project
+      }));
+      errors.push({
+        message: "Trusted domain is not a valid URL: " + domain,
+        relativeFixUrl: domainsFixUrl
+      });
+      continue;
+    }
+    if (isLocalhost(url)) {
+      errors.push({
+        message: "Localhost domains are not allowed to be trusted in production mode: " + domain,
+        relativeFixUrl: domainsFixUrl
+      });
+    } else if (url.hostname.match(/^\d+(\.\d+)*$/)) {
+      errors.push({
+        message: "Direct IPs are not valid for trusted domains in production mode: " + domain,
+        relativeFixUrl: domainsFixUrl
+      });
+    } else if (url.protocol !== "https:") {
+      errors.push({
+        message: "Trusted domains should be HTTPS: " + domain,
+        relativeFixUrl: domainsFixUrl
+      });
+    }
+  }
+  return errors;
+}
+export {
+  getProductionModeErrors
+};
+//# sourceMappingURL=production-mode.js.map

package/dist/esm/helpers/production-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/helpers/production-mode.ts"],"sourcesContent":["import { ProjectsCrud } from \"../interface/crud/projects\";\nimport { StackAssertionError, captureError } from \"../utils/errors\";\nimport { isLocalhost } from \"../utils/urls\";\n\nexport type ProductionModeError = {\n  message: string,\n  relativeFixUrl: `/${string}`,\n};\n\nexport function getProductionModeErrors(project: ProjectsCrud[\"Admin\"][\"Read\"]): ProductionModeError[] {\n  const errors: ProductionModeError[] = [];\n  const domainsFixUrl = `/projects/${project.id}/domains` as const;\n\n  if (project.config.allow_localhost) {\n    errors.push({\n      message: \"Localhost is not allowed in production mode, turn off 'Allow localhost' in project settings\",\n      relativeFixUrl: domainsFixUrl,\n    });\n  }\n\n  for (const { domain } of project.config.domains) {\n    let url;\n    try {\n      url = new URL(domain);\n    } catch (e) {\n      captureError(\"production-mode-domain-not-valid\", new StackAssertionError(\"Domain was somehow not a valid URL; we should've caught this when setting the domain in the first place\", {\n        domain,\n        projectId: project\n      }));\n      errors.push({\n        message: \"Trusted domain is not a valid URL: \" + domain,\n        relativeFixUrl: domainsFixUrl,\n      });\n      continue;\n    }\n\n    if (isLocalhost(url)) {\n      errors.push({\n        message: \"Localhost domains are not allowed to be trusted in production mode: \" + domain,\n        relativeFixUrl: domainsFixUrl,\n      });\n    } else if (url.hostname.match(/^\\d+(\\.\\d+)*$/)) {\n      errors.push({\n        message: \"Direct IPs are not valid for trusted domains in production mode: \" + domain,\n        relativeFixUrl: domainsFixUrl,\n      });\n    } else if (url.protocol !== \"https:\") {\n      errors.push({\n        message: \"Trusted domains should be HTTPS: \" + domain,\n        relativeFixUrl: domainsFixUrl,\n      });\n    }\n  }\n\n  return errors;\n}\n"],"mappings":";AACA,SAAS,qBAAqB,oBAAoB;AAClD,SAAS,mBAAmB;AAOrB,SAAS,wBAAwB,SAA+D;AACrG,QAAM,SAAgC,CAAC;AACvC,QAAM,gBAAgB,aAAa,QAAQ,EAAE;AAE7C,MAAI,QAAQ,OAAO,iBAAiB;AAClC,WAAO,KAAK;AAAA,MACV,SAAS;AAAA,MACT,gBAAgB;AAAA,IAClB,CAAC;AAAA,EACH;AAEA,aAAW,EAAE,OAAO,KAAK,QAAQ,OAAO,SAAS;AAC/C,QAAI;AACJ,QAAI;AACF,YAAM,IAAI,IAAI,MAAM;AAAA,IACtB,SAAS,GAAG;AACV,mBAAa,oCAAoC,IAAI,oBAAoB,2GAA2G;AAAA,QAClL;AAAA,QACA,WAAW;AAAA,MACb,CAAC,CAAC;AACF,aAAO,KAAK;AAAA,QACV,SAAS,wCAAwC;AAAA,QACjD,gBAAgB;AAAA,MAClB,CAAC;AACD;AAAA,IACF;AAEA,QAAI,YAAY,GAAG,GAAG;AACpB,aAAO,KAAK;AAAA,QACV,SAAS,yEAAyE;AAAA,QAClF,gBAAgB;AAAA,MAClB,CAAC;AAAA,IACH,WAAW,IAAI,SAAS,MAAM,eAAe,GAAG;AAC9C,aAAO,KAAK;AAAA,QACV,SAAS,sEAAsE;AAAA,QAC/E,gBAAgB;AAAA,MAClB,CAAC;AAAA,IACH,WAAW,IAAI,aAAa,UAAU;AACpC,aAAO,KAAK;AAAA,QACV,SAAS,sCAAsC;AAAA,QAC/C,gBAAgB;AAAA,MAClB,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/esm/hooks/use-async-callback.js

@@ -0,0 +1,38 @@
+// src/hooks/use-async-callback.tsx
+import React from "react";
+import { captureError } from "../utils/errors";
+function useAsyncCallback(callback, deps) {
+  const [error, setError] = React.useState(void 0);
+  const [loadingCount, setLoadingCount] = React.useState(0);
+  const cb = React.useCallback(
+    async (...args) => {
+      setLoadingCount((c) => c + 1);
+      try {
+        return await callback(...args);
+      } catch (e) {
+        setError(e);
+        throw e;
+      } finally {
+        setLoadingCount((c) => c - 1);
+      }
+    },
+    deps
+  );
+  return [cb, loadingCount > 0, error];
+}
+function useAsyncCallbackWithLoggedError(callback, deps) {
+  const [newCallback, loading] = useAsyncCallback(async (...args) => {
+    try {
+      return await callback(...args);
+    } catch (e) {
+      captureError("async-callback", e);
+      throw e;
+    }
+  }, deps);
+  return [newCallback, loading];
+}
+export {
+  useAsyncCallback,
+  useAsyncCallbackWithLoggedError
+};
+//# sourceMappingURL=use-async-callback.js.map

package/dist/esm/hooks/use-async-callback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-async-callback.tsx"],"sourcesContent":["import React from \"react\";\nimport { captureError } from \"../utils/errors\";\n\nexport function useAsyncCallback<A extends any[], R>(\n  callback: (...args: A) => Promise<R>,\n  deps: React.DependencyList\n): [cb: (...args: A) => Promise<R>, loading: boolean, error: unknown | undefined] {\n  const [error, setError] = React.useState<unknown | undefined>(undefined);\n  const [loadingCount, setLoadingCount] = React.useState(0);\n\n  const cb = React.useCallback(\n    async (...args: A) => {\n      setLoadingCount((c) => c + 1);\n      try {\n        return await callback(...args);\n      } catch (e) {\n        setError(e);\n        throw e;\n      } finally {\n        setLoadingCount((c) => c - 1);\n      }\n    },\n    deps,\n  );\n\n  return [cb, loadingCount > 0, error];\n}\n\nexport function useAsyncCallbackWithLoggedError<A extends any[], R>(\n  callback: (...args: A) => Promise<R>,\n  deps: React.DependencyList\n): [cb: (...args: A) => Promise<R>, loading: boolean] {\n  const [newCallback, loading] = useAsyncCallback<A, R>(async (...args) => {\n    try {\n      return await callback(...args);\n    } catch (e) {\n      captureError(\"async-callback\", e);\n      throw e;\n    }\n  }, deps);\n\n  return [newCallback, loading];\n}\n"],"mappings":";AAAA,OAAO,WAAW;AAClB,SAAS,oBAAoB;AAEtB,SAAS,iBACd,UACA,MACgF;AAChF,QAAM,CAAC,OAAO,QAAQ,IAAI,MAAM,SAA8B,MAAS;AACvE,QAAM,CAAC,cAAc,eAAe,IAAI,MAAM,SAAS,CAAC;AAExD,QAAM,KAAK,MAAM;AAAA,IACf,UAAU,SAAY;AACpB,sBAAgB,CAAC,MAAM,IAAI,CAAC;AAC5B,UAAI;AACF,eAAO,MAAM,SAAS,GAAG,IAAI;AAAA,MAC/B,SAAS,GAAG;AACV,iBAAS,CAAC;AACV,cAAM;AAAA,MACR,UAAE;AACA,wBAAgB,CAAC,MAAM,IAAI,CAAC;AAAA,MAC9B;AAAA,IACF;AAAA,IACA;AAAA,EACF;AAEA,SAAO,CAAC,IAAI,eAAe,GAAG,KAAK;AACrC;AAEO,SAAS,gCACd,UACA,MACoD;AACpD,QAAM,CAAC,aAAa,OAAO,IAAI,iBAAuB,UAAU,SAAS;AACvE,QAAI;AACF,aAAO,MAAM,SAAS,GAAG,IAAI;AAAA,IAC/B,SAAS,GAAG;AACV,mBAAa,kBAAkB,CAAC;AAChC,YAAM;AAAA,IACR;AAAA,EACF,GAAG,IAAI;AAEP,SAAO,CAAC,aAAa,OAAO;AAC9B;","names":[]}

package/dist/esm/hooks/use-async-external-store.js

@@ -0,0 +1,23 @@
+// src/hooks/use-async-external-store.tsx
+import { useEffect, useState } from "react";
+import { AsyncResult } from "../utils/results";
+function useAsyncExternalStore(subscribe) {
+  const [isAvailable, setIsAvailable] = useState(false);
+  const [value, setValue] = useState();
+  useEffect(() => {
+    const unsubscribe = subscribe((value2) => {
+      setValue(() => value2);
+      setIsAvailable(() => true);
+    });
+    return unsubscribe;
+  }, [subscribe]);
+  if (isAvailable) {
+    return AsyncResult.ok(value);
+  } else {
+    return AsyncResult.pending();
+  }
+}
+export {
+  useAsyncExternalStore
+};
+//# sourceMappingURL=use-async-external-store.js.map

package/dist/esm/hooks/use-async-external-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-async-external-store.tsx"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { AsyncResult } from \"../utils/results\";\n\nexport function useAsyncExternalStore<T>(\n  subscribe: (callback: (t: T) => void) => (() => void),\n): AsyncResult<T, never> & { status: \"ok\" | \"pending\" } {\n  // sure, the \"sync\" in useSyncExternalStore refers to \"synchronize a store\" and not \"sync/async\", but it's too good of a name to pass up on\n\n  const [isAvailable, setIsAvailable] = useState(false);\n  const [value, setValue] = useState<T>();\n  useEffect(() => {\n    const unsubscribe = subscribe((value: T) => {\n      setValue(() => value);\n      setIsAvailable(() => true);\n    });\n    return unsubscribe;\n  }, [subscribe]);\n\n  if (isAvailable) {\n    return AsyncResult.ok(value as T);\n  } else {\n    return AsyncResult.pending();\n  }\n}\n"],"mappings":";AAAA,SAAS,WAAW,gBAAgB;AACpC,SAAS,mBAAmB;AAErB,SAAS,sBACd,WACsD;AAGtD,QAAM,CAAC,aAAa,cAAc,IAAI,SAAS,KAAK;AACpD,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAY;AACtC,YAAU,MAAM;AACd,UAAM,cAAc,UAAU,CAACA,WAAa;AAC1C,eAAS,MAAMA,MAAK;AACpB,qBAAe,MAAM,IAAI;AAAA,IAC3B,CAAC;AACD,WAAO;AAAA,EACT,GAAG,CAAC,SAAS,CAAC;AAEd,MAAI,aAAa;AACf,WAAO,YAAY,GAAG,KAAU;AAAA,EAClC,OAAO;AACL,WAAO,YAAY,QAAQ;AAAA,EAC7B;AACF;","names":["value"]}

package/dist/esm/hooks/use-hash.js

@@ -0,0 +1,17 @@
+// src/hooks/use-hash.tsx
+import { useSyncExternalStore } from "react";
+import { suspendIfSsr } from "../utils/react";
+var useHash = () => {
+  suspendIfSsr("useHash");
+  return useSyncExternalStore(
+    (onChange) => {
+      const interval = setInterval(() => onChange(), 10);
+      return () => clearInterval(interval);
+    },
+    () => window.location.hash.substring(1)
+  );
+};
+export {
+  useHash
+};
+//# sourceMappingURL=use-hash.js.map

package/dist/esm/hooks/use-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-hash.tsx"],"sourcesContent":["import { useSyncExternalStore } from \"react\";\nimport { suspendIfSsr } from \"../utils/react\";\n\nexport const useHash = () => {\n  suspendIfSsr(\"useHash\");\n  return useSyncExternalStore(\n    (onChange) => {\n      const interval = setInterval(() => onChange(), 10);\n      return () => clearInterval(interval);\n    },\n    () => window.location.hash.substring(1)\n  );\n};\n\n"],"mappings":";AAAA,SAAS,4BAA4B;AACrC,SAAS,oBAAoB;AAEtB,IAAM,UAAU,MAAM;AAC3B,eAAa,SAAS;AACtB,SAAO;AAAA,IACL,CAAC,aAAa;AACZ,YAAM,WAAW,YAAY,MAAM,SAAS,GAAG,EAAE;AACjD,aAAO,MAAM,cAAc,QAAQ;AAAA,IACrC;AAAA,IACA,MAAM,OAAO,SAAS,KAAK,UAAU,CAAC;AAAA,EACxC;AACF;","names":[]}

package/dist/esm/hooks/use-strict-memo.js

@@ -0,0 +1,61 @@
+// src/hooks/use-strict-memo.tsx
+import { useId, useInsertionEffect } from "react";
+import { Result } from "../utils/results";
+var cached = /* @__PURE__ */ new Map();
+function unwrapFromInner(dependencies, inner) {
+  if (dependencies.length === 0 !== "isNotNestedMap" in inner) {
+    return Result.error(void 0);
+  }
+  if ("isNotNestedMap" in inner) {
+    if (dependencies.length === 0) {
+      return Result.ok(inner.value);
+    } else {
+      return Result.error(void 0);
+    }
+  } else {
+    if (dependencies.length === 0) {
+      return Result.error(void 0);
+    } else {
+      const [key, ...rest] = dependencies;
+      const newInner = inner.get(key);
+      if (!newInner) {
+        return Result.error(void 0);
+      }
+      return unwrapFromInner(rest, newInner);
+    }
+  }
+}
+function wrapToInner(dependencies, value) {
+  if (dependencies.length === 0) {
+    return { isNotNestedMap: true, value };
+  }
+  const [key, ...rest] = dependencies;
+  const inner = wrapToInner(rest, value);
+  const isObject = typeof key === "object" && key !== null;
+  const isUnregisteredSymbol = typeof key === "symbol" && Symbol.keyFor(key) === void 0;
+  const isWeak = isObject || isUnregisteredSymbol;
+  const mapType = isWeak ? WeakMap : Map;
+  return new mapType([[key, inner]]);
+}
+function useStrictMemo(callback, dependencies) {
+  const id = useId();
+  useInsertionEffect(() => {
+    return () => {
+      cached.delete(id);
+    };
+  }, [id]);
+  const c = cached.get(id);
+  if (c) {
+    const unwrapped = unwrapFromInner(dependencies, c);
+    if (unwrapped.status === "ok") {
+      return unwrapped.data;
+    }
+  }
+  const value = callback();
+  cached.set(id, wrapToInner(dependencies, value));
+  return value;
+}
+export {
+  useStrictMemo
+};
+//# sourceMappingURL=use-strict-memo.js.map

package/dist/esm/hooks/use-strict-memo.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-strict-memo.tsx"],"sourcesContent":["import { useId, useInsertionEffect, useMemo } from \"react\";\nimport { Result } from \"../utils/results\";\n\ntype CacheInner = Map<unknown, CacheInner> | WeakMap<WeakKey, CacheInner> | { isNotNestedMap: true, value: any };\n\nconst cached = new Map<string, CacheInner>();\n\nfunction unwrapFromInner(dependencies: any[], inner: CacheInner): Result<any, void> {\n  if ((dependencies.length === 0) !== (\"isNotNestedMap\" in inner)) {\n    return Result.error(undefined);\n  }\n  if (\"isNotNestedMap\" in inner) {\n    if (dependencies.length === 0) {\n      return Result.ok(inner.value);\n    } else {\n      return Result.error(undefined);\n    }\n  } else {\n    if (dependencies.length === 0) {\n      return Result.error(undefined);\n    } else {\n      const [key, ...rest] = dependencies;\n      const newInner = inner.get(key);\n      if (!newInner) {\n        return Result.error(undefined);\n      }\n      return unwrapFromInner(rest, newInner);\n    }\n  }\n}\nundefined?.test(\"unwrapFromInner\", ({ expect }) => {\n  // Test with empty dependencies and non-nested map\n  const nonNestedMap = { isNotNestedMap: true, value: \"test\" } as CacheInner;\n  const result1 = unwrapFromInner([], nonNestedMap);\n  expect(result1.status).toBe(\"ok\");\n  if (result1.status === \"ok\") {\n    expect(result1.data).toBe(\"test\");\n  }\n\n  // Test with non-empty dependencies and non-nested map (should error)\n  expect(unwrapFromInner([\"key\"], nonNestedMap).status).toBe(\"error\");\n\n  // Test with empty dependencies and nested map (should error)\n  const nestedMap = new Map([[\"key\", { isNotNestedMap: true, value: \"test\" } as CacheInner]]) as CacheInner;\n  expect(unwrapFromInner([], nestedMap).status).toBe(\"error\");\n\n  // Test with matching dependencies and nested map\n  const result2 = unwrapFromInner([\"key\"], nestedMap);\n  expect(result2.status).toBe(\"ok\");\n  if (result2.status === \"ok\") {\n    expect(result2.data).toBe(\"test\");\n  }\n\n  // Test with non-matching dependencies and nested map\n  expect(unwrapFromInner([\"wrongKey\"], nestedMap).status).toBe(\"error\");\n\n  // Test with deeply nested map\n  const deeplyNestedMap = new Map([\n    [\"key1\", new Map([\n      [\"key2\", { isNotNestedMap: true, value: \"nested\" } as CacheInner]\n    ]) as CacheInner]\n  ]) as CacheInner;\n\n  const result3 = unwrapFromInner([\"key1\", \"key2\"], deeplyNestedMap);\n  expect(result3.status).toBe(\"ok\");\n  if (result3.status === \"ok\") {\n    expect(result3.data).toBe(\"nested\");\n  }\n\n  // Test with partial match in deeply nested map\n  expect(unwrapFromInner([\"key1\", \"wrongKey\"], deeplyNestedMap).status).toBe(\"error\");\n});\n\nfunction wrapToInner(dependencies: any[], value: any): CacheInner {\n  if (dependencies.length === 0) {\n    return { isNotNestedMap: true, value };\n  }\n  const [key, ...rest] = dependencies;\n  const inner = wrapToInner(rest, value);\n\n  const isObject = (typeof key === \"object\" && key !== null);\n  const isUnregisteredSymbol = (typeof key === \"symbol\" && Symbol.keyFor(key) === undefined);\n  const isWeak = isObject || isUnregisteredSymbol;\n  const mapType = isWeak ? WeakMap : Map;\n\n  return new mapType([[key, inner]]);\n}\nundefined?.test(\"wrapToInner\", ({ expect }) => {\n  // Test with empty dependencies\n  const emptyResult = wrapToInner([], \"test\");\n  expect(emptyResult).toEqual({ isNotNestedMap: true, value: \"test\" });\n\n  // Test with single string dependency\n  const singleResult = wrapToInner([\"key\"], \"test\");\n  expect(singleResult instanceof Map).toBe(true);\n  // Need to cast to access Map methods\n  const singleMap = singleResult as Map<unknown, CacheInner>;\n  expect(singleMap.get(\"key\")).toEqual({ isNotNestedMap: true, value: \"test\" });\n\n  // Test with multiple string dependencies\n  const multiResult = wrapToInner([\"key1\", \"key2\"], \"test\");\n  expect(multiResult instanceof Map).toBe(true);\n  // Need to cast to access Map methods\n  const multiMap = multiResult as Map<unknown, CacheInner>;\n  const innerMap = multiMap.get(\"key1\") as Map<unknown, CacheInner>;\n  expect(innerMap instanceof Map).toBe(true);\n  expect(innerMap.get(\"key2\")).toEqual({ isNotNestedMap: true, value: \"test\" });\n\n  // Test with object dependency (should use WeakMap)\n  const obj = { test: true };\n  const objResult = wrapToInner([obj], \"test\");\n  expect(objResult instanceof WeakMap).toBe(true);\n  // Need to cast to access WeakMap methods\n  const objMap = objResult as WeakMap<WeakKey, CacheInner>;\n  expect(objMap.get(obj)).toEqual({ isNotNestedMap: true, value: \"test\" });\n\n  // Test with unregistered symbol dependency (should use WeakMap)\n  const symbolObj = Symbol(\"test\");\n  const symbolResult = wrapToInner([symbolObj], \"test\");\n  expect(symbolResult instanceof WeakMap).toBe(true);\n  // Need to cast to access WeakMap methods\n  const symbolMap = symbolResult as WeakMap<WeakKey, CacheInner>;\n  expect(symbolMap.get(symbolObj as unknown as object)).toEqual({ isNotNestedMap: true, value: \"test\" });\n\n  // Test with registered symbol dependency (should use Map)\n  const registeredSymbol = Symbol.for(\"test\");\n  const registeredSymbolResult = wrapToInner([registeredSymbol], \"test\");\n  expect(registeredSymbolResult instanceof Map).toBe(true);\n  // Need to cast to access Map methods\n  const registeredSymbolMap = registeredSymbolResult as Map<unknown, CacheInner>;\n  expect(registeredSymbolMap.get(registeredSymbol)).toEqual({ isNotNestedMap: true, value: \"test\" });\n});\n\n/**\n * Like memo, but minimizes recomputation of the value at all costs (instead of useMemo which recomputes whenever the renderer feels like it).\n *\n * The most recent value will be kept from garbage collection until one of the dependencies becomes unreachable. This may be true even after the component no longer renders. Be wary of memory leaks.\n */\nexport function useStrictMemo<T>(callback: () => T, dependencies: any[]): T {\n  const id = useId();\n  useInsertionEffect(() => {\n    return () => {\n      cached.delete(id);\n    };\n  }, [id]);\n\n  const c = cached.get(id);\n  if (c) {\n    const unwrapped = unwrapFromInner(dependencies, c);\n    if (unwrapped.status === \"ok\") {\n      return unwrapped.data;\n    }\n  }\n  const value = callback();\n  cached.set(id, wrapToInner(dependencies, value));\n  return value;\n}\n"],"mappings":";AAAA,SAAS,OAAO,0BAAmC;AACnD,SAAS,cAAc;AAIvB,IAAM,SAAS,oBAAI,IAAwB;AAE3C,SAAS,gBAAgB,cAAqB,OAAsC;AAClF,MAAK,aAAa,WAAW,MAAQ,oBAAoB,OAAQ;AAC/D,WAAO,OAAO,MAAM,MAAS;AAAA,EAC/B;AACA,MAAI,oBAAoB,OAAO;AAC7B,QAAI,aAAa,WAAW,GAAG;AAC7B,aAAO,OAAO,GAAG,MAAM,KAAK;AAAA,IAC9B,OAAO;AACL,aAAO,OAAO,MAAM,MAAS;AAAA,IAC/B;AAAA,EACF,OAAO;AACL,QAAI,aAAa,WAAW,GAAG;AAC7B,aAAO,OAAO,MAAM,MAAS;AAAA,IAC/B,OAAO;AACL,YAAM,CAAC,KAAK,GAAG,IAAI,IAAI;AACvB,YAAM,WAAW,MAAM,IAAI,GAAG;AAC9B,UAAI,CAAC,UAAU;AACb,eAAO,OAAO,MAAM,MAAS;AAAA,MAC/B;AACA,aAAO,gBAAgB,MAAM,QAAQ;AAAA,IACvC;AAAA,EACF;AACF;AA4CA,SAAS,YAAY,cAAqB,OAAwB;AAChE,MAAI,aAAa,WAAW,GAAG;AAC7B,WAAO,EAAE,gBAAgB,MAAM,MAAM;AAAA,EACvC;AACA,QAAM,CAAC,KAAK,GAAG,IAAI,IAAI;AACvB,QAAM,QAAQ,YAAY,MAAM,KAAK;AAErC,QAAM,WAAY,OAAO,QAAQ,YAAY,QAAQ;AACrD,QAAM,uBAAwB,OAAO,QAAQ,YAAY,OAAO,OAAO,GAAG,MAAM;AAChF,QAAM,SAAS,YAAY;AAC3B,QAAM,UAAU,SAAS,UAAU;AAEnC,SAAO,IAAI,QAAQ,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC;AACnC;AAoDO,SAAS,cAAiB,UAAmB,cAAwB;AAC1E,QAAM,KAAK,MAAM;AACjB,qBAAmB,MAAM;AACvB,WAAO,MAAM;AACX,aAAO,OAAO,EAAE;AAAA,IAClB;AAAA,EACF,GAAG,CAAC,EAAE,CAAC;AAEP,QAAM,IAAI,OAAO,IAAI,EAAE;AACvB,MAAI,GAAG;AACL,UAAM,YAAY,gBAAgB,cAAc,CAAC;AACjD,QAAI,UAAU,WAAW,MAAM;AAC7B,aAAO,UAAU;AAAA,IACnB;AAAA,EACF;AACA,QAAM,QAAQ,SAAS;AACvB,SAAO,IAAI,IAAI,YAAY,cAAc,KAAK,CAAC;AAC/C,SAAO;AACT;","names":[]}

package/dist/esm/index.js

@@ -0,0 +1,22 @@
+// src/index.ts
+import {
+  StackAdminInterface
+} from "./interface/adminInterface";
+import {
+  StackClientInterface
+} from "./interface/clientInterface";
+import {
+  StackServerInterface
+} from "./interface/serverInterface";
+import {
+  KnownError,
+  KnownErrors
+} from "./known-errors";
+export {
+  KnownError,
+  KnownErrors,
+  StackAdminInterface,
+  StackClientInterface,
+  StackServerInterface
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export {\n  StackAdminInterface\n} from \"./interface/adminInterface\";\nexport {\n  StackClientInterface\n} from \"./interface/clientInterface\";\nexport {\n  StackServerInterface\n} from \"./interface/serverInterface\";\nexport {\n  KnownError,\n  KnownErrors\n} from \"./known-errors\";\n\n"],"mappings":";AAAA;AAAA,EACE;AAAA,OACK;AACP;AAAA,EACE;AAAA,OACK;AACP;AAAA,EACE;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;","names":[]}

package/dist/esm/interface/adminInterface.js

@@ -0,0 +1,244 @@
+// src/interface/adminInterface.ts
+import { StackServerInterface } from "./serverInterface";
+var StackAdminInterface = class extends StackServerInterface {
+  constructor(options) {
+    super(options);
+    this.options = options;
+  }
+  async sendAdminRequest(path, options, session, requestType = "admin") {
+    return await this.sendServerRequest(
+      path,
+      {
+        ...options,
+        headers: {
+          "x-stack-super-secret-admin-key": "superSecretAdminKey" in this.options ? this.options.superSecretAdminKey : "",
+          ...options.headers
+        }
+      },
+      session,
+      requestType
+    );
+  }
+  async getProject() {
+    const response = await this.sendAdminRequest(
+      "/internal/projects/current",
+      {
+        method: "GET"
+      },
+      null
+    );
+    return await response.json();
+  }
+  async updateProject(update) {
+    const response = await this.sendAdminRequest(
+      "/internal/projects/current",
+      {
+        method: "PATCH",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(update)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async createInternalApiKey(options) {
+    const response = await this.sendAdminRequest(
+      "/internal/api-keys",
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(options)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async listInternalApiKeys() {
+    const response = await this.sendAdminRequest("/internal/api-keys", {}, null);
+    const result = await response.json();
+    return result.items;
+  }
+  async revokeInternalApiKeyById(id) {
+    await this.sendAdminRequest(
+      `/internal/api-keys/${id}`,
+      {
+        method: "PATCH",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          revoked: true
+        })
+      },
+      null
+    );
+  }
+  async getInternalApiKey(id, session) {
+    const response = await this.sendAdminRequest(`/internal/api-keys/${id}`, {}, session);
+    return await response.json();
+  }
+  async listEmailTemplates() {
+    const response = await this.sendAdminRequest(`/email-templates`, {}, null);
+    const result = await response.json();
+    return result.items;
+  }
+  async updateEmailTemplate(type, data) {
+    const result = await this.sendAdminRequest(
+      `/email-templates/${type}`,
+      {
+        method: "PATCH",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(data)
+      },
+      null
+    );
+    return await result.json();
+  }
+  async resetEmailTemplate(type) {
+    await this.sendAdminRequest(
+      `/email-templates/${type}`,
+      { method: "DELETE" },
+      null
+    );
+  }
+  // Team permission definitions methods
+  async listTeamPermissionDefinitions() {
+    const response = await this.sendAdminRequest(`/team-permission-definitions`, {}, null);
+    const result = await response.json();
+    return result.items;
+  }
+  async createTeamPermissionDefinition(data) {
+    const response = await this.sendAdminRequest(
+      "/team-permission-definitions",
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(data)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async updateTeamPermissionDefinition(permissionId, data) {
+    const response = await this.sendAdminRequest(
+      `/team-permission-definitions/${permissionId}`,
+      {
+        method: "PATCH",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(data)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async deleteTeamPermissionDefinition(permissionId) {
+    await this.sendAdminRequest(
+      `/team-permission-definitions/${permissionId}`,
+      { method: "DELETE" },
+      null
+    );
+  }
+  async listProjectPermissionDefinitions() {
+    const response = await this.sendAdminRequest(`/project-permission-definitions`, {}, null);
+    const result = await response.json();
+    return result.items;
+  }
+  async createProjectPermissionDefinition(data) {
+    const response = await this.sendAdminRequest(
+      "/project-permission-definitions",
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(data)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async updateProjectPermissionDefinition(permissionId, data) {
+    const response = await this.sendAdminRequest(
+      `/project-permission-definitions/${permissionId}`,
+      {
+        method: "PATCH",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(data)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async deleteProjectPermissionDefinition(permissionId) {
+    await this.sendAdminRequest(
+      `/project-permission-definitions/${permissionId}`,
+      { method: "DELETE" },
+      null
+    );
+  }
+  async getSvixToken() {
+    const response = await this.sendAdminRequest(
+      "/webhooks/svix-token",
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({})
+      },
+      null
+    );
+    return await response.json();
+  }
+  async deleteProject() {
+    await this.sendAdminRequest(
+      "/internal/projects/current",
+      {
+        method: "DELETE"
+      },
+      null
+    );
+  }
+  async getMetrics() {
+    const response = await this.sendAdminRequest(
+      "/internal/metrics",
+      {
+        method: "GET"
+      },
+      null
+    );
+    return await response.json();
+  }
+  async sendTestEmail(data) {
+    const response = await this.sendAdminRequest(`/internal/send-test-email`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(data)
+    }, null);
+    return await response.json();
+  }
+  async listSentEmails() {
+    const response = await this.sendAdminRequest("/internal/emails", {
+      method: "GET"
+    }, null);
+    return await response.json();
+  }
+};
+export {
+  StackAdminInterface
+};
+//# sourceMappingURL=adminInterface.js.map