@agntcy/slim-bindings-linux-arm64-gnu 2.0.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agntcy/slim-bindings-linux-arm64-gnu",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "SLIM Node.js bindings (linux-arm64-gnu)",
   "main": "index.js",
   "types": "index.d.ts",

package/slim_bindings.d.ts

@@ -1001,11 +1001,205 @@ export declare const ClientJwtAuth: Readonly<{
     new: (partial: Partial<ClientJwtAuth> & Required<Omit<ClientJwtAuth, "key" | "duration" | "audience" | "issuer" | "subject">>) => ClientJwtAuth;
     defaults: () => Partial<ClientJwtAuth>;
 }>;
+export declare enum OidcPolicyConfig_Tags {
+    Rego = "Rego",
+    RegoFile = "RegoFile",
+    Cel = "Cel"
+}
+/**
+ * Policy evaluated against JWT claims on every authenticated request (server-side OIDC only)
+ */
+export declare const OidcPolicyConfig: Readonly<{
+    instanceOf: (obj: any) => obj is OidcPolicyConfig;
+    Rego: {
+        new (inner: {
+            text: string;
+        }): {
+            readonly tag: OidcPolicyConfig_Tags.Rego;
+            readonly inner: Readonly<{
+                text: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OidcPolicyConfig";
+        };
+        "new"(inner: {
+            text: string;
+        }): {
+            readonly tag: OidcPolicyConfig_Tags.Rego;
+            readonly inner: Readonly<{
+                text: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OidcPolicyConfig";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: OidcPolicyConfig_Tags.Rego;
+            readonly inner: Readonly<{
+                text: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OidcPolicyConfig";
+        };
+    };
+    RegoFile: {
+        new (inner: {
+            path: string;
+        }): {
+            readonly tag: OidcPolicyConfig_Tags.RegoFile;
+            readonly inner: Readonly<{
+                path: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OidcPolicyConfig";
+        };
+        "new"(inner: {
+            path: string;
+        }): {
+            readonly tag: OidcPolicyConfig_Tags.RegoFile;
+            readonly inner: Readonly<{
+                path: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OidcPolicyConfig";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: OidcPolicyConfig_Tags.RegoFile;
+            readonly inner: Readonly<{
+                path: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OidcPolicyConfig";
+        };
+    };
+    Cel: {
+        new (inner: {
+            expression: string;
+        }): {
+            readonly tag: OidcPolicyConfig_Tags.Cel;
+            readonly inner: Readonly<{
+                expression: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OidcPolicyConfig";
+        };
+        "new"(inner: {
+            expression: string;
+        }): {
+            readonly tag: OidcPolicyConfig_Tags.Cel;
+            readonly inner: Readonly<{
+                expression: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OidcPolicyConfig";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: OidcPolicyConfig_Tags.Cel;
+            readonly inner: Readonly<{
+                expression: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OidcPolicyConfig";
+        };
+    };
+}>;
+/**
+ * Policy evaluated against JWT claims on every authenticated request (server-side OIDC only)
+ */
+export type OidcPolicyConfig = InstanceType<typeof OidcPolicyConfig['Rego' | 'RegoFile' | 'Cel']>;
+/**
+ * OIDC authentication configuration (client-credentials, refresh-token, or JWKS verification)
+ */
+export type OidcConfig = {
+    /**
+     * OIDC issuer URL (e.g., https://auth.example.com)
+     */
+    issuerUrl: string;
+    /**
+     * OAuth2 client ID (required for client-credentials and refresh-token flows)
+     */
+    clientId?: string;
+    /**
+     * OAuth2 client secret (for client-credentials flow)
+     */
+    clientSecret?: string;
+    /**
+     * Expected audience for JWT tokens (required for server-side verification)
+     */
+    audience?: string;
+    /**
+     * Inline refresh token (for authorization-code flow)
+     */
+    refreshToken?: string;
+    /**
+     * Path to file holding the refresh token (rotated tokens are written back automatically)
+     */
+    refreshTokenFile?: string;
+    /**
+     * Path to a file caching the current access token (optional companion to refresh_token_file)
+     */
+    accessTokenFile?: string;
+    /**
+     * OAuth2 scope parameter (client-side only)
+     */
+    scope?: string;
+    /**
+     * HTTP timeout for token requests in seconds (default: 30, client-side only)
+     */
+    timeout?: number;
+    /**
+     * JWKS cache TTL in seconds (default: 3600, server-side only)
+     */
+    jwksTtl?: number;
+    /**
+     * Cache TTL for merged JWT+userinfo claims in seconds (server-side only, absent = no cache)
+     */
+    claimCacheTtl?: number;
+    /**
+     * Policy evaluated against JWT claims on every authenticated request (server-side only)
+     */
+    policy?: OidcPolicyConfig;
+};
+/**
+ * Generated factory for {@link OidcConfig} record objects.
+ */
+export declare const OidcConfig: Readonly<{
+    create: (partial: Partial<OidcConfig> & Required<Omit<OidcConfig, "timeout" | "audience" | "issuerUrl" | "clientId" | "clientSecret" | "refreshToken" | "refreshTokenFile" | "accessTokenFile" | "scope" | "jwksTtl" | "claimCacheTtl" | "policy">>) => OidcConfig;
+    new: (partial: Partial<OidcConfig> & Required<Omit<OidcConfig, "timeout" | "audience" | "issuerUrl" | "clientId" | "clientSecret" | "refreshToken" | "refreshTokenFile" | "accessTokenFile" | "scope" | "jwksTtl" | "claimCacheTtl" | "policy">>) => OidcConfig;
+    defaults: () => Partial<OidcConfig>;
+}>;
 export declare enum ClientAuthenticationConfig_Tags {
     Basic = "Basic",
     StaticJwt = "StaticJwt",
     Jwt = "Jwt",
     Spire = "Spire",
+    Oidc = "Oidc",
     None = "None"
 }
 /**
@@ -1169,6 +1363,45 @@ export declare const ClientAuthenticationConfig: Readonly<{
             readonly [uniffiTypeNameSymbol]: "ClientAuthenticationConfig";
         };
     };
+    Oidc: {
+        new (inner: {
+            config: OidcConfig;
+        }): {
+            readonly tag: ClientAuthenticationConfig_Tags.Oidc;
+            readonly inner: Readonly<{
+                config: OidcConfig;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClientAuthenticationConfig";
+        };
+        "new"(inner: {
+            config: OidcConfig;
+        }): {
+            readonly tag: ClientAuthenticationConfig_Tags.Oidc;
+            readonly inner: Readonly<{
+                config: OidcConfig;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClientAuthenticationConfig";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ClientAuthenticationConfig_Tags.Oidc;
+            readonly inner: Readonly<{
+                config: OidcConfig;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClientAuthenticationConfig";
+        };
+    };
     None: {
         new (): {
             readonly tag: ClientAuthenticationConfig_Tags.None;
@@ -1199,7 +1432,7 @@ export declare const ClientAuthenticationConfig: Readonly<{
 /**
  * Authentication configuration enum for client
  */
-export type ClientAuthenticationConfig = InstanceType<typeof ClientAuthenticationConfig['Basic' | 'StaticJwt' | 'Jwt' | 'Spire' | 'None']>;
+export type ClientAuthenticationConfig = InstanceType<typeof ClientAuthenticationConfig['Basic' | 'StaticJwt' | 'Jwt' | 'Spire' | 'Oidc' | 'None']>;
 /**
  * Exponential backoff configuration
  */
@@ -1533,6 +1766,7 @@ export declare enum ServerAuthenticationConfig_Tags {
     Basic = "Basic",
     Jwt = "Jwt",
     Spire = "Spire",
+    Oidc = "Oidc",
     None = "None"
 }
 /**
@@ -1657,6 +1891,45 @@ export declare const ServerAuthenticationConfig: Readonly<{
             readonly [uniffiTypeNameSymbol]: "ServerAuthenticationConfig";
         };
     };
+    Oidc: {
+        new (inner: {
+            config: OidcConfig;
+        }): {
+            readonly tag: ServerAuthenticationConfig_Tags.Oidc;
+            readonly inner: Readonly<{
+                config: OidcConfig;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ServerAuthenticationConfig";
+        };
+        "new"(inner: {
+            config: OidcConfig;
+        }): {
+            readonly tag: ServerAuthenticationConfig_Tags.Oidc;
+            readonly inner: Readonly<{
+                config: OidcConfig;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ServerAuthenticationConfig";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ServerAuthenticationConfig_Tags.Oidc;
+            readonly inner: Readonly<{
+                config: OidcConfig;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ServerAuthenticationConfig";
+        };
+    };
     None: {
         new (): {
             readonly tag: ServerAuthenticationConfig_Tags.None;
@@ -1687,7 +1960,7 @@ export declare const ServerAuthenticationConfig: Readonly<{
 /**
  * Authentication configuration enum for server
  */
-export type ServerAuthenticationConfig = InstanceType<typeof ServerAuthenticationConfig['Basic' | 'Jwt' | 'Spire' | 'None']>;
+export type ServerAuthenticationConfig = InstanceType<typeof ServerAuthenticationConfig['Basic' | 'Jwt' | 'Spire' | 'Oidc' | 'None']>;
 /**
  * Server configuration for running a SLIM server
  */
@@ -5034,6 +5307,20 @@ declare const _default: Readonly<{
             lower(value: MlsSettings, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
         FfiConverterTypeName: FfiConverterObject<NameLike>;
+        FfiConverterTypeOidcConfig: {
+            read(from: RustBuffer): OidcConfig;
+            write(value: OidcConfig, into: RustBuffer): void;
+            allocationSize(value: OidcConfig): number;
+            lift(value: UniffiByteArray): OidcConfig;
+            lower(value: OidcConfig, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeOidcPolicyConfig: {
+            read(from: RustBuffer): OidcPolicyConfig;
+            write(value: OidcPolicyConfig, into: RustBuffer): void;
+            allocationSize(value: OidcPolicyConfig): number;
+            lift(value: UniffiByteArray): OidcPolicyConfig;
+            lower(value: OidcPolicyConfig, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeParticipantInfo: {
             read(from: RustBuffer): ParticipantInfo;
             write(value: ParticipantInfo, into: RustBuffer): void;

package/slim_bindings.js

@@ -1607,6 +1607,221 @@ const FfiConverterTypeClientJwtAuth = (() => {
     ;
     return new FFIConverter();
 })();
+// Enum: OidcPolicyConfig
+export var OidcPolicyConfig_Tags;
+(function (OidcPolicyConfig_Tags) {
+    OidcPolicyConfig_Tags["Rego"] = "Rego";
+    OidcPolicyConfig_Tags["RegoFile"] = "RegoFile";
+    OidcPolicyConfig_Tags["Cel"] = "Cel";
+})(OidcPolicyConfig_Tags || (OidcPolicyConfig_Tags = {}));
+/**
+ * Policy evaluated against JWT claims on every authenticated request (server-side OIDC only)
+ */
+export const OidcPolicyConfig = (() => {
+    var _f, _g, _h;
+    /**
+     * Inline Rego policy (must define `package slim.auth` with `default allow = false`)
+     */
+    class Rego_ extends UniffiEnum {
+        constructor(inner) {
+            super("OidcPolicyConfig", "Rego");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_f] = "OidcPolicyConfig";
+            this.tag = OidcPolicyConfig_Tags.Rego;
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Rego_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === OidcPolicyConfig_Tags.Rego;
+        }
+    }
+    _f = uniffiTypeNameSymbol;
+    /**
+     * Path to a Rego policy file read at server startup
+     */
+    class RegoFile_ extends UniffiEnum {
+        constructor(inner) {
+            super("OidcPolicyConfig", "RegoFile");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_g] = "OidcPolicyConfig";
+            this.tag = OidcPolicyConfig_Tags.RegoFile;
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new RegoFile_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === OidcPolicyConfig_Tags.RegoFile;
+        }
+    }
+    _g = uniffiTypeNameSymbol;
+    /**
+     * CEL expression evaluated against JWT claims (e.g. `"admin" in claims.groups`)
+     */
+    class Cel_ extends UniffiEnum {
+        constructor(inner) {
+            super("OidcPolicyConfig", "Cel");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_h] = "OidcPolicyConfig";
+            this.tag = OidcPolicyConfig_Tags.Cel;
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Cel_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === OidcPolicyConfig_Tags.Cel;
+        }
+    }
+    _h = uniffiTypeNameSymbol;
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "OidcPolicyConfig";
+    }
+    return Object.freeze({
+        instanceOf,
+        Rego: Rego_,
+        RegoFile: RegoFile_,
+        Cel: Cel_
+    });
+})();
+// FfiConverter for enum OidcPolicyConfig
+const FfiConverterTypeOidcPolicyConfig = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new OidcPolicyConfig.Rego({ text: FfiConverterString.read(from) });
+                case 2: return new OidcPolicyConfig.RegoFile({ path: FfiConverterString.read(from) });
+                case 3: return new OidcPolicyConfig.Cel({ expression: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case OidcPolicyConfig_Tags.Rego: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.text, into);
+                    return;
+                }
+                case OidcPolicyConfig_Tags.RegoFile: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.path, into);
+                    return;
+                }
+                case OidcPolicyConfig_Tags.Cel: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.expression, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that OidcPolicyConfig_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case OidcPolicyConfig_Tags.Rego: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.text);
+                    return size;
+                }
+                case OidcPolicyConfig_Tags.RegoFile: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner.path);
+                    return size;
+                }
+                case OidcPolicyConfig_Tags.Cel: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterString.allocationSize(inner.expression);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link OidcConfig} record objects.
+ */
+export const OidcConfig = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeOidcConfig = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                issuerUrl: FfiConverterString.read(from),
+                clientId: FfiConverterOptionalString.read(from),
+                clientSecret: FfiConverterOptionalString.read(from),
+                audience: FfiConverterOptionalString.read(from),
+                refreshToken: FfiConverterOptionalString.read(from),
+                refreshTokenFile: FfiConverterOptionalString.read(from),
+                accessTokenFile: FfiConverterOptionalString.read(from),
+                scope: FfiConverterOptionalString.read(from),
+                timeout: FfiConverterOptionalDuration.read(from),
+                jwksTtl: FfiConverterOptionalDuration.read(from),
+                claimCacheTtl: FfiConverterOptionalDuration.read(from),
+                policy: FfiConverterOptionalTypeOidcPolicyConfig.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.issuerUrl, into);
+            FfiConverterOptionalString.write(value.clientId, into);
+            FfiConverterOptionalString.write(value.clientSecret, into);
+            FfiConverterOptionalString.write(value.audience, into);
+            FfiConverterOptionalString.write(value.refreshToken, into);
+            FfiConverterOptionalString.write(value.refreshTokenFile, into);
+            FfiConverterOptionalString.write(value.accessTokenFile, into);
+            FfiConverterOptionalString.write(value.scope, into);
+            FfiConverterOptionalDuration.write(value.timeout, into);
+            FfiConverterOptionalDuration.write(value.jwksTtl, into);
+            FfiConverterOptionalDuration.write(value.claimCacheTtl, into);
+            FfiConverterOptionalTypeOidcPolicyConfig.write(value.policy, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.issuerUrl) +
+                FfiConverterOptionalString.allocationSize(value.clientId) +
+                FfiConverterOptionalString.allocationSize(value.clientSecret) +
+                FfiConverterOptionalString.allocationSize(value.audience) +
+                FfiConverterOptionalString.allocationSize(value.refreshToken) +
+                FfiConverterOptionalString.allocationSize(value.refreshTokenFile) +
+                FfiConverterOptionalString.allocationSize(value.accessTokenFile) +
+                FfiConverterOptionalString.allocationSize(value.scope) +
+                FfiConverterOptionalDuration.allocationSize(value.timeout) +
+                FfiConverterOptionalDuration.allocationSize(value.jwksTtl) +
+                FfiConverterOptionalDuration.allocationSize(value.claimCacheTtl) +
+                FfiConverterOptionalTypeOidcPolicyConfig.allocationSize(value.policy);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
 // Enum: ClientAuthenticationConfig
 export var ClientAuthenticationConfig_Tags;
 (function (ClientAuthenticationConfig_Tags) {
@@ -1614,13 +1829,14 @@ export var ClientAuthenticationConfig_Tags;
     ClientAuthenticationConfig_Tags["StaticJwt"] = "StaticJwt";
     ClientAuthenticationConfig_Tags["Jwt"] = "Jwt";
     ClientAuthenticationConfig_Tags["Spire"] = "Spire";
+    ClientAuthenticationConfig_Tags["Oidc"] = "Oidc";
     ClientAuthenticationConfig_Tags["None"] = "None";
 })(ClientAuthenticationConfig_Tags || (ClientAuthenticationConfig_Tags = {}));
 /**
  * Authentication configuration enum for client
  */
 export const ClientAuthenticationConfig = (() => {
-    var _f, _g, _h, _j, _k;
+    var _f, _g, _h, _j, _k, _l;
     class Basic_ extends UniffiEnum {
         constructor(inner) {
             super("ClientAuthenticationConfig", "Basic");
@@ -1700,6 +1916,28 @@ export const ClientAuthenticationConfig = (() => {
         }
     }
     _j = uniffiTypeNameSymbol;
+    /**
+     * OIDC authentication (client-credentials or refresh-token flow)
+     */
+    class Oidc_ extends UniffiEnum {
+        constructor(inner) {
+            super("ClientAuthenticationConfig", "Oidc");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_k] = "ClientAuthenticationConfig";
+            this.tag = ClientAuthenticationConfig_Tags.Oidc;
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Oidc_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === ClientAuthenticationConfig_Tags.Oidc;
+        }
+    }
+    _k = uniffiTypeNameSymbol;
     class None_ extends UniffiEnum {
         constructor() {
             super("ClientAuthenticationConfig", "None");
@@ -1707,7 +1945,7 @@ export const ClientAuthenticationConfig = (() => {
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            this[_k] = "ClientAuthenticationConfig";
+            this[_l] = "ClientAuthenticationConfig";
             this.tag = ClientAuthenticationConfig_Tags.None;
         }
         static new() {
@@ -1717,7 +1955,7 @@ export const ClientAuthenticationConfig = (() => {
             return obj.tag === ClientAuthenticationConfig_Tags.None;
         }
     }
-    _k = uniffiTypeNameSymbol;
+    _l = uniffiTypeNameSymbol;
     function instanceOf(obj) {
         return obj[uniffiTypeNameSymbol] === "ClientAuthenticationConfig";
     }
@@ -1727,6 +1965,7 @@ export const ClientAuthenticationConfig = (() => {
         StaticJwt: StaticJwt_,
         Jwt: Jwt_,
         Spire: Spire_,
+        Oidc: Oidc_,
         None: None_
     });
 })();
@@ -1740,7 +1979,8 @@ const FfiConverterTypeClientAuthenticationConfig = (() => {
                 case 2: return new ClientAuthenticationConfig.StaticJwt({ config: FfiConverterTypeStaticJwtAuth.read(from) });
                 case 3: return new ClientAuthenticationConfig.Jwt({ config: FfiConverterTypeClientJwtAuth.read(from) });
                 case 4: return new ClientAuthenticationConfig.Spire({ config: FfiConverterTypeSpireConfig.read(from) });
-                case 5: return new ClientAuthenticationConfig.None();
+                case 5: return new ClientAuthenticationConfig.Oidc({ config: FfiConverterTypeOidcConfig.read(from) });
+                case 6: return new ClientAuthenticationConfig.None();
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
@@ -1770,8 +2010,14 @@ const FfiConverterTypeClientAuthenticationConfig = (() => {
                     FfiConverterTypeSpireConfig.write(inner.config, into);
                     return;
                 }
-                case ClientAuthenticationConfig_Tags.None: {
+                case ClientAuthenticationConfig_Tags.Oidc: {
                     ordinalConverter.write(5, into);
+                    const inner = value.inner;
+                    FfiConverterTypeOidcConfig.write(inner.config, into);
+                    return;
+                }
+                case ClientAuthenticationConfig_Tags.None: {
+                    ordinalConverter.write(6, into);
                     return;
                 }
                 default:
@@ -1805,8 +2051,14 @@ const FfiConverterTypeClientAuthenticationConfig = (() => {
                     size += FfiConverterTypeSpireConfig.allocationSize(inner.config);
                     return size;
                 }
+                case ClientAuthenticationConfig_Tags.Oidc: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(5);
+                    size += FfiConverterTypeOidcConfig.allocationSize(inner.config);
+                    return size;
+                }
                 case ClientAuthenticationConfig_Tags.None: {
-                    return ordinalConverter.allocationSize(5);
+                    return ordinalConverter.allocationSize(6);
                 }
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
@@ -2213,13 +2465,14 @@ export var ServerAuthenticationConfig_Tags;
     ServerAuthenticationConfig_Tags["Basic"] = "Basic";
     ServerAuthenticationConfig_Tags["Jwt"] = "Jwt";
     ServerAuthenticationConfig_Tags["Spire"] = "Spire";
+    ServerAuthenticationConfig_Tags["Oidc"] = "Oidc";
     ServerAuthenticationConfig_Tags["None"] = "None";
 })(ServerAuthenticationConfig_Tags || (ServerAuthenticationConfig_Tags = {}));
 /**
  * Authentication configuration enum for server
  */
 export const ServerAuthenticationConfig = (() => {
-    var _f, _g, _h, _j;
+    var _f, _g, _h, _j, _k;
     class Basic_ extends UniffiEnum {
         constructor(inner) {
             super("ServerAuthenticationConfig", "Basic");
@@ -2280,6 +2533,28 @@ export const ServerAuthenticationConfig = (() => {
         }
     }
     _h = uniffiTypeNameSymbol;
+    /**
+     * OIDC authentication (JWKS-based JWT verification with optional policy)
+     */
+    class Oidc_ extends UniffiEnum {
+        constructor(inner) {
+            super("ServerAuthenticationConfig", "Oidc");
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            this[_j] = "ServerAuthenticationConfig";
+            this.tag = ServerAuthenticationConfig_Tags.Oidc;
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Oidc_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === ServerAuthenticationConfig_Tags.Oidc;
+        }
+    }
+    _j = uniffiTypeNameSymbol;
     class None_ extends UniffiEnum {
         constructor() {
             super("ServerAuthenticationConfig", "None");
@@ -2287,7 +2562,7 @@ export const ServerAuthenticationConfig = (() => {
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            this[_j] = "ServerAuthenticationConfig";
+            this[_k] = "ServerAuthenticationConfig";
             this.tag = ServerAuthenticationConfig_Tags.None;
         }
         static new() {
@@ -2297,7 +2572,7 @@ export const ServerAuthenticationConfig = (() => {
             return obj.tag === ServerAuthenticationConfig_Tags.None;
         }
     }
-    _j = uniffiTypeNameSymbol;
+    _k = uniffiTypeNameSymbol;
     function instanceOf(obj) {
         return obj[uniffiTypeNameSymbol] === "ServerAuthenticationConfig";
     }
@@ -2306,6 +2581,7 @@ export const ServerAuthenticationConfig = (() => {
         Basic: Basic_,
         Jwt: Jwt_,
         Spire: Spire_,
+        Oidc: Oidc_,
         None: None_
     });
 })();
@@ -2318,7 +2594,8 @@ const FfiConverterTypeServerAuthenticationConfig = (() => {
                 case 1: return new ServerAuthenticationConfig.Basic({ config: FfiConverterTypeBasicAuth.read(from) });
                 case 2: return new ServerAuthenticationConfig.Jwt({ config: FfiConverterTypeJwtAuth.read(from) });
                 case 3: return new ServerAuthenticationConfig.Spire({ config: FfiConverterTypeSpireConfig.read(from) });
-                case 4: return new ServerAuthenticationConfig.None();
+                case 4: return new ServerAuthenticationConfig.Oidc({ config: FfiConverterTypeOidcConfig.read(from) });
+                case 5: return new ServerAuthenticationConfig.None();
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
@@ -2342,8 +2619,14 @@ const FfiConverterTypeServerAuthenticationConfig = (() => {
                     FfiConverterTypeSpireConfig.write(inner.config, into);
                     return;
                 }
-                case ServerAuthenticationConfig_Tags.None: {
+                case ServerAuthenticationConfig_Tags.Oidc: {
                     ordinalConverter.write(4, into);
+                    const inner = value.inner;
+                    FfiConverterTypeOidcConfig.write(inner.config, into);
+                    return;
+                }
+                case ServerAuthenticationConfig_Tags.None: {
+                    ordinalConverter.write(5, into);
                     return;
                 }
                 default:
@@ -2371,8 +2654,14 @@ const FfiConverterTypeServerAuthenticationConfig = (() => {
                     size += FfiConverterTypeSpireConfig.allocationSize(inner.config);
                     return size;
                 }
+                case ServerAuthenticationConfig_Tags.Oidc: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(4);
+                    size += FfiConverterTypeOidcConfig.allocationSize(inner.config);
+                    return size;
+                }
                 case ServerAuthenticationConfig_Tags.None: {
-                    return ordinalConverter.allocationSize(4);
+                    return ordinalConverter.allocationSize(5);
                 }
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
@@ -6444,6 +6733,8 @@ const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
 const FfiConverterOptionalMapStringString = new FfiConverterOptional(FfiConverterMapStringString);
 // FfiConverter for Array<string> | undefined
 const FfiConverterOptionalSequenceString = new FfiConverterOptional(FfiConverterSequenceString);
+// FfiConverter for OidcPolicyConfig | undefined
+const FfiConverterOptionalTypeOidcPolicyConfig = new FfiConverterOptional(FfiConverterTypeOidcPolicyConfig);
 // FfiConverter for ClientAuthenticationConfig | undefined
 const FfiConverterOptionalTypeClientAuthenticationConfig = new FfiConverterOptional(FfiConverterTypeClientAuthenticationConfig);
 // FfiConverter for BackoffConfig | undefined
@@ -6894,6 +7185,8 @@ export default Object.freeze({
         FfiConverterTypeMessageContext,
         FfiConverterTypeMlsSettings,
         FfiConverterTypeName,
+        FfiConverterTypeOidcConfig,
+        FfiConverterTypeOidcPolicyConfig,
         FfiConverterTypeParticipantInfo,
         FfiConverterTypeParticipantStatus,
         FfiConverterTypePersistenceConfig,