aws-iam-language-server 0.0.16 → 0.0.17

package/src/handlers/hover/condition-block.js

@@ -1,18 +1,14 @@
 import { MarkupKind } from 'vscode-languageserver';
-const conditionBlockAttributes = {
-    test: 'The condition operator to evaluate (e.g., `StringEquals`, `ArnLike`, `IpAddress`).',
-    variable: 'The condition key to evaluate (e.g., `aws:SourceIp`, `s3:prefix`).',
-    values: 'List of values to compare against the condition key.',
-};
+import { conditionBlockAttributes } from "../../lib/iam-policy/reference/documentation.js";
 export function handleConditionBlockHover(location) {
-    const description = conditionBlockAttributes[location.value];
-    if (!description)
+    const attr = conditionBlockAttributes[location.value];
+    if (!attr)
         return null;
     return {
         range: location.range,
         contents: {
             kind: MarkupKind.Markdown,
-            value: description,
+            value: attr.description,
         },
     };
 }

package/src/handlers/hover/condition-key.js

@@ -1,6 +1,6 @@
 import { MarkupKind } from 'vscode-languageserver';
+import { formatConditionKeyDocumentation } from "../../lib/iam-policy/reference/documentation.js";
 import { ServiceReference } from "../../lib/iam-policy/reference/services.js";
-import { formatConditionKeyDocumentation } from "../completion/condition-key.js";
 const placeholderPattern = /\$\{[^}]+\}/g;
 function patternToRegex(pattern) {
     const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -32,22 +32,25 @@ export function handleConditionKeyHover(location) {
         return null;
     const globalKeys = ServiceReference.getGlobalConditionKeys();
     const service = keyName.split(':')[0];
-    let global = globalKeys.find((k) => k.name === keyName);
+    let globalKey = globalKeys.find((k) => k.name === keyName);
     let conditionKey = service ? ServiceReference.getConditionKey(service, keyName) : undefined;
-    if (!global && !conditionKey) {
+    if (!globalKey && !conditionKey) {
         const match = findByPattern(keyName, globalKeys, service);
         if (!match)
             return null;
-        global = match.global;
+        globalKey = match.global;
         conditionKey = match.conditionKey;
     }
-    const types = conditionKey?.types ?? [];
-    const docs = formatConditionKeyDocumentation(types, global, conditionKey);
+    const keyDocs = [];
+    if (globalKey)
+        keyDocs.push(formatConditionKeyDocumentation(globalKey));
+    if (conditionKey)
+        keyDocs.push(formatConditionKeyDocumentation(conditionKey));
     return {
         range: location.range,
         contents: {
             kind: MarkupKind.Markdown,
-            value: `**${keyName}**\n\n${docs}`,
+            value: keyDocs.join('\n---\n'),
         },
     };
 }

package/src/handlers/hover/condition-operator.js

@@ -1,5 +1,6 @@
 import { MarkupKind } from 'vscode-languageserver';
 import { conditionOperators } from "../../lib/iam-policy/condition-operators.js";
+import { formatConditionOperatorDocumentation } from "../../lib/iam-policy/reference/documentation.js";
 export function handleConditionOperatorHover(location) {
     const operator = conditionOperators[location.value];
     if (!operator)
@@ -8,7 +9,7 @@ export function handleConditionOperatorHover(location) {
         range: location.range,
         contents: {
             kind: MarkupKind.Markdown,
-            value: operator.description,
+            value: formatConditionOperatorDocumentation(operator),
         },
     };
 }

package/src/handlers/hover/effect-value.js

@@ -1,17 +1,14 @@
 import { MarkupKind } from 'vscode-languageserver';
-const effectDescriptions = {
-    Allow: 'Grants access to the specified resources and actions.\n\nBy default, all requests are implicitly denied. An `Allow` overrides implicit denies but never overrides an explicit `Deny`.',
-    Deny: 'Explicitly denies access to the specified resources and actions.\n\nAn explicit `Deny` always takes precedence — it overrides any `Allow` statements, regardless of where they appear.',
-};
+import { effects, formatEffectDocumentation } from "../../lib/iam-policy/reference/documentation.js";
 export function handleEffectValueHover(location) {
-    const description = effectDescriptions[location.value];
-    if (!description)
+    const effect = effects[location.value];
+    if (!effect)
         return null;
     return {
         range: location.range,
         contents: {
             kind: MarkupKind.Markdown,
-            value: description,
+            value: formatEffectDocumentation(effect),
         },
     };
 }

package/src/handlers/hover/index.js

@@ -15,8 +15,7 @@ export function hoverHandler(params, treeManager, connection) {
     const handler = treeManager.getLanguageHandler(params.textDocument.uri);
     if (!handler)
         return null;
-    const position = params.position;
-    const cursorContext = handler.getCursorContext(params.textDocument.uri, position);
+    const cursorContext = handler.getCursorContext(params.textDocument.uri, params.position);
     if (!cursorContext)
         return null;
     const location = resolvePolicyLocation(cursorContext);

package/src/handlers/hover/principal-block.js

@@ -1,17 +1,14 @@
 import { MarkupKind } from 'vscode-languageserver';
-const principalBlockAttributes = {
-    type: 'The type of principal. Valid values: `*`, `AWS`, `Service`, `Federated`, `CanonicalUser`.',
-    identifiers: 'List of principal identifiers. The format depends on the `type` attribute.',
-};
+import { formatPrincipalBlockAttributeDocumentation, principalBlockAttributes, } from "../../lib/iam-policy/reference/documentation.js";
 export function handlePrincipalBlockHover(location) {
-    const description = principalBlockAttributes[location.value];
-    if (!description)
+    const principalBlockAttribute = principalBlockAttributes[location.value];
+    if (!principalBlockAttribute)
         return null;
     return {
         range: location.range,
         contents: {
             kind: MarkupKind.Markdown,
-            value: description,
+            value: formatPrincipalBlockAttributeDocumentation(principalBlockAttribute),
         },
     };
 }

package/src/handlers/hover/principal-type.js

@@ -1,22 +1,14 @@
 import { MarkupKind } from 'vscode-languageserver';
 import { principalTypes } from "../../lib/iam-policy/principals.js";
+import { formatPrincipalTypeDocumentation } from "../../lib/iam-policy/reference/documentation.js";
 export function handlePrincipalTypeHover(location) {
-    if (location.value === '*') {
-        return {
-            range: location.range,
-            contents: {
-                kind: MarkupKind.Markdown,
-                value: '**Public (unauthenticated) access**\n\nMatches all principals, including anonymous users.',
-            },
-        };
-    }
     for (const principalType of Object.values(principalTypes)) {
-        if (principalType.value === location.value) {
+        if (principalType.name === location.value) {
             return {
                 range: location.range,
                 contents: {
                     kind: MarkupKind.Markdown,
-                    value: principalType.description,
+                    value: formatPrincipalTypeDocumentation(principalType),
                 },
             };
         }

package/src/handlers/hover/principal-typed-value.js

@@ -1,4 +1,5 @@
 import { MarkupKind } from 'vscode-languageserver';
+import { formatPrincipalTypedValueDocumentation, principalTypedValues, } from "../../lib/iam-policy/reference/documentation.js";
 import { ServiceReference } from "../../lib/iam-policy/reference/services.js";
 export function handlePrincipalTypedValueHover(location) {
     if (location.value === '*') {
@@ -6,7 +7,7 @@ export function handlePrincipalTypedValueHover(location) {
             range: location.range,
             contents: {
                 kind: MarkupKind.Markdown,
-                value: '**All principals** of this type.',
+                value: formatPrincipalTypedValueDocumentation(principalTypedValues['*']),
             },
         };
     }
@@ -14,12 +15,11 @@ export function handlePrincipalTypedValueHover(location) {
     if (principalType === 'Service') {
         const principals = ServiceReference.getServicePrincipals();
         if (principals.includes(location.value)) {
-            const serviceName = location.value.split('.')[0];
             return {
                 range: location.range,
                 contents: {
                     kind: MarkupKind.Markdown,
-                    value: `**AWS service principal**\n\n\`${location.value}\` — allows the \`${serviceName}\` service to assume this role or access this resource.`,
+                    value: formatPrincipalTypedValueDocumentation(principalTypedValues.Service),
                 },
             };
         }
@@ -30,7 +30,7 @@ export function handlePrincipalTypedValueHover(location) {
                 range: location.range,
                 contents: {
                     kind: MarkupKind.Markdown,
-                    value: `**AWS account**\n\nGrants access to the root user and all IAM identities in account \`${location.value}\`.`,
+                    value: formatPrincipalTypedValueDocumentation(principalTypedValues.Account),
                 },
             };
         }
@@ -42,7 +42,7 @@ export function handlePrincipalTypedValueHover(location) {
                     range: location.range,
                     contents: {
                         kind: MarkupKind.Markdown,
-                        value: `**AWS account root user**\n\nGrants access to the root user of this account. Equivalent to specifying the account ID.`,
+                        value: formatPrincipalTypedValueDocumentation(principalTypedValues.Account),
                     },
                 };
             }
@@ -51,7 +51,7 @@ export function handlePrincipalTypedValueHover(location) {
                     range: location.range,
                     contents: {
                         kind: MarkupKind.Markdown,
-                        value: `**IAM role**\n\n\`${resource}\`\n\nAny identity that assumes this role will have the permissions granted by this statement.`,
+                        value: formatPrincipalTypedValueDocumentation(principalTypedValues.Role),
                     },
                 };
             }
@@ -60,7 +60,7 @@ export function handlePrincipalTypedValueHover(location) {
                     range: location.range,
                     contents: {
                         kind: MarkupKind.Markdown,
-                        value: `**IAM user**\n\n\`${resource}\``,
+                        value: formatPrincipalTypedValueDocumentation(principalTypedValues.User),
                     },
                 };
             }
@@ -69,7 +69,7 @@ export function handlePrincipalTypedValueHover(location) {
                     range: location.range,
                     contents: {
                         kind: MarkupKind.Markdown,
-                        value: `**Assumed role session**\n\n\`${resource}\``,
+                        value: formatPrincipalTypedValueDocumentation(principalTypedValues.RoleSession),
                     },
                 };
             }
@@ -83,7 +83,7 @@ export function handlePrincipalTypedValueHover(location) {
                     range: location.range,
                     contents: {
                         kind: MarkupKind.Markdown,
-                        value: `**OIDC identity provider**\n\n\`${resource}\``,
+                        value: formatPrincipalTypedValueDocumentation(principalTypedValues.FederatedOidc),
                     },
                 };
             }
@@ -92,27 +92,18 @@ export function handlePrincipalTypedValueHover(location) {
                     range: location.range,
                     contents: {
                         kind: MarkupKind.Markdown,
-                        value: `**SAML identity provider**\n\n\`${resource}\``,
+                        value: formatPrincipalTypedValueDocumentation(principalTypedValues.FederatedSaml),
                     },
                 };
             }
         }
-        const knownProviders = {
-            'cognito-identity.amazonaws.com': 'Amazon Cognito identity pool',
-            'www.amazon.com': 'Login with Amazon',
-            'accounts.google.com': 'Google',
-            'graph.facebook.com': 'Facebook',
+        return {
+            range: location.range,
+            contents: {
+                kind: MarkupKind.Markdown,
+                value: formatPrincipalTypedValueDocumentation(principalTypedValues.FederatedIdentity),
+            },
         };
-        const description = knownProviders[location.value];
-        if (description) {
-            return {
-                range: location.range,
-                contents: {
-                    kind: MarkupKind.Markdown,
-                    value: `**Federated identity provider**\n\n${description}`,
-                },
-            };
-        }
     }
     return null;
 }

package/src/handlers/hover/resource-value.js

@@ -1,5 +1,6 @@
 import { MarkupKind } from 'vscode-languageserver';
 import { parseArn } from "../../lib/iam-policy/arn.js";
+import { formatResourceDocumentation } from "../../lib/iam-policy/reference/documentation.js";
 import { ServiceReference } from "../../lib/iam-policy/reference/services.js";
 export function handleResourceValueHover(location) {
     if (location.value === '*') {
@@ -17,29 +18,15 @@ export function handleResourceValueHover(location) {
     const resources = ServiceReference.getResources(parsed);
     if (resources.length === 0)
         return null;
-    const lines = [];
-    for (let i = 0; i < resources.length; i++) {
-        lines.push(`**${parsed.service} ${resources[i].name}**`);
-        if (resources[i].arnFormats.length > 0) {
-            lines.push('\n**ARNs**');
-            for (const format of resources[i].arnFormats) {
-                lines.push(`- \`${format}\``);
-            }
-        }
-        if (resources[i].conditionKeys.length > 0) {
-            lines.push('\n**Condition keys**');
-            for (const key of resources[i].conditionKeys) {
-                lines.push(`- \`${key}\``);
-            }
-        }
-        if (i + 1 !== resources.length)
-            lines.push('\n---\n');
+    const docs = [];
+    for (const resource of resources) {
+        docs.push(formatResourceDocumentation(resource));
     }
     return {
         range: location.range,
         contents: {
             kind: MarkupKind.Markdown,
-            value: lines.join('\n'),
+            value: docs.join('\n---\n'),
         },
     };
 }

package/src/handlers/hover/statement-key.js

@@ -1,4 +1,5 @@
 import { MarkupKind } from 'vscode-languageserver';
+import { formatStatementElementDocumentation } from "../../lib/iam-policy/reference/documentation.js";
 import { StatementKeys } from "../../lib/iam-policy/statement-keys.js";
 export function handleStatementKeyHover(_connection, location) {
     const statementKey = StatementKeys[location.value];
@@ -8,7 +9,7 @@ export function handleStatementKeyHover(_connection, location) {
         range: location.range,
         contents: {
             kind: MarkupKind.Markdown,
-            value: statementKey.description,
+            value: formatStatementElementDocumentation(statementKey),
         },
     };
 }

package/src/lib/iam-policy/arn.js

@@ -32,7 +32,6 @@ function tokensMatch(a, b) {
         return true;
     if (a.includes('?') || b.includes('?'))
         return true;
-    // Placeholders expect a value — don't match empty strings
     if (a !== '' && b !== '' && (placeholderPattern.test(a) || placeholderPattern.test(b)))
         return true;
     return false;

package/src/lib/iam-policy/condition-operators.d.ts

@@ -1,317 +1,5 @@
-export declare const conditionOperators: {
-    readonly StringEquals: {
-        readonly description: "Exact matching, case sensitive";
-    };
-    readonly StringEqualsIfExists: {
-        readonly description: "Exact matching, case sensitive; true if key is absent";
-    };
-    readonly 'ForAllValues:StringEquals': {
-        readonly description: "All values must match at least one policy value (case sensitive)";
-    };
-    readonly 'ForAnyValue:StringEquals': {
-        readonly description: "At least one value must match a policy value (case sensitive)";
-    };
-    readonly StringNotEquals: {
-        readonly description: "Negated matching, case sensitive";
-    };
-    readonly StringNotEqualsIfExists: {
-        readonly description: "Negated matching, case sensitive; true if key is absent";
-    };
-    readonly 'ForAllValues:StringNotEquals': {
-        readonly description: "None of the values can match any policy value (case sensitive)";
-    };
-    readonly 'ForAnyValue:StringNotEquals': {
-        readonly description: "At least one value must not match any policy value (case sensitive)";
-    };
-    readonly StringEqualsIgnoreCase: {
-        readonly description: "Exact matching, ignoring case";
-    };
-    readonly StringEqualsIgnoreCaseIfExists: {
-        readonly description: "Exact matching, ignoring case; true if key is absent";
-    };
-    readonly 'ForAllValues:StringEqualsIgnoreCase': {
-        readonly description: "All values must match at least one policy value (case insensitive)";
-    };
-    readonly 'ForAnyValue:StringEqualsIgnoreCase': {
-        readonly description: "At least one value must match a policy value (case insensitive)";
-    };
-    readonly StringNotEqualsIgnoreCase: {
-        readonly description: "Negated matching, ignoring case";
-    };
-    readonly StringNotEqualsIgnoreCaseIfExists: {
-        readonly description: "Negated matching, ignoring case; true if key is absent";
-    };
-    readonly 'ForAllValues:StringNotEqualsIgnoreCase': {
-        readonly description: "None of the values can match any policy value (case insensitive)";
-    };
-    readonly 'ForAnyValue:StringNotEqualsIgnoreCase': {
-        readonly description: "At least one value must not match any policy value (case insensitive)";
-    };
-    readonly StringLike: {
-        readonly description: "Case-sensitive matching with wildcard support (* and ?)";
-    };
-    readonly StringLikeIfExists: {
-        readonly description: "Wildcard matching; true if key is absent";
-    };
-    readonly 'ForAllValues:StringLike': {
-        readonly description: "All values must match at least one policy value pattern";
-    };
-    readonly 'ForAnyValue:StringLike': {
-        readonly description: "At least one value must match a policy value pattern";
-    };
-    readonly StringNotLike: {
-        readonly description: "Negated case-sensitive matching with wildcard support";
-    };
-    readonly StringNotLikeIfExists: {
-        readonly description: "Negated wildcard matching; true if key is absent";
-    };
-    readonly 'ForAllValues:StringNotLike': {
-        readonly description: "None of the values can match any policy value pattern";
-    };
-    readonly 'ForAnyValue:StringNotLike': {
-        readonly description: "At least one value must not match any policy value pattern";
-    };
-    readonly NumericEquals: {
-        readonly description: "Exact numeric matching";
-    };
-    readonly NumericEqualsIfExists: {
-        readonly description: "Exact numeric matching; true if key is absent";
-    };
-    readonly 'ForAllValues:NumericEquals': {
-        readonly description: "All values must match at least one policy numeric value";
-    };
-    readonly 'ForAnyValue:NumericEquals': {
-        readonly description: "At least one value must match a policy numeric value";
-    };
-    readonly NumericNotEquals: {
-        readonly description: "Negated numeric matching";
-    };
-    readonly NumericNotEqualsIfExists: {
-        readonly description: "Negated numeric matching; true if key is absent";
-    };
-    readonly 'ForAllValues:NumericNotEquals': {
-        readonly description: "None of the values can match any policy numeric value";
-    };
-    readonly 'ForAnyValue:NumericNotEquals': {
-        readonly description: "At least one value must not match any policy numeric value";
-    };
-    readonly NumericLessThan: {
-        readonly description: "Less than matching";
-    };
-    readonly NumericLessThanIfExists: {
-        readonly description: "Less than matching; true if key is absent";
-    };
-    readonly 'ForAllValues:NumericLessThan': {
-        readonly description: "All values must be less than the policy value";
-    };
-    readonly 'ForAnyValue:NumericLessThan': {
-        readonly description: "At least one value must be less than the policy value";
-    };
-    readonly NumericLessThanEquals: {
-        readonly description: "Less than or equals matching";
-    };
-    readonly NumericLessThanEqualsIfExists: {
-        readonly description: "Less than or equals matching; true if key is absent";
-    };
-    readonly 'ForAllValues:NumericLessThanEquals': {
-        readonly description: "All values must be less than or equal to the policy value";
-    };
-    readonly 'ForAnyValue:NumericLessThanEquals': {
-        readonly description: "At least one value must be less than or equal to the policy value";
-    };
-    readonly NumericGreaterThan: {
-        readonly description: "Greater than matching";
-    };
-    readonly NumericGreaterThanIfExists: {
-        readonly description: "Greater than matching; true if key is absent";
-    };
-    readonly 'ForAllValues:NumericGreaterThan': {
-        readonly description: "All values must be greater than the policy value";
-    };
-    readonly 'ForAnyValue:NumericGreaterThan': {
-        readonly description: "At least one value must be greater than the policy value";
-    };
-    readonly NumericGreaterThanEquals: {
-        readonly description: "Greater than or equals matching";
-    };
-    readonly NumericGreaterThanEqualsIfExists: {
-        readonly description: "Greater than or equals matching; true if key is absent";
-    };
-    readonly 'ForAllValues:NumericGreaterThanEquals': {
-        readonly description: "All values must be greater than or equal to the policy value";
-    };
-    readonly 'ForAnyValue:NumericGreaterThanEquals': {
-        readonly description: "At least one value must be greater than or equal to the policy value";
-    };
-    readonly DateEquals: {
-        readonly description: "Matching a specific date";
-    };
-    readonly DateEqualsIfExists: {
-        readonly description: "Date matching; true if key is absent";
-    };
-    readonly 'ForAllValues:DateEquals': {
-        readonly description: "All values must match a policy date value";
-    };
-    readonly 'ForAnyValue:DateEquals': {
-        readonly description: "At least one value must match a policy date value";
-    };
-    readonly DateNotEquals: {
-        readonly description: "Negated date matching";
-    };
-    readonly DateNotEqualsIfExists: {
-        readonly description: "Negated date matching; true if key is absent";
-    };
-    readonly 'ForAllValues:DateNotEquals': {
-        readonly description: "None of the values can match any policy date value";
-    };
-    readonly 'ForAnyValue:DateNotEquals': {
-        readonly description: "At least one value must not match any policy date value";
-    };
-    readonly DateLessThan: {
-        readonly description: "Matching before a specific date and time";
-    };
-    readonly DateLessThanIfExists: {
-        readonly description: "Before date matching; true if key is absent";
-    };
-    readonly 'ForAllValues:DateLessThan': {
-        readonly description: "All values must be before the policy date";
-    };
-    readonly 'ForAnyValue:DateLessThan': {
-        readonly description: "At least one value must be before the policy date";
-    };
-    readonly DateLessThanEquals: {
-        readonly description: "Matching at or before a specific date and time";
-    };
-    readonly DateLessThanEqualsIfExists: {
-        readonly description: "At or before date matching; true if key is absent";
-    };
-    readonly 'ForAllValues:DateLessThanEquals': {
-        readonly description: "All values must be at or before the policy date";
-    };
-    readonly 'ForAnyValue:DateLessThanEquals': {
-        readonly description: "At least one value must be at or before the policy date";
-    };
-    readonly DateGreaterThan: {
-        readonly description: "Matching after a specific date and time";
-    };
-    readonly DateGreaterThanIfExists: {
-        readonly description: "After date matching; true if key is absent";
-    };
-    readonly 'ForAllValues:DateGreaterThan': {
-        readonly description: "All values must be after the policy date";
-    };
-    readonly 'ForAnyValue:DateGreaterThan': {
-        readonly description: "At least one value must be after the policy date";
-    };
-    readonly DateGreaterThanEquals: {
-        readonly description: "Matching at or after a specific date and time";
-    };
-    readonly DateGreaterThanEqualsIfExists: {
-        readonly description: "At or after date matching; true if key is absent";
-    };
-    readonly 'ForAllValues:DateGreaterThanEquals': {
-        readonly description: "All values must be at or after the policy date";
-    };
-    readonly 'ForAnyValue:DateGreaterThanEquals': {
-        readonly description: "At least one value must be at or after the policy date";
-    };
-    readonly Bool: {
-        readonly description: "Boolean matching (true or false)";
-    };
-    readonly BoolIfExists: {
-        readonly description: "Boolean matching; true if key is absent";
-    };
-    readonly 'ForAllValues:Bool': {
-        readonly description: "All values must match the policy boolean";
-    };
-    readonly 'ForAnyValue:Bool': {
-        readonly description: "At least one value must match the policy boolean";
-    };
-    readonly BinaryEquals: {
-        readonly description: "Byte-for-byte comparison of base-64 encoded binary values";
-    };
-    readonly BinaryEqualsIfExists: {
-        readonly description: "Binary value matching; true if key is absent";
-    };
-    readonly 'ForAllValues:BinaryEquals': {
-        readonly description: "All values must match a policy binary value";
-    };
-    readonly 'ForAnyValue:BinaryEquals': {
-        readonly description: "At least one value must match a policy binary value";
-    };
-    readonly IpAddress: {
-        readonly description: "Matching a specific IP address or CIDR range";
-    };
-    readonly IpAddressIfExists: {
-        readonly description: "IP address matching; true if key is absent";
-    };
-    readonly 'ForAllValues:IpAddress': {
-        readonly description: "All values must match a policy IP address or CIDR range";
-    };
-    readonly 'ForAnyValue:IpAddress': {
-        readonly description: "At least one value must match a policy IP address or CIDR range";
-    };
-    readonly NotIpAddress: {
-        readonly description: "All IP addresses except the specified IP address or CIDR range";
-    };
-    readonly NotIpAddressIfExists: {
-        readonly description: "Negated IP address matching; true if key is absent";
-    };
-    readonly 'ForAllValues:NotIpAddress': {
-        readonly description: "All values must not match any policy IP address or CIDR range";
-    };
-    readonly 'ForAnyValue:NotIpAddress': {
-        readonly description: "At least one value must not match any policy IP address or CIDR range";
-    };
-    readonly ArnEquals: {
-        readonly description: "Case-sensitive ARN matching";
-    };
-    readonly ArnEqualsIfExists: {
-        readonly description: "ARN matching; true if key is absent";
-    };
-    readonly 'ForAllValues:ArnEquals': {
-        readonly description: "All values must match at least one policy ARN";
-    };
-    readonly 'ForAnyValue:ArnEquals': {
-        readonly description: "At least one value must match a policy ARN";
-    };
-    readonly ArnLike: {
-        readonly description: "Case-sensitive ARN matching with wildcard support (* and ?)";
-    };
-    readonly ArnLikeIfExists: {
-        readonly description: "ARN wildcard matching; true if key is absent";
-    };
-    readonly 'ForAllValues:ArnLike': {
-        readonly description: "All values must match at least one policy ARN pattern";
-    };
-    readonly 'ForAnyValue:ArnLike': {
-        readonly description: "At least one value must match a policy ARN pattern";
-    };
-    readonly ArnNotEquals: {
-        readonly description: "Negated case-sensitive ARN matching";
-    };
-    readonly ArnNotEqualsIfExists: {
-        readonly description: "Negated ARN matching; true if key is absent";
-    };
-    readonly 'ForAllValues:ArnNotEquals': {
-        readonly description: "None of the values can match any policy ARN";
-    };
-    readonly 'ForAnyValue:ArnNotEquals': {
-        readonly description: "At least one value must not match any policy ARN";
-    };
-    readonly ArnNotLike: {
-        readonly description: "Negated case-sensitive ARN matching with wildcard support";
-    };
-    readonly ArnNotLikeIfExists: {
-        readonly description: "Negated ARN wildcard matching; true if key is absent";
-    };
-    readonly 'ForAllValues:ArnNotLike': {
-        readonly description: "None of the values can match any policy ARN pattern";
-    };
-    readonly 'ForAnyValue:ArnNotLike': {
-        readonly description: "At least one value must not match any policy ARN pattern";
-    };
-    readonly Null: {
-        readonly description: "Checks whether a condition key is present (true if absent, false if present)";
-    };
+export type ConditionOperator = {
+    name: string;
+    description: string;
 };
+export declare const conditionOperators: Record<string, ConditionOperator>;