@zuplo/cli 6.72.0 → 6.72.1

package/node_modules/@zuplo/runtime/out/types/index.d.ts

@@ -885,6 +885,15 @@ declare interface AmberfloMeteringProperties extends Omit<
   customerId: string;
 }
 
+declare interface AndRule {
+  /**
+   * Nested rules that must all pass.
+   *
+   * @minItems 1
+   */
+  and: [NestedRule, ...NestedRule[]];
+}
+
 declare interface AnthropicMessage {
   role: "user" | "assistant";
   content:
@@ -1591,7 +1600,7 @@ export declare interface Auth0JwtInboundPolicyOptions {
  *
  * @title AuthZEN Authorization
  * @product api-gateway
- * @beta
+ * @public
  * @enterprise
  * @param request - The ZuploRequest
  * @param context - The ZuploContext
@@ -1912,7 +1921,7 @@ export declare class AWSLoggingPlugin extends LogPlugin {
  *
  * @title Axiomatics Authorization
  * @product api-gateway
- * @beta
+ * @public
  * @enterprise
  * @param request - The ZuploRequest
  * @param context - The ZuploContext
@@ -2647,6 +2656,18 @@ declare type CheckIntervalMs = number;
  */
 declare type CheckIntervalMs_2 = number;
 
+/**
+ * A light JSON-path selector into the authenticated user's claims (request.user.data). Use dot notation for nested claims, e.g. 'address.country'. Use bracket notation with quotes for claim names that contain dots or slashes — namespaced claims — e.g. ["https://sts.amazonaws.com/"]["lambda_source_function_arn"]; the two notations may be mixed. A missing claim always fails the check.
+ * @public
+ */
+declare type Claim = string;
+
+/**
+ * A single claim check using exactly one operator: eq, in, or startsWith.
+ * @public
+ */
+declare type ClaimCheck = EqualsRule | InRule | StartsWithRule;
+
 /**
  * Removes all headers from the incoming request except for those in the exclude list.
  *
@@ -3944,6 +3965,14 @@ declare type EnableStreamingAccumulation_2 = boolean;
  */
 export declare const environment: Record<string, string | undefined>;
 
+declare interface EqualsRule {
+  claim: Claim;
+  /**
+   * The exact value the claim must equal. Comparison is strict and type-sensitive: the string '42' does not equal the number 42. When the claim value is an array, the check passes if any element equals this value.
+   */
+  eq: string | number | boolean;
+}
+
 /**
  * @beta
  */
@@ -6375,6 +6404,45 @@ declare interface IncomingRequestProperties {
   /* Excluded from this release type: clientCertSubjectDn */
 }
 
+declare interface InnermostAndRule {
+  /**
+   * Claim checks that must all pass. The maximum combinator nesting depth is reached, so entries must be single claim checks.
+   *
+   * @minItems 1
+   */
+  and: [ClaimCheck, ...ClaimCheck[]];
+}
+
+declare interface InnermostOrRule {
+  /**
+   * Claim checks of which at least one must pass. The maximum combinator nesting depth is reached, so entries must be single claim checks.
+   *
+   * @minItems 1
+   */
+  or: [ClaimCheck, ...ClaimCheck[]];
+}
+
+/**
+ * A third-level rule: a single claim check or an and/or combination of claim checks. Combinators cannot nest any deeper.
+ * @public
+ */
+declare type InnermostRule =
+  | InnermostAndRule
+  | InnermostOrRule
+  | EqualsRule
+  | InRule
+  | StartsWithRule;
+
+declare interface InRule {
+  claim: Claim;
+  /**
+   * Allowed values for the claim. The check passes when the claim value equals any listed value (strict, type-sensitive comparison). When the claim value is an array, the check passes if any element equals any listed value.
+   *
+   * @minItems 1
+   */
+  in: [string | number | boolean, ...(string | number | boolean)[]];
+}
+
 /**
  * ISO 3166-1 Alpha-2 codes
  * @public
@@ -8756,6 +8824,35 @@ declare interface MultiRequests {
   RequestReference: RequestReference;
 }
 
+declare interface NestedAndRule {
+  /**
+   * Nested rules that must all pass.
+   *
+   * @minItems 1
+   */
+  and: [InnermostRule, ...InnermostRule[]];
+}
+
+declare interface NestedOrRule {
+  /**
+   * Nested rules of which at least one must pass.
+   *
+   * @minItems 1
+   */
+  or: [InnermostRule, ...InnermostRule[]];
+}
+
+/**
+ * A second-level rule: a single claim check or an and/or combination of third-level rules.
+ * @public
+ */
+declare type NestedRule =
+  | NestedAndRule
+  | NestedOrRule
+  | EqualsRule
+  | InRule
+  | StartsWithRule;
+
 declare interface NewRelicLoggingOptions {
   url?: string;
   apiKey: string;
@@ -8849,7 +8946,7 @@ export declare interface OAuthProtectedResourcePluginOptions {
  *
  * @title Okta FGA Authorization
  * @product api-gateway
- * @beta
+ * @public
  * @enterprise
  * @param request - The ZuploRequest
  * @param context - The ZuploContext
@@ -9589,7 +9686,7 @@ declare namespace OpenAPIV3_1 {
  *
  * @title OpenFGA Authorization
  * @product api-gateway
- * @beta
+ * @public
  * @enterprise
  * @param request - The ZuploRequest
  * @param context - The ZuploContext
@@ -9834,6 +9931,15 @@ export declare interface OpenMeterInboundPolicyOptions {
   subjectPath?: string;
 }
 
+declare interface OrRule {
+  /**
+   * Nested rules of which at least one must pass.
+   *
+   * @minItems 1
+   */
+  or: [NestedRule, ...NestedRule[]];
+}
+
 /**
  * Context for adding per-request attributes to OTel metrics
  * @public
@@ -11127,6 +11233,708 @@ export declare interface RequireOriginInboundPolicyOptions {
   failureDetail?: string;
 }
 
+/**
+ * Authorizes requests by validating claims on the authenticated user
+ * (`request.user`) against a configurable rule of `and`/`or` combinators and
+ * per-claim `eq`, `in`, and `startsWith` checks. Run it after any
+ * authentication policy that populates `request.user` — a JWT auth policy, API
+ * key auth, mTLS, and so on — to allow only specific callers (service
+ * accounts, OAuth clients, tenants, groups) without writing custom code.
+ *
+ * Every check fails closed: a missing or non-primitive claim never matches,
+ * comparisons are strict and type-sensitive, and requests without an
+ * authenticated user receive a 401 response. Denied requests receive a 403
+ * response that does not echo claim values or expected values; the failing
+ * checks are written to the request log instead.
+ *
+ * Validation of the options runs lazily inside the policy constructor, which
+ * the runtime caches per policy name. Misconfigured options therefore fail on
+ * first use with a customer-facing `ConfigurationError` instead of failing at
+ * module load.
+ *
+ * @title Require User Claims
+ * @product api-gateway
+ * @public
+ */
+export declare class RequireUserClaimsInboundPolicy extends InboundPolicy<ValidatedOptions> {
+  #private;
+  static readonly policyType = "require-user-claims";
+  constructor(rawOptions: unknown, policyName: string);
+  handler(
+    request: ZuploRequest,
+    context: ZuploContext
+  ): Promise<ZuploRequest | Response>;
+}
+
+/**
+ * The options for this policy.
+ * @public
+ */
+export declare interface RequireUserClaimsInboundPolicyOptions {
+  rule: Rule;
+}
+
+declare const requireUserClaimsOptionsSchema: z.ZodObject<
+  {
+    rule: z.ZodUnion<
+      readonly [
+        z.ZodObject<
+          {
+            and: z.ZodArray<
+              z.ZodUnion<
+                readonly [
+                  z.ZodObject<
+                    {
+                      and: z.ZodArray<
+                        z.ZodUnion<
+                          readonly [
+                            z.ZodObject<
+                              {
+                                and: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          eq: z.ZodUnion<
+                                            readonly [
+                                              z.ZodString,
+                                              z.ZodNumber,
+                                              z.ZodBoolean,
+                                            ]
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          in: z.ZodArray<
+                                            z.ZodUnion<
+                                              readonly [
+                                                z.ZodString,
+                                                z.ZodNumber,
+                                                z.ZodBoolean,
+                                              ]
+                                            >
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          startsWith: z.ZodString;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                or: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          eq: z.ZodUnion<
+                                            readonly [
+                                              z.ZodString,
+                                              z.ZodNumber,
+                                              z.ZodBoolean,
+                                            ]
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          in: z.ZodArray<
+                                            z.ZodUnion<
+                                              readonly [
+                                                z.ZodString,
+                                                z.ZodNumber,
+                                                z.ZodBoolean,
+                                              ]
+                                            >
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          startsWith: z.ZodString;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                eq: z.ZodUnion<
+                                  readonly [
+                                    z.ZodString,
+                                    z.ZodNumber,
+                                    z.ZodBoolean,
+                                  ]
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                in: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodString,
+                                      z.ZodNumber,
+                                      z.ZodBoolean,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                startsWith: z.ZodString;
+                              },
+                              z.core.$strict
+                            >,
+                          ]
+                        >
+                      >;
+                    },
+                    z.core.$strict
+                  >,
+                  z.ZodObject<
+                    {
+                      or: z.ZodArray<
+                        z.ZodUnion<
+                          readonly [
+                            z.ZodObject<
+                              {
+                                and: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          eq: z.ZodUnion<
+                                            readonly [
+                                              z.ZodString,
+                                              z.ZodNumber,
+                                              z.ZodBoolean,
+                                            ]
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          in: z.ZodArray<
+                                            z.ZodUnion<
+                                              readonly [
+                                                z.ZodString,
+                                                z.ZodNumber,
+                                                z.ZodBoolean,
+                                              ]
+                                            >
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          startsWith: z.ZodString;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                or: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          eq: z.ZodUnion<
+                                            readonly [
+                                              z.ZodString,
+                                              z.ZodNumber,
+                                              z.ZodBoolean,
+                                            ]
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          in: z.ZodArray<
+                                            z.ZodUnion<
+                                              readonly [
+                                                z.ZodString,
+                                                z.ZodNumber,
+                                                z.ZodBoolean,
+                                              ]
+                                            >
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          startsWith: z.ZodString;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                eq: z.ZodUnion<
+                                  readonly [
+                                    z.ZodString,
+                                    z.ZodNumber,
+                                    z.ZodBoolean,
+                                  ]
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                in: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodString,
+                                      z.ZodNumber,
+                                      z.ZodBoolean,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                startsWith: z.ZodString;
+                              },
+                              z.core.$strict
+                            >,
+                          ]
+                        >
+                      >;
+                    },
+                    z.core.$strict
+                  >,
+                  z.ZodObject<
+                    {
+                      claim: z.ZodString;
+                      eq: z.ZodUnion<
+                        readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]
+                      >;
+                    },
+                    z.core.$strict
+                  >,
+                  z.ZodObject<
+                    {
+                      claim: z.ZodString;
+                      in: z.ZodArray<
+                        z.ZodUnion<
+                          readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]
+                        >
+                      >;
+                    },
+                    z.core.$strict
+                  >,
+                  z.ZodObject<
+                    {
+                      claim: z.ZodString;
+                      startsWith: z.ZodString;
+                    },
+                    z.core.$strict
+                  >,
+                ]
+              >
+            >;
+          },
+          z.core.$strict
+        >,
+        z.ZodObject<
+          {
+            or: z.ZodArray<
+              z.ZodUnion<
+                readonly [
+                  z.ZodObject<
+                    {
+                      and: z.ZodArray<
+                        z.ZodUnion<
+                          readonly [
+                            z.ZodObject<
+                              {
+                                and: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          eq: z.ZodUnion<
+                                            readonly [
+                                              z.ZodString,
+                                              z.ZodNumber,
+                                              z.ZodBoolean,
+                                            ]
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          in: z.ZodArray<
+                                            z.ZodUnion<
+                                              readonly [
+                                                z.ZodString,
+                                                z.ZodNumber,
+                                                z.ZodBoolean,
+                                              ]
+                                            >
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          startsWith: z.ZodString;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                or: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          eq: z.ZodUnion<
+                                            readonly [
+                                              z.ZodString,
+                                              z.ZodNumber,
+                                              z.ZodBoolean,
+                                            ]
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          in: z.ZodArray<
+                                            z.ZodUnion<
+                                              readonly [
+                                                z.ZodString,
+                                                z.ZodNumber,
+                                                z.ZodBoolean,
+                                              ]
+                                            >
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          startsWith: z.ZodString;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                eq: z.ZodUnion<
+                                  readonly [
+                                    z.ZodString,
+                                    z.ZodNumber,
+                                    z.ZodBoolean,
+                                  ]
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                in: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodString,
+                                      z.ZodNumber,
+                                      z.ZodBoolean,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                startsWith: z.ZodString;
+                              },
+                              z.core.$strict
+                            >,
+                          ]
+                        >
+                      >;
+                    },
+                    z.core.$strict
+                  >,
+                  z.ZodObject<
+                    {
+                      or: z.ZodArray<
+                        z.ZodUnion<
+                          readonly [
+                            z.ZodObject<
+                              {
+                                and: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          eq: z.ZodUnion<
+                                            readonly [
+                                              z.ZodString,
+                                              z.ZodNumber,
+                                              z.ZodBoolean,
+                                            ]
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          in: z.ZodArray<
+                                            z.ZodUnion<
+                                              readonly [
+                                                z.ZodString,
+                                                z.ZodNumber,
+                                                z.ZodBoolean,
+                                              ]
+                                            >
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          startsWith: z.ZodString;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                or: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          eq: z.ZodUnion<
+                                            readonly [
+                                              z.ZodString,
+                                              z.ZodNumber,
+                                              z.ZodBoolean,
+                                            ]
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          in: z.ZodArray<
+                                            z.ZodUnion<
+                                              readonly [
+                                                z.ZodString,
+                                                z.ZodNumber,
+                                                z.ZodBoolean,
+                                              ]
+                                            >
+                                          >;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                      z.ZodObject<
+                                        {
+                                          claim: z.ZodString;
+                                          startsWith: z.ZodString;
+                                        },
+                                        z.core.$strict
+                                      >,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                eq: z.ZodUnion<
+                                  readonly [
+                                    z.ZodString,
+                                    z.ZodNumber,
+                                    z.ZodBoolean,
+                                  ]
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                in: z.ZodArray<
+                                  z.ZodUnion<
+                                    readonly [
+                                      z.ZodString,
+                                      z.ZodNumber,
+                                      z.ZodBoolean,
+                                    ]
+                                  >
+                                >;
+                              },
+                              z.core.$strict
+                            >,
+                            z.ZodObject<
+                              {
+                                claim: z.ZodString;
+                                startsWith: z.ZodString;
+                              },
+                              z.core.$strict
+                            >,
+                          ]
+                        >
+                      >;
+                    },
+                    z.core.$strict
+                  >,
+                  z.ZodObject<
+                    {
+                      claim: z.ZodString;
+                      eq: z.ZodUnion<
+                        readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]
+                      >;
+                    },
+                    z.core.$strict
+                  >,
+                  z.ZodObject<
+                    {
+                      claim: z.ZodString;
+                      in: z.ZodArray<
+                        z.ZodUnion<
+                          readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]
+                        >
+                      >;
+                    },
+                    z.core.$strict
+                  >,
+                  z.ZodObject<
+                    {
+                      claim: z.ZodString;
+                      startsWith: z.ZodString;
+                    },
+                    z.core.$strict
+                  >,
+                ]
+              >
+            >;
+          },
+          z.core.$strict
+        >,
+        z.ZodObject<
+          {
+            claim: z.ZodString;
+            eq: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+          },
+          z.core.$strict
+        >,
+        z.ZodObject<
+          {
+            claim: z.ZodString;
+            in: z.ZodArray<
+              z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>
+            >;
+          },
+          z.core.$strict
+        >,
+        z.ZodObject<
+          {
+            claim: z.ZodString;
+            startsWith: z.ZodString;
+          },
+          z.core.$strict
+        >,
+      ]
+    >;
+  },
+  z.core.$strict
+>;
+
 declare type ResolveRequestParams<
   TParams extends RequestParamsDefault | undefined,
 > = TParams extends RequestParamsDefault ? TParams : RequestParamsDefault;
@@ -11406,6 +12214,12 @@ export declare interface RouteHandler<T = unknown> {
 
 /* Excluded from this release type: Router */
 
+/**
+ * The authorization rule evaluated against the authenticated user's claims (request.user.data, populated by the authentication policy that runs before this one — a JWT policy, API key auth, mTLS, etc.). A rule is either a single claim check (eq, in, or startsWith) or an and/or combination of nested rules. Combinators may nest up to three levels deep. Requests that fail the rule receive a 403 Forbidden response.
+ * @public
+ */
+declare type Rule = AndRule | OrRule | EqualsRule | InRule | StartsWithRule;
+
 /* Excluded from this release type: RuntimeEnvironment */
 
 /**
@@ -11558,7 +12372,7 @@ export declare interface SecretMaskingOutboundPolicyOptions {
  *
  * @title Semantic Cache
  * @product ai-gateway
- * @beta
+ * @public
  * @enterprise
  * @requiresAI
  * @param request - The ZuploRequest
@@ -11947,6 +12761,14 @@ export declare class SplunkLoggingPlugin extends LogPlugin {
 
 /* Excluded from this release type: StandardEnv */
 
+declare interface StartsWithRule {
+  claim: Claim;
+  /**
+   * The prefix the claim's string value must start with. Non-string claim values never match. Must not be empty — an empty prefix would match every value. When the claim value is an array, the check passes if any string element starts with this prefix.
+   */
+  startsWith: string;
+}
+
 /**
  * Configuration for accumulating and validating streaming responses.
  * @public
@@ -12427,7 +13249,7 @@ export declare interface UpstreamFirebaseUserAuthInboundPolicyOptions {
  *
  * @title Upstream GCP Federated Auth
  * @product api-gateway
- * @beta
+ * @public
  * @enterprise
  * @param request - The ZuploRequest
  * @param context - The ZuploContext
@@ -12799,6 +13621,8 @@ declare type ValidatedAuth0OAuthOptions = z.infer<
   typeof mcpAuth0OAuthOptionsSchema
 >;
 
+declare type ValidatedOptions = z.infer<typeof requireUserClaimsOptionsSchema>;
+
 /**
  * Validates the body of an incoming request based on a JSON schema.
  *