tructor(e,t,r,n,i){super(e,t,i),this.vectorBucketName=r,this.indexName=n}async putVectors(e){var t=()=>super.putVectors,r=this;return t().call(r,xe(xe({},e),{},{vectorBucketName:r.vectorBucketName,indexName:r.indexName}))}async getVectors(e){var t=()=>super.getVectors,r=this;return t().call(r,xe(xe({},e),{},{vectorBucketName:r.vectorBucketName,indexName:r.indexName}))}async listVectors(e={}){var t=()=>super.listVectors,r=this;return t().call(r,xe(xe({},e),{},{vectorBucketName:r.vectorBucketName,indexName:r.indexName}))}async queryVectors(e){var t=()=>super.queryVectors,r=this;return t().call(r,xe(xe({},e),{},{vectorBucketName:r.vectorBucketName,indexName:r.indexName}))}async deleteVectors(e){var t=()=>super.deleteVectors,r=this;return t().call(r,xe(xe({},e),{},{vectorBucketName:r.vectorBucketName,indexName:r.indexName}))}},S$=class extends v${constructor(e,t={},r,n){super(e,t,r,n)}from(e){return new h$(this.url,this.headers,e,this.fetch)}get vectors(){return new b$(this.url+"/vector",{headers:this.headers,fetch:this.fetch})}get analytics(){return new m$(this.url+"/iceberg",this.headers,this.fetch)}};const MO="2.106.2",Bo=30*1e3,yg=3,vv=yg*Bo,k$="http://localhost:9999",P$="supabase.auth.token",E$={"X-Client-Info":`gotrue-js/${MO}`},wg="X-Supabase-Api-Version",$O={"2024-01-01":{timestamp:Date.parse("2024-01-01T00:00:00.0Z"),name:"2024-01-01"}},O$=/^([a-z0-9_-]{4})*($|[a-z0-9_-]{3}$|[a-z0-9_-]{2}$)$/i,A$=10*60*1e3;class es extends Error{constructor(t,r,n){super(t),this.__isAuthError=!0,this.name="AuthError",this.status=r,this.code=n}toJSON(){return{name:this.name,message:this.message,status:this.status,code:this.code}}}function ne(e){return typeof e=="object"&&e!==null&&"__isAuthError"in e}class C$ extends es{constructor(t,r,n){super(t,r,n),this.name="AuthApiError",this.status=r,this.code=n}}function j$(e){return ne(e)&&e.name==="AuthApiError"}class an extends es{constructor(t,r){super(t),this.name="AuthUnknownError",this.originalError=r}}class li extends es{constructor(t,r,n,i){super(t,n,i),this.name=r,this.status=n}}class At extends li{constructor(){super("Auth session missing!","AuthSessionMissingError",400,void 0)}}function zc(e){return ne(e)&&e.name==="AuthSessionMissingError"}class Oo extends li{constructor(){super("Auth session or user missing","AuthInvalidTokenResponseError",500,void 0)}}class Uc extends li{constructor(t){super(t,"AuthInvalidCredentialsError",400,void 0)}}class Bc extends li{constructor(t,r=null){super(t,"AuthImplicitGrantRedirectError",500,void 0),this.details=null,this.details=r}toJSON(){return Object.assign(Object.assign({},super.toJSON()),{details:this.details})}}function T$(e){return ne(e)&&e.name==="AuthImplicitGrantRedirectError"}class D1 extends li{constructor(t,r=null){super(t,"AuthPKCEGrantCodeExchangeError",500,void 0),this.details=null,this.details=r}toJSON(){return Object.assign(Object.assign({},super.toJSON()),{details:this.details})}}class N$ extends li{constructor(){super("PKCE code verifier not found in storage. This can happen if the auth flow was initiated in a different browser or device, or if the storage was cleared. For SSR frameworks (Next.js, SvelteKit, etc.), use @supabase/ssr on both the server and client to store the code verifier in cookies.","AuthPKCECodeVerifierMissingError",400,"pkce_code_verifier_not_found")}}class bg extends li{constructor(t,r){super(t,"AuthRetryableFetchError",r,void 0)}}function mv(e){return ne(e)&&e.name==="AuthRetryableFetchError"}class M1 extends li{constructor(t,r,n){super(t,"AuthWeakPasswordError",r,"weak_password"),this.reasons=n}toJSON(){return Object.assign(Object.assign({},super.toJSON()),{reasons:this.reasons})}}class xg extends li{constructor(t){super(t,"AuthInvalidJwtError",400,"invalid_jwt")}}const yd="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".split(""),$1=` 	
\r=`.split(""),I$=(()=>{const e=new Array(128);for(let t=0;t<e.length;t+=1)e[t]=-1;for(let t=0;t<$1.length;t+=1)e[$1[t].charCodeAt(0)]=-2;for(let t=0;t<yd.length;t+=1)e[yd[t].charCodeAt(0)]=t;return e})();function L1(e,t,r){if(e!==null)for(t.queue=t.queue<<8|e,t.queuedBits+=8;t.queuedBits>=6;){const n=t.queue>>t.queuedBits-6&63;r(yd[n]),t.queuedBits-=6}else if(t.queuedBits>0)for(t.queue=t.queue<<6-t.queuedBits,t.queuedBits=6;t.queuedBits>=6;){const n=t.queue>>t.queuedBits-6&63;r(yd[n]),t.queuedBits-=6}}function LO(e,t,r){const n=I$[e];if(n>-1)for(t.queue=t.queue<<6|n,t.queuedBits+=6;t.queuedBits>=8;)r(t.queue>>t.queuedBits-8&255),t.queuedBits-=8;else{if(n===-2)return;throw new Error(`Invalid Base64-URL character "${String.fromCharCode(e)}"`)}}function z1(e){const t=[],r=s=>{t.push(String.fromCodePoint(s))},n={utf8seq:0,codepoint:0},i={queue:0,queuedBits:0},a=s=>{M$(s,n,r)};for(let s=0;s<e.length;s+=1)LO(e.charCodeAt(s),i,a);return t.join("")}function R$(e,t){if(e<=127){t(e);return}else if(e<=2047){t(192|e>>6),t(128|e&63);return}else if(e<=65535){t(224|e>>12),t(128|e>>6&63),t(128|e&63);return}else if(e<=1114111){t(240|e>>18),t(128|e>>12&63),t(128|e>>6&63),t(128|e&63);return}throw new Error(`Unrecognized Unicode codepoint: ${e.toString(16)}`)}function D$(e,t){for(let r=0;r<e.length;r+=1){let n=e.charCodeAt(r);if(n>55295&&n<=56319){const i=(n-55296)*1024&65535;n=(e.charCodeAt(r+1)-56320&65535|i)+65536,r+=1}R$(n,t)}}function M$(e,t,r){if(t.utf8seq===0){if(e<=127){r(e);return}for(let n=1;n<6;n+=1)if(!(e>>7-n&1)){t.utf8seq=n;break}if(t.utf8seq===2)t.codepoint=e&31;else if(t.utf8seq===3)t.codepoint=e&15;else if(t.utf8seq===4)t.codepoint=e&7;else throw new Error("Invalid UTF-8 sequence");t.utf8seq-=1}else if(t.utf8seq>0){if(e<=127)throw new Error("Invalid UTF-8 sequence");t.codepoint=t.codepoint<<6|e&63,t.utf8seq-=1,t.utf8seq===0&&r(t.codepoint)}}function Go(e){const t=[],r={queue:0,queuedBits:0},n=i=>{t.push(i)};for(let i=0;i<e.length;i+=1)LO(e.charCodeAt(i),r,n);return new Uint8Array(t)}function $$(e){const t=[];return D$(e,r=>t.push(r)),new Uint8Array(t)}function Pa(e){const t=[],r={queue:0,queuedBits:0},n=i=>{t.push(i)};return e.forEach(i=>L1(i,r,n)),L1(null,r,n),t.join("")}function L$(e){return Math.round(Date.now()/1e3)+e}function z$(){return Symbol("auth-callback")}const Lt=()=>typeof window<"u"&&typeof document<"u",pa={tested:!1,writable:!1},zO=()=>{if(!Lt())return!1;try{if(typeof globalThis.localStorage!="object")return!1}catch{return!1}if(pa.tested)return pa.writable;const e=`lswt-${Math.random()}${Math.random()}`;try{globalThis.localStorage.setItem(e,e),globalThis.localStorage.removeItem(e),pa.tested=!0,pa.writable=!0}catch{pa.tested=!0,pa.writable=!1}return pa.writable};function U$(e){const t={},r=new URL(e);if(r.hash&&r.hash[0]==="#")try{new URLSearchParams(r.hash.substring(1)).forEach((i,a)=>{t[a]=i})}catch{}return r.searchParams.forEach((n,i)=>{t[i]=n}),t}const UO=e=>e?(...t)=>e(...t):(...t)=>fetch(...t),B$=e=>typeof e=="object"&&e!==null&&"status"in e&&"ok"in e&&"json"in e&&typeof e.json=="function",Fo=async(e,t,r)=>{await e.setItem(t,JSON.stringify(r))},va=async(e,t)=>{const r=await e.getItem(t);if(!r)return null;try{return JSON.parse(r)}catch{return null}},$t=async(e,t)=>{await e.removeItem(t)};class Of{constructor(){this.promise=new Of.promiseConstructor((t,r)=>{this.resolve=t,this.reject=r})}}Of.promiseConstructor=Promise;function Fc(e){const t=e.split(".");if(t.length!==3)throw new xg("Invalid JWT structure");for(let n=0;n<t.length;n++)if(!O$.test(t[n]))throw new xg("JWT not in base64url format");return{header:JSON.parse(z1(t[0])),payload:JSON.parse(z1(t[1])),signature:Go(t[2]),raw:{header:t[0],payload:t[1]}}}async function F$(e){return await new Promise(t=>{setTimeout(()=>t(null),e)})}function W$(e,t){return new Promise((n,i)=>{(async()=>{for(let a=0;a<1/0;a++)try{const s=await e(a);if(!t(a,null,s)){n(s);return}}catch(s){if(!t(a,s)){i(s);return}}})()})}function q$(e){return("0"+e.toString(16)).substr(-2)}function H$(){const t=new Uint32Array(56);if(typeof crypto>"u"){const r="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~",n=r.length;let i="";for(let a=0;a<56;a++)i+=r.charAt(Math.floor(Math.random()*n));return i}return crypto.getRandomValues(t),Array.from(t,q$).join("")}async function K$(e){const r=new TextEncoder().encode(e),n=await crypto.subtle.digest("SHA-256",r),i=new Uint8Array(n);return Array.from(i).map(a=>String.fromCharCode(a)).join("")}async function V$(e){if(!(typeof crypto<"u"&&typeof crypto.subtle<"u"&&typeof TextEncoder<"u"))return console.warn("WebCrypto API is not supported. Code challenge method will default to use plain instead of sha256."),e;const r=await K$(e);return btoa(r).replace(/\+/g,"-").replace(/\//g,"_").replace(/=+$/,"")}async function Ao(e,t,r=!1){const n=H$();let i=n;r&&(i+="/recovery"),await Fo(e,`${t}-code-verifier`,i);const a=await V$(n);return[a,n===a?"plain":"s256"]}const G$=/^2[0-9]{3}-(0[1-9]|1[0-2])-(0[1-9]|1[0-9]|2[0-9]|3[0-1])$/i;function Y$(e){const t=e.headers.get(wg);if(!t||!t.match(G$))return null;try{return new Date(`${t}T00:00:00.0Z`)}catch{return null}}function X$(e){if(!e)throw new Error("Missing exp claim");const t=Math.floor(Date.now()/1e3);if(e<=t)throw new Error("JWT has expired")}function J$(e){switch(e){case"RS256":return{name:"RSASSA-PKCS1-v1_5",hash:{name:"SHA-256"}};case"ES256":return{name:"ECDSA",namedCurve:"P-256",hash:{name:"SHA-256"}};default:throw new Error("Invalid alg claim")}}const Q$=/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;function Kn(e){if(!Q$.test(e))throw new Error("@supabase/auth-js: Expected parameter to be UUID but is not")}function tn(e){if(!e.passkey)throw new Error("@supabase/auth-js: the passkey API is experimental and disabled by default. Enable it by passing `auth: { experimental: { passkey: true } }` to createClient (or to the GoTrueClient constructor).")}function gv(){const e={};return new Proxy(e,{get:(t,r)=>{if(r==="__isUserNotAvailableProxy")return!0;if(typeof r=="symbol"){const n=r.toString();if(n==="Symbol(Symbol.toPrimitive)"||n==="Symbol(Symbol.toStringTag)"||n==="Symbol(util.inspect.custom)")return}throw new Error(`@supabase/auth-js: client was created with userStorage option and there was no user stored in the user storage. Accessing the "${r}" property of the session object is not supported. Please use getUser() instead.`)},set:(t,r)=>{throw new Error(`@supabase/auth-js: client was created with userStorage option and there was no user stored in the user storage. Setting the "${r}" property of the session object is not supported. Please use getUser() to fetch a user object you can manipulate.`)},deleteProperty:(t,r)=>{throw new Error(`@supabase/auth-js: client was created with userStorage option and there was no user stored in the user storage. Deleting the "${r}" property of the session object is not supported. Please use getUser() to fetch a user object you can manipulate.`)}})}function Z$(e,t){return new Proxy(e,{get:(r,n,i)=>{if(n==="__isInsecureUserWarningProxy")return!0;if(typeof n=="symbol"){const a=n.toString();if(a==="Symbol(Symbol.toPrimitive)"||a==="Symbol(Symbol.toStringTag)"||a==="Symbol(util.inspect.custom)"||a==="Symbol(nodejs.util.inspect.custom)")return Reflect.get(r,n,i)}return!t.value&&typeof n=="string"&&(console.warn("Using the user object as returned from supabase.auth.getSession() or from some supabase.auth.onAuthStateChange() events could be insecure! This value comes directly from the storage medium (usually cookies on the server) and may not be authentic. Use supabase.auth.getUser() instead which authenticates the data by contacting the Supabase Auth server."),t.value=!0),Reflect.get(r,n,i)}})}function U1(e){return JSON.parse(JSON.stringify(e))}const ba=e=>{if(typeof e=="object"&&e!==null){const t=e;if(typeof t.msg=="string")return t.msg;if(typeof t.message=="string")return t.message;if(typeof t.error_description=="string")return t.error_description;if(typeof t.error=="string")return t.error}return JSON.stringify(e)},eL=[502,503,504,520,521,522,523,524,530];async function B1(e){var t;if(!B$(e))throw new bg(ba(e),0);if(eL.includes(e.status))throw new bg(ba(e),e.status);let r;try{r=await e.json()}catch(a){throw new an(ba(a),a)}let n;const i=Y$(e);if(i&&i.getTime()>=$O["2024-01-01"].timestamp&&typeof r=="object"&&r&&typeof r.code=="string"?n=r.code:typeof r=="object"&&r&&typeof r.error_code=="string"&&(n=r.error_code),n){if(n==="weak_password")throw new M1(ba(r),e.status,((t=r.weak_password)===null||t===void 0?void 0:t.reasons)||[]);if(n==="session_not_found")throw new At}else if(typeof r=="object"&&r&&typeof r.weak_password=="object"&&r.weak_password&&Array.isArray(r.weak_password.reasons)&&r.weak_password.reasons.length&&r.weak_password.reasons.reduce((a,s)=>a&&typeof s=="string",!0))throw new M1(ba(r),e.status,r.weak_password.reasons);throw new C$(ba(r),e.status||500,n)}const tL=(e,t,r,n)=>{const i={method:e,headers:(t==null?void 0:t.headers)||{}};return e==="GET"?i:(i.headers=Object.assign({"Content-Type":"application/json;charset=UTF-8"},t==null?void 0:t.headers),i.body=JSON.stringify(n),Object.assign(Object.assign({},i),r))};async function ue(e,t,r,n){var i;const a=Object.assign({},n==null?void 0:n.headers);a[wg]||(a[wg]=$O["2024-01-01"].name),n!=null&&n.jwt&&(a.Authorization=`Bearer ${n.jwt}`);const s=(i=n==null?void 0:n.query)!==null&&i!==void 0?i:{};n!=null&&n.redirectTo&&(s.redirect_to=n.redirectTo);const u=Object.keys(s).length?"?"+new URLSearchParams(s).toString():"",c=await rL(e,t,r+u,{headers:a,noResolveJson:n==null?void 0:n.noResolveJson},{},n==null?void 0:n.body);return n!=null&&n.xform?n==null?void 0:n.xform(c):{data:Object.assign({},c),error:null}}async function rL(e,t,r,n,i,a){const s=tL(t,n,i,a);let u;try{u=await e(r,Object.assign({},s))}catch(c){throw console.error(c),new bg(ba(c),0)}if(u.ok||await B1(u),n!=null&&n.noResolveJson)return u;try{return await u.json()}catch(c){await B1(c)}}function Lr(e){var t;let r=null;aL(e)&&(r=Object.assign({},e),e.expires_at||(r.expires_at=L$(e.expires_in)));const n=(t=e.user)!==null&&t!==void 0?t:typeof(e==null?void 0:e.id)=="string"?e:null;return{data:{session:r,user:n},error:null}}function F1(e){const t=Lr(e);return!t.error&&e.weak_password&&typeof e.weak_password=="object"&&Array.isArray(e.weak_password.reasons)&&e.weak_password.reasons.length&&e.weak_password.message&&typeof e.weak_password.message=="string"&&e.weak_password.reasons.reduce((r,n)=>r&&typeof n=="string",!0)&&(t.data.weak_password=e.weak_password),t}function Bi(e){var t;return{data:{user:(t=e.user)!==null&&t!==void 0?t:e},error:null}}function nL(e){return{data:e,error:null}}function iL(e){const{action_link:t,email_otp:r,hashed_token:n,redirect_to:i,verification_type:a}=e,s=kf(e,["action_link","email_otp","hashed_token","redirect_to","verification_type"]),u={action_link:t,email_otp:r,hashed_token:n,redirect_to:i,verification_type:a},c=Object.assign({},s);return{data:{properties:u,user:c},error:null}}function W1(e){return e}function aL(e){return!!e.access_token&&!!e.refresh_token&&!!e.expires_in}const yv=["global","local","others"];class oL{_encodePathSegment(t){if(t==="."||t==="..")throw new es("Invalid path segment");return encodeURIComponent(t)}constructor({url:t="",headers:r={},fetch:n,experimental:i}){this.url=t,this.headers=r,this.fetch=UO(n),this.experimental=i??{},this.mfa={listFactors:this._listFactors.bind(this),deleteFactor:this._deleteFactor.bind(this)},this.oauth={listClients:this._listOAuthClients.bind(this),createClient:this._createOAuthClient.bind(this),getClient:this._getOAuthClient.bind(this),updateClient:this._updateOAuthClient.bind(this),deleteClient:this._deleteOAuthClient.bind(this),regenerateClientSecret:this._regenerateOAuthClientSecret.bind(this)},this.customProviders={listProviders:this._listCustomProviders.bind(this),createProvider:this._createCustomProvider.bind(this),getProvider:this._getCustomProvider.bind(this),updateProvider:this._updateCustomProvider.bind(this),deleteProvider:this._deleteCustomProvider.bind(this)},this.passkey={listPasskeys:this._adminListPasskeys.bind(this),deletePasskey:this._adminDeletePasskey.bind(this)}}async signOut(t,r=yv[0]){if(yv.indexOf(r)<0)throw new Error(`@supabase/auth-js: Parameter scope must be one of ${yv.join(", ")}`);try{return await ue(this.fetch,"POST",`${this.url}/logout?scope=${r}`,{headers:this.headers,jwt:t,noResolveJson:!0}),{data:null,error:null}}catch(n){if(ne(n))return{data:null,error:n};throw n}}async inviteUserByEmail(t,r={}){try{return await ue(this.fetch,"POST",`${this.url}/invite`,{body:{email:t,data:r.data},headers:this.headers,redirectTo:r.redirectTo,xform:Bi})}catch(n){if(ne(n))return{data:{user:null},error:n};throw n}}async generateLink(t){try{const{options:r}=t,n=kf(t,["options"]),i=Object.assign(Object.assign({},n),r);return"newEmail"in n&&(i.new_email=n==null?void 0:n.newEmail,delete i.newEmail),await ue(this.fetch,"POST",`${this.url}/admin/generate_link`,{body:i,headers:this.headers,xform:iL,redirectTo:r==null?void 0:r.redirectTo})}catch(r){if(ne(r))return{data:{properties:null,user:null},error:r};throw r}}async createUser(t){try{return await ue(this.fetch,"POST",`${this.url}/admin/users`,{body:t,headers:this.headers,xform:Bi})}catch(r){if(ne(r))return{data:{user:null},error:r};throw r}}async listUsers(t){var r,n,i,a,s,u,c;try{const d={nextPage:null,lastPage:0,total:0},h=await ue(this.fetch,"GET",`${this.url}/admin/users`,{headers:this.headers,noResolveJson:!0,query:{page:(n=(r=t==null?void 0:t.page)===null||r===void 0?void 0:r.toString())!==null&&n!==void 0?n:"",per_page:(a=(i=t==null?void 0:t.perPage)===null||i===void 0?void 0:i.toString())!==null&&a!==void 0?a:""},xform:W1});if(h.error)throw h.error;const p=await h.json(),m=(s=h.headers.get("x-total-count"))!==null&&s!==void 0?s:0,g=(c=(u=h.headers.get("link"))===null||u===void 0?void 0:u.split(","))!==null&&c!==void 0?c:[];return g.length>0&&(g.forEach(b=>{const w=parseInt(b.split(";")[0].split("=")[1].substring(0,1)),S=JSON.parse(b.split(";")[1].split("=")[1]);d[`${S}Page`]=w}),d.total=parseInt(m)),{data:Object.assign(Object.assign({},p),d),error:null}}catch(d){if(ne(d))return{data:{users:[]},error:d};throw d}}async getUserById(t){Kn(t);try{return await ue(this.fetch,"GET",`${this.url}/admin/users/${t}`,{headers:this.headers,xform:Bi})}catch(r){if(ne(r))return{data:{user:null},error:r};throw r}}async updateUserById(t,r){Kn(t);try{return await ue(this.fetch,"PUT",`${this.url}/admin/users/${t}`,{body:r,headers:this.headers,xform:Bi})}catch(n){if(ne(n))return{data:{user:null},error:n};throw n}}async deleteUser(t,r=!1){Kn(t);try{return await ue(this.fetch,"DELETE",`${this.url}/admin/users/${t}`,{headers:this.headers,body:{should_soft_delete:r},xform:Bi})}catch(n){if(ne(n))return{data:{user:null},error:n};throw n}}async _listFactors(t){Kn(t.userId);try{const{data:r,error:n}=await ue(this.fetch,"GET",`${this.url}/admin/users/${t.userId}/factors`,{headers:this.headers,xform:i=>({data:{factors:i},error:null})});return{data:r,error:n}}catch(r){if(ne(r))return{data:null,error:r};throw r}}async _deleteFactor(t){Kn(t.userId),Kn(t.id);try{return{data:await ue(this.fetch,"DELETE",`${this.url}/admin/users/${t.userId}/factors/${t.id}`,{headers:this.headers}),error:null}}catch(r){if(ne(r))return{data:null,error:r};throw r}}async _listOAuthClients(t){var r,n,i,a,s,u,c;try{const d={nextPage:null,lastPage:0,total:0},h=await ue(this.fetch,"GET",`${this.url}/admin/oauth/clients`,{headers:this.headers,noResolveJson:!0,query:{page:(n=(r=t==null?void 0:t.page)===null||r===void 0?void 0:r.toString())!==null&&n!==void 0?n:"",per_page:(a=(i=t==null?void 0:t.perPage)===null||i===void 0?void 0:i.toString())!==null&&a!==void 0?a:""},xform:W1});if(h.error)throw h.error;const p=await h.json(),m=(s=h.headers.get("x-total-count"))!==null&&s!==void 0?s:0,g=(c=(u=h.headers.get("link"))===null||u===void 0?void 0:u.split(","))!==null&&c!==void 0?c:[];return g.length>0&&(g.forEach(b=>{const w=parseInt(b.split(";")[0].split("=")[1].substring(0,1)),S=JSON.parse(b.split(";")[1].split("=")[1]);d[`${S}Page`]=w}),d.total=parseInt(m)),{data:Object.assign(Object.assign({},p),d),error:null}}catch(d){if(ne(d))return{data:{clients:[]},error:d};throw d}}async _createOAuthClient(t){try{return await ue(this.fetch,"POST",`${this.url}/admin/oauth/clients`,{body:t,headers:this.headers,xform:r=>({data:r,error:null})})}catch(r){if(ne(r))return{data:null,error:r};throw r}}async _getOAuthClient(t){try{const r=this._encodePathSegment(t);return await ue(this.fetch,"GET",`${this.url}/admin/oauth/clients/${r}`,{headers:this.headers,xform:n=>({data:n,error:null})})}catch(r){if(ne(r))return{data:null,error:r};throw r}}async _updateOAuthClient(t,r){try{const n=this._encodePathSegment(t);return await ue(this.fetch,"PUT",`${this.url}/admin/oauth/clients/${n}`,{body:r,headers:this.headers,xform:i=>({data:i,error:null})})}catch(n){if(ne(n))return{data:null,error:n};throw n}}async _deleteOAuthClient(t){try{const r=this._encodePathSegment(t);return await ue(this.fetch,"DELETE",`${this.url}/admin/oauth/clients/${r}`,{headers:this.headers,noResolveJson:!0}),{data:null,error:null}}catch(r){if(ne(r))return{data:null,error:r};throw r}}async _regenerateOAuthClientSecret(t){try{const r=this._encodePathSegment(t);return await ue(this.fetch,"POST",`${this.url}/admin/oauth/clients/${r}/regenerate_secret`,{headers:this.headers,xform:n=>({data:n,error:null})})}catch(r){if(ne(r))return{data:null,error:r};throw r}}async _listCustomProviders(t){try{const r={};return t!=null&&t.type&&(r.type=t.type),await ue(this.fetch,"GET",`${this.url}/admin/custom-providers`,{headers:this.headers,query:r,xform:n=>{var i;return{data:{providers:(i=n==null?void 0:n.providers)!==null&&i!==void 0?i:[]},error:null}}})}catch(r){if(ne(r))return{data:{providers:[]},error:r};throw r}}async _createCustomProvider(t){try{return await ue(this.fetch,"POST",`${this.url}/admin/custom-providers`,{body:t,headers:this.headers,xform:r=>({data:r,error:null})})}catch(r){if(ne(r))return{data:null,error:r};throw r}}async _getCustomProvider(t){try{const r=this._encodePathSegment(t);return await ue(this.fetch,"GET",`${this.url}/admin/custom-providers/${r}`,{headers:this.headers,xform:n=>({data:n,error:null})})}catch(r){if(ne(r))return{data:null,error:r};throw r}}async _updateCustomProvider(t,r){try{const n=this._encodePathSegment(t);return await ue(this.fetch,"PUT",`${this.url}/admin/custom-providers/${n}`,{body:r,headers:this.headers,xform:i=>({data:i,error:null})})}catch(n){if(ne(n))return{data:null,error:n};throw n}}async _deleteCustomProvider(t){try{const r=this._encodePathSegment(t);ret
