fakecloud-iot 0.41.0

// @generated by scripts/generate-iot-tables.py (do not edit by hand)
// AWS IoT Core (iot) operation metadata derived from the Smithy model.
#![allow(clippy::all)]

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Seg {
    Fixed(&'static str),
    Label(&'static str),
    Greedy(&'static str),
}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum K {
    Str,
    Int,
    Num,
    Bool,
    Blob,
    Ts,
    List,
    Map,
    Struct,
}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Src {
    Label,
    Query,
    Header,
    Body,
}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Verb {
    Create,
    Get,
    List,
    Update,
    Delete,
    Action,
}

pub struct Rule {
    pub wire: &'static str,
    pub src: Src,
    pub req: bool,
    pub kind: K,
    pub min_len: Option<u64>,
    pub max_len: Option<u64>,
    pub min_val: Option<i64>,
    pub max_val: Option<i64>,
    pub enums: &'static [&'static str],
}

pub struct OpMeta {
    pub op: &'static str,
    pub method: &'static str,
    pub segs: &'static [Seg],
    pub verb: Verb,
    pub rtype: &'static str,
    pub nlabels: usize,
    pub has_input: bool,
    pub errors: &'static [&'static str],
    pub rules: &'static [Rule],
    pub omembers: &'static [(&'static str, K)],
    pub list_field: Option<&'static str>,
    pub list_elems: &'static [(&'static str, K)],
    pub list_scalar: bool,
    pub req_payload: bool,
}

pub static OPS: &[OpMeta] = &[
    OpMeta {
        op: "AcceptCertificateTransfer",
        method: "PATCH",
        segs: &[
            Seg::Fixed("accept-certificate-transfer"),
            Seg::Label("certificateId"),
        ],
        verb: Verb::Action,
        rtype: "accept-certificate-transfer",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "TransferAlreadyCompletedException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "certificateId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(64),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AddThingToBillingGroup",
        method: "PUT",
        segs: &[
            Seg::Fixed("billing-groups"),
            Seg::Fixed("addThingToBillingGroup"),
        ],
        verb: Verb::Action,
        rtype: "billing-groups",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "billingGroupName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AddThingToThingGroup",
        method: "PUT",
        segs: &[
            Seg::Fixed("thing-groups"),
            Seg::Fixed("addThingToThingGroup"),
        ],
        verb: Verb::Action,
        rtype: "thing-groups",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "thingGroupName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AssociateSbomWithPackageVersion",
        method: "PUT",
        segs: &[
            Seg::Fixed("packages"),
            Seg::Label("packageName"),
            Seg::Fixed("versions"),
            Seg::Label("versionName"),
            Seg::Fixed("sbom"),
        ],
        verb: Verb::Action,
        rtype: "packages",
        nlabels: 2,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ServiceQuotaExceededException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "packageName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "versionName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "sbom",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(36),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("packageName", K::Str),
            ("versionName", K::Str),
            ("sbom", K::Struct),
            ("sbomValidationStatus", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AssociateTargetsWithJob",
        method: "POST",
        segs: &[
            Seg::Fixed("jobs"),
            Seg::Label("jobId"),
            Seg::Fixed("targets"),
        ],
        verb: Verb::Action,
        rtype: "jobs",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "targets",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "jobId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "comment",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2028),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("jobArn", K::Str),
            ("jobId", K::Str),
            ("description", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AttachPolicy",
        method: "PUT",
        segs: &[Seg::Fixed("target-policies"), Seg::Label("policyName")],
        verb: Verb::Action,
        rtype: "target-policies",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "policyName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "target",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AttachPrincipalPolicy",
        method: "PUT",
        segs: &[Seg::Fixed("principal-policies"), Seg::Label("policyName")],
        verb: Verb::Action,
        rtype: "principal-policies",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "policyName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "x-amzn-iot-principal",
                src: Src::Header,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AttachSecurityProfile",
        method: "PUT",
        segs: &[
            Seg::Fixed("security-profiles"),
            Seg::Label("securityProfileName"),
            Seg::Fixed("targets"),
        ],
        verb: Verb::Action,
        rtype: "security-profiles",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "VersionConflictException",
        ],
        rules: &[
            Rule {
                wire: "securityProfileName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "securityProfileTargetArn",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AttachThingPrincipal",
        method: "PUT",
        segs: &[
            Seg::Fixed("things"),
            Seg::Label("thingName"),
            Seg::Fixed("principals"),
        ],
        verb: Verb::Action,
        rtype: "things",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "thingName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "x-amzn-principal",
                src: Src::Header,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingPrincipalType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["EXCLUSIVE_THING", "NON_EXCLUSIVE_THING"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CancelAuditMitigationActionsTask",
        method: "PUT",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("tasks"),
            Seg::Label("taskId"),
            Seg::Fixed("cancel"),
        ],
        verb: Verb::Action,
        rtype: "audit",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "taskId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CancelAuditTask",
        method: "PUT",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("tasks"),
            Seg::Label("taskId"),
            Seg::Fixed("cancel"),
        ],
        verb: Verb::Action,
        rtype: "audit",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "taskId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(40),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CancelCertificateTransfer",
        method: "PATCH",
        segs: &[
            Seg::Fixed("cancel-certificate-transfer"),
            Seg::Label("certificateId"),
        ],
        verb: Verb::Action,
        rtype: "cancel-certificate-transfer",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "TransferAlreadyCompletedException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "certificateId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(64),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CancelDetectMitigationActionsTask",
        method: "PUT",
        segs: &[
            Seg::Fixed("detect"),
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("tasks"),
            Seg::Label("taskId"),
            Seg::Fixed("cancel"),
        ],
        verb: Verb::Action,
        rtype: "detect",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "taskId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CancelJob",
        method: "PUT",
        segs: &[
            Seg::Fixed("jobs"),
            Seg::Label("jobId"),
            Seg::Fixed("cancel"),
        ],
        verb: Verb::Action,
        rtype: "jobs",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "jobId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "reasonCode",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "comment",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2028),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("jobArn", K::Str),
            ("jobId", K::Str),
            ("description", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CancelJobExecution",
        method: "PUT",
        segs: &[
            Seg::Fixed("things"),
            Seg::Label("thingName"),
            Seg::Fixed("jobs"),
            Seg::Label("jobId"),
            Seg::Fixed("cancel"),
        ],
        verb: Verb::Action,
        rtype: "things",
        nlabels: 2,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "InvalidStateTransitionException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "VersionConflictException",
        ],
        rules: &[
            Rule {
                wire: "jobId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ClearDefaultAuthorizer",
        method: "DELETE",
        segs: &[Seg::Fixed("default-authorizer")],
        verb: Verb::Action,
        rtype: "default-authorizer",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ConfirmTopicRuleDestination",
        method: "GET",
        segs: &[
            Seg::Fixed("confirmdestination"),
            Seg::Greedy("confirmationToken"),
        ],
        verb: Verb::Action,
        rtype: "confirmdestination",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "confirmationToken",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(2048),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateAuditSuppression",
        method: "POST",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("suppressions"),
            Seg::Fixed("create"),
        ],
        verb: Verb::Action,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "checkName",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceIdentifier",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1000),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientRequestToken",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateAuthorizer",
        method: "POST",
        segs: &[Seg::Fixed("authorizer"), Seg::Label("authorizerName")],
        verb: Verb::Create,
        rtype: "authorizer",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "authorizerName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "authorizerFunctionArn",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "tokenKeyName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "status",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["ACTIVE", "INACTIVE"],
            },
        ],
        omembers: &[("authorizerName", K::Str), ("authorizerArn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateBillingGroup",
        method: "POST",
        segs: &[Seg::Fixed("billing-groups"), Seg::Label("billingGroupName")],
        verb: Verb::Create,
        rtype: "billing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceAlreadyExistsException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "billingGroupName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("billingGroupName", K::Str),
            ("billingGroupArn", K::Str),
            ("billingGroupId", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateCertificateFromCsr",
        method: "POST",
        segs: &[Seg::Fixed("certificates")],
        verb: Verb::Action,
        rtype: "certificates",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "certificateSigningRequest",
            src: Src::Body,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(4096),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("certificateArn", K::Str),
            ("certificateId", K::Str),
            ("certificatePem", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateCertificateProvider",
        method: "POST",
        segs: &[
            Seg::Fixed("certificate-providers"),
            Seg::Label("certificateProviderName"),
        ],
        verb: Verb::Create,
        rtype: "certificate-providers",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "certificateProviderName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "lambdaFunctionArn",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "accountDefaultForOperations",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: Some(1),
                max_len: Some(1),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientToken",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(36),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("certificateProviderName", K::Str),
            ("certificateProviderArn", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateCommand",
        method: "PUT",
        segs: &[Seg::Fixed("commands"), Seg::Label("commandId")],
        verb: Verb::Create,
        rtype: "commands",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ServiceQuotaExceededException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "commandId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "namespace",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["AWS-IoT", "AWS-IoT-FleetWise"],
            },
            Rule {
                wire: "displayName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2028),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "payloadTemplate",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(32768),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "mandatoryParameters",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "roleArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(20),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("commandId", K::Str), ("commandArn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateCustomMetric",
        method: "POST",
        segs: &[Seg::Fixed("custom-metric"), Seg::Label("metricName")],
        verb: Verb::Create,
        rtype: "custom-metric",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "metricName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "displayName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "metricType",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["string-list", "ip-address-list", "number-list", "number"],
            },
            Rule {
                wire: "clientRequestToken",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("metricName", K::Str), ("metricArn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateDimension",
        method: "POST",
        segs: &[Seg::Fixed("dimensions"), Seg::Label("name")],
        verb: Verb::Create,
        rtype: "dimensions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "name",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "type",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["TOPIC_FILTER"],
            },
            Rule {
                wire: "stringValues",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: Some(1),
                max_len: Some(100),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientRequestToken",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("name", K::Str), ("arn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateDomainConfiguration",
        method: "POST",
        segs: &[
            Seg::Fixed("domainConfigurations"),
            Seg::Label("domainConfigurationName"),
        ],
        verb: Verb::Create,
        rtype: "domainConfigurations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "CertificateValidationException",
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "domainConfigurationName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "domainName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(253),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "serverCertificateArns",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(1),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "validationCertificateArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "serviceType",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["DATA", "CREDENTIAL_PROVIDER", "JOBS"],
            },
            Rule {
                wire: "authenticationType",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "CUSTOM_AUTH_X509",
                    "CUSTOM_AUTH",
                    "AWS_X509",
                    "AWS_SIGV4",
                    "DEFAULT",
                ],
            },
            Rule {
                wire: "applicationProtocol",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["SECURE_MQTT", "MQTT_WSS", "HTTPS", "DEFAULT"],
            },
        ],
        omembers: &[
            ("domainConfigurationName", K::Str),
            ("domainConfigurationArn", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateDynamicThingGroup",
        method: "POST",
        segs: &[
            Seg::Fixed("dynamic-thing-groups"),
            Seg::Label("thingGroupName"),
        ],
        verb: Verb::Create,
        rtype: "dynamic-thing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidQueryException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "thingGroupName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "indexName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "queryString",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("thingGroupName", K::Str),
            ("thingGroupArn", K::Str),
            ("thingGroupId", K::Str),
            ("indexName", K::Str),
            ("queryString", K::Str),
            ("queryVersion", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateFleetMetric",
        method: "PUT",
        segs: &[Seg::Fixed("fleet-metric"), Seg::Label("metricName")],
        verb: Verb::Create,
        rtype: "fleet-metric",
        nlabels: 1,
        has_input: true,
        errors: &[
            "IndexNotReadyException",
            "InternalFailureException",
            "InvalidAggregationException",
            "InvalidQueryException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "metricName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "queryString",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "aggregationType",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "period",
                src: Src::Body,
                req: true,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(60),
                max_val: Some(86400),
                enums: &[],
            },
            Rule {
                wire: "aggregationField",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "indexName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "unit",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "Seconds",
                    "Microseconds",
                    "Milliseconds",
                    "Bytes",
                    "Kilobytes",
                    "Megabytes",
                    "Gigabytes",
                    "Terabytes",
                    "Bits",
                    "Kilobits",
                    "Megabits",
                    "Gigabits",
                    "Terabits",
                    "Percent",
                    "Count",
                    "Bytes/Second",
                    "Kilobytes/Second",
                    "Megabytes/Second",
                    "Gigabytes/Second",
                    "Terabytes/Second",
                    "Bits/Second",
                    "Kilobits/Second",
                    "Megabits/Second",
                    "Gigabits/Second",
                    "Terabits/Second",
                    "Count/Second",
                    "None",
                ],
            },
        ],
        omembers: &[("metricName", K::Str), ("metricArn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateJob",
        method: "PUT",
        segs: &[Seg::Fixed("jobs"), Seg::Label("jobId")],
        verb: Verb::Create,
        rtype: "jobs",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "jobId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "targets",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "documentSource",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(1350),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "document",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(32768),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2028),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "targetSelection",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["CONTINUOUS", "SNAPSHOT"],
            },
            Rule {
                wire: "jobTemplateArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(1600),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("jobArn", K::Str),
            ("jobId", K::Str),
            ("description", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateJobTemplate",
        method: "PUT",
        segs: &[Seg::Fixed("job-templates"), Seg::Label("jobTemplateId")],
        verb: Verb::Create,
        rtype: "job-templates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "jobTemplateId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "documentSource",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(1350),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "document",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(32768),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2028),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("jobTemplateArn", K::Str), ("jobTemplateId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateKeysAndCertificate",
        method: "POST",
        segs: &[Seg::Fixed("keys-and-certificate")],
        verb: Verb::Action,
        rtype: "keys-and-certificate",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[],
        omembers: &[
            ("certificateArn", K::Str),
            ("certificateId", K::Str),
            ("certificatePem", K::Str),
            ("keyPair", K::Struct),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateMitigationAction",
        method: "POST",
        segs: &[
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("actions"),
            Seg::Label("actionName"),
        ],
        verb: Verb::Create,
        rtype: "mitigationactions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "actionName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "roleArn",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(20),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "actionParams",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("actionArn", K::Str), ("actionId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateOTAUpdate",
        method: "POST",
        segs: &[Seg::Fixed("otaUpdates"), Seg::Label("otaUpdateId")],
        verb: Verb::Create,
        rtype: "otaUpdates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "otaUpdateId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2028),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "targets",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "protocols",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(1),
                max_len: Some(2),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "targetSelection",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["CONTINUOUS", "SNAPSHOT"],
            },
            Rule {
                wire: "files",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "roleArn",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(20),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("otaUpdateId", K::Str),
            ("awsIotJobId", K::Str),
            ("otaUpdateArn", K::Str),
            ("awsIotJobArn", K::Str),
            ("otaUpdateStatus", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreatePackage",
        method: "PUT",
        segs: &[Seg::Fixed("packages"), Seg::Label("packageName")],
        verb: Verb::Create,
        rtype: "packages",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ServiceQuotaExceededException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "packageName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "tags",
                src: Src::Body,
                req: false,
                kind: K::Map,
                min_len: Some(1),
                max_len: Some(50),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(36),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("packageName", K::Str),
            ("packageArn", K::Str),
            ("description", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreatePackageVersion",
        method: "PUT",
        segs: &[
            Seg::Fixed("packages"),
            Seg::Label("packageName"),
            Seg::Fixed("versions"),
            Seg::Label("versionName"),
        ],
        verb: Verb::Create,
        rtype: "packages",
        nlabels: 2,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ServiceQuotaExceededException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "packageName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "versionName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "recipe",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(3072),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "tags",
                src: Src::Body,
                req: false,
                kind: K::Map,
                min_len: Some(1),
                max_len: Some(50),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(36),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("packageVersionArn", K::Str),
            ("packageName", K::Str),
            ("versionName", K::Str),
            ("description", K::Str),
            ("attributes", K::Map),
            ("status", K::Str),
            ("errorReason", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreatePolicy",
        method: "POST",
        segs: &[Seg::Fixed("policies"), Seg::Label("policyName")],
        verb: Verb::Create,
        rtype: "policies",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "MalformedPolicyException",
            "ResourceAlreadyExistsException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "policyName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "policyDocument",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(404600),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("policyName", K::Str),
            ("policyArn", K::Str),
            ("policyDocument", K::Str),
            ("policyVersionId", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreatePolicyVersion",
        method: "POST",
        segs: &[
            Seg::Fixed("policies"),
            Seg::Label("policyName"),
            Seg::Fixed("version"),
        ],
        verb: Verb::Action,
        rtype: "policies",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "MalformedPolicyException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
            "VersionsLimitExceededException",
        ],
        rules: &[
            Rule {
                wire: "policyName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "policyDocument",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(404600),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("policyArn", K::Str),
            ("policyDocument", K::Str),
            ("policyVersionId", K::Str),
            ("isDefaultVersion", K::Bool),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateProvisioningClaim",
        method: "POST",
        segs: &[
            Seg::Fixed("provisioning-templates"),
            Seg::Label("templateName"),
            Seg::Fixed("provisioning-claim"),
        ],
        verb: Verb::Action,
        rtype: "provisioning-templates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "templateName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(36),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("certificateId", K::Str),
            ("certificatePem", K::Str),
            ("keyPair", K::Struct),
            ("expiration", K::Ts),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateProvisioningTemplate",
        method: "POST",
        segs: &[Seg::Fixed("provisioning-templates")],
        verb: Verb::Action,
        rtype: "provisioning-templates",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "templateName",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(36),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(500),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "templateBody",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(10240),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "provisioningRoleArn",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(20),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "type",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["FLEET_PROVISIONING", "JITP"],
            },
        ],
        omembers: &[
            ("templateArn", K::Str),
            ("templateName", K::Str),
            ("defaultVersionId", K::Int),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateProvisioningTemplateVersion",
        method: "POST",
        segs: &[
            Seg::Fixed("provisioning-templates"),
            Seg::Label("templateName"),
            Seg::Fixed("versions"),
        ],
        verb: Verb::Action,
        rtype: "provisioning-templates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "UnauthorizedException",
            "VersionsLimitExceededException",
        ],
        rules: &[
            Rule {
                wire: "templateName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(36),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "templateBody",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(10240),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("templateArn", K::Str),
            ("templateName", K::Str),
            ("versionId", K::Int),
            ("isDefaultVersion", K::Bool),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateRoleAlias",
        method: "POST",
        segs: &[Seg::Fixed("role-aliases"), Seg::Label("roleAlias")],
        verb: Verb::Create,
        rtype: "role-aliases",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "roleAlias",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "roleArn",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(20),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "credentialDurationSeconds",
                src: Src::Body,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(900),
                max_val: Some(43200),
                enums: &[],
            },
        ],
        omembers: &[("roleAlias", K::Str), ("roleAliasArn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateScheduledAudit",
        method: "POST",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("scheduledaudits"),
            Seg::Label("scheduledAuditName"),
        ],
        verb: Verb::Create,
        rtype: "audit",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "frequency",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["DAILY", "WEEKLY", "BIWEEKLY", "MONTHLY"],
            },
            Rule {
                wire: "dayOfWeek",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"],
            },
            Rule {
                wire: "targetCheckNames",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "scheduledAuditName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("scheduledAuditArn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateSecurityProfile",
        method: "POST",
        segs: &[
            Seg::Fixed("security-profiles"),
            Seg::Label("securityProfileName"),
        ],
        verb: Verb::Create,
        rtype: "security-profiles",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceAlreadyExistsException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "securityProfileName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "securityProfileDescription",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1000),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "behaviors",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(100),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("securityProfileName", K::Str),
            ("securityProfileArn", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateStream",
        method: "POST",
        segs: &[Seg::Fixed("streams"), Seg::Label("streamId")],
        verb: Verb::Create,
        rtype: "streams",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceAlreadyExistsException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "streamId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2028),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "files",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: Some(1),
                max_len: Some(50),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "roleArn",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(20),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("streamId", K::Str),
            ("streamArn", K::Str),
            ("description", K::Str),
            ("streamVersion", K::Int),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateThing",
        method: "POST",
        segs: &[Seg::Fixed("things"), Seg::Label("thingName")],
        verb: Verb::Create,
        rtype: "things",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceAlreadyExistsException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "thingName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingTypeName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "billingGroupName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("thingName", K::Str),
            ("thingArn", K::Str),
            ("thingId", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateThingGroup",
        method: "POST",
        segs: &[Seg::Fixed("thing-groups"), Seg::Label("thingGroupName")],
        verb: Verb::Create,
        rtype: "thing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceAlreadyExistsException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "thingGroupName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "parentGroupName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("thingGroupName", K::Str),
            ("thingGroupArn", K::Str),
            ("thingGroupId", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateThingType",
        method: "POST",
        segs: &[Seg::Fixed("thing-types"), Seg::Label("thingTypeName")],
        verb: Verb::Create,
        rtype: "thing-types",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceAlreadyExistsException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "thingTypeName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("thingTypeName", K::Str),
            ("thingTypeArn", K::Str),
            ("thingTypeId", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateTopicRule",
        method: "POST",
        segs: &[Seg::Fixed("rules"), Seg::Label("ruleName")],
        verb: Verb::Create,
        rtype: "rules",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalException",
            "InvalidRequestException",
            "ResourceAlreadyExistsException",
            "ServiceUnavailableException",
            "SqlParseException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "ruleName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: true,
    },
    OpMeta {
        op: "CreateTopicRuleDestination",
        method: "POST",
        segs: &[Seg::Fixed("destinations")],
        verb: Verb::Action,
        rtype: "destinations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalException",
            "InvalidRequestException",
            "ResourceAlreadyExistsException",
            "ServiceUnavailableException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "destinationConfiguration",
            src: Src::Body,
            req: true,
            kind: K::Struct,
            min_len: None,
            max_len: None,
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("topicRuleDestination", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteAccountAuditConfiguration",
        method: "DELETE",
        segs: &[Seg::Fixed("audit"), Seg::Fixed("configuration")],
        verb: Verb::Action,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteAuditSuppression",
        method: "POST",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("suppressions"),
            Seg::Fixed("delete"),
        ],
        verb: Verb::Action,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "checkName",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceIdentifier",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteAuthorizer",
        method: "DELETE",
        segs: &[Seg::Fixed("authorizer"), Seg::Label("authorizerName")],
        verb: Verb::Delete,
        rtype: "authorizer",
        nlabels: 1,
        has_input: true,
        errors: &[
            "DeleteConflictException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "authorizerName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteBillingGroup",
        method: "DELETE",
        segs: &[Seg::Fixed("billing-groups"), Seg::Label("billingGroupName")],
        verb: Verb::Delete,
        rtype: "billing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
            "VersionConflictException",
        ],
        rules: &[Rule {
            wire: "billingGroupName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteCACertificate",
        method: "DELETE",
        segs: &[Seg::Fixed("cacertificate"), Seg::Label("certificateId")],
        verb: Verb::Delete,
        rtype: "cacertificate",
        nlabels: 1,
        has_input: true,
        errors: &[
            "CertificateStateException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "certificateId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(64),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteCertificate",
        method: "DELETE",
        segs: &[Seg::Fixed("certificates"), Seg::Label("certificateId")],
        verb: Verb::Delete,
        rtype: "certificates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "CertificateStateException",
            "DeleteConflictException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "certificateId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(64),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteCertificateProvider",
        method: "DELETE",
        segs: &[
            Seg::Fixed("certificate-providers"),
            Seg::Label("certificateProviderName"),
        ],
        verb: Verb::Delete,
        rtype: "certificate-providers",
        nlabels: 1,
        has_input: true,
        errors: &[
            "DeleteConflictException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "certificateProviderName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteCommand",
        method: "DELETE",
        segs: &[Seg::Fixed("commands"), Seg::Label("commandId")],
        verb: Verb::Delete,
        rtype: "commands",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "commandId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteCommandExecution",
        method: "DELETE",
        segs: &[Seg::Fixed("command-executions"), Seg::Label("executionId")],
        verb: Verb::Delete,
        rtype: "command-executions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "executionId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "targetArn",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteCustomMetric",
        method: "DELETE",
        segs: &[Seg::Fixed("custom-metric"), Seg::Label("metricName")],
        verb: Verb::Delete,
        rtype: "custom-metric",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "metricName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteDimension",
        method: "DELETE",
        segs: &[Seg::Fixed("dimensions"), Seg::Label("name")],
        verb: Verb::Delete,
        rtype: "dimensions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "name",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteDomainConfiguration",
        method: "DELETE",
        segs: &[
            Seg::Fixed("domainConfigurations"),
            Seg::Label("domainConfigurationName"),
        ],
        verb: Verb::Delete,
        rtype: "domainConfigurations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "domainConfigurationName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteDynamicThingGroup",
        method: "DELETE",
        segs: &[
            Seg::Fixed("dynamic-thing-groups"),
            Seg::Label("thingGroupName"),
        ],
        verb: Verb::Delete,
        rtype: "dynamic-thing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
            "VersionConflictException",
        ],
        rules: &[Rule {
            wire: "thingGroupName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteFleetMetric",
        method: "DELETE",
        segs: &[Seg::Fixed("fleet-metric"), Seg::Label("metricName")],
        verb: Verb::Delete,
        rtype: "fleet-metric",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
            "VersionConflictException",
        ],
        rules: &[Rule {
            wire: "metricName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteJob",
        method: "DELETE",
        segs: &[Seg::Fixed("jobs"), Seg::Label("jobId")],
        verb: Verb::Delete,
        rtype: "jobs",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "InvalidStateTransitionException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "jobId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteJobExecution",
        method: "DELETE",
        segs: &[
            Seg::Fixed("things"),
            Seg::Label("thingName"),
            Seg::Fixed("jobs"),
            Seg::Label("jobId"),
            Seg::Fixed("executionNumber"),
            Seg::Label("executionNumber"),
        ],
        verb: Verb::Delete,
        rtype: "things",
        nlabels: 3,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "InvalidStateTransitionException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "jobId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "executionNumber",
                src: Src::Label,
                req: true,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteJobTemplate",
        method: "DELETE",
        segs: &[Seg::Fixed("job-templates"), Seg::Label("jobTemplateId")],
        verb: Verb::Delete,
        rtype: "job-templates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "jobTemplateId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteMitigationAction",
        method: "DELETE",
        segs: &[
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("actions"),
            Seg::Label("actionName"),
        ],
        verb: Verb::Delete,
        rtype: "mitigationactions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "actionName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteOTAUpdate",
        method: "DELETE",
        segs: &[Seg::Fixed("otaUpdates"), Seg::Label("otaUpdateId")],
        verb: Verb::Delete,
        rtype: "otaUpdates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
            "VersionConflictException",
        ],
        rules: &[Rule {
            wire: "otaUpdateId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeletePackage",
        method: "DELETE",
        segs: &[Seg::Fixed("packages"), Seg::Label("packageName")],
        verb: Verb::Delete,
        rtype: "packages",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "packageName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(36),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeletePackageVersion",
        method: "DELETE",
        segs: &[
            Seg::Fixed("packages"),
            Seg::Label("packageName"),
            Seg::Fixed("versions"),
            Seg::Label("versionName"),
        ],
        verb: Verb::Delete,
        rtype: "packages",
        nlabels: 2,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "packageName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "versionName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(36),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeletePolicy",
        method: "DELETE",
        segs: &[Seg::Fixed("policies"), Seg::Label("policyName")],
        verb: Verb::Delete,
        rtype: "policies",
        nlabels: 1,
        has_input: true,
        errors: &[
            "DeleteConflictException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "policyName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeletePolicyVersion",
        method: "DELETE",
        segs: &[
            Seg::Fixed("policies"),
            Seg::Label("policyName"),
            Seg::Fixed("version"),
            Seg::Label("policyVersionId"),
        ],
        verb: Verb::Delete,
        rtype: "policies",
        nlabels: 2,
        has_input: true,
        errors: &[
            "DeleteConflictException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "policyName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "policyVersionId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteProvisioningTemplate",
        method: "DELETE",
        segs: &[
            Seg::Fixed("provisioning-templates"),
            Seg::Label("templateName"),
        ],
        verb: Verb::Delete,
        rtype: "provisioning-templates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "DeleteConflictException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "templateName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(36),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteProvisioningTemplateVersion",
        method: "DELETE",
        segs: &[
            Seg::Fixed("provisioning-templates"),
            Seg::Label("templateName"),
            Seg::Fixed("versions"),
            Seg::Label("versionId"),
        ],
        verb: Verb::Delete,
        rtype: "provisioning-templates",
        nlabels: 2,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "DeleteConflictException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "templateName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(36),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "versionId",
                src: Src::Label,
                req: true,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteRegistrationCode",
        method: "DELETE",
        segs: &[Seg::Fixed("registrationcode")],
        verb: Verb::Action,
        rtype: "registrationcode",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteRoleAlias",
        method: "DELETE",
        segs: &[Seg::Fixed("role-aliases"), Seg::Label("roleAlias")],
        verb: Verb::Delete,
        rtype: "role-aliases",
        nlabels: 1,
        has_input: true,
        errors: &[
            "DeleteConflictException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "roleAlias",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteScheduledAudit",
        method: "DELETE",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("scheduledaudits"),
            Seg::Label("scheduledAuditName"),
        ],
        verb: Verb::Delete,
        rtype: "audit",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "scheduledAuditName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteSecurityProfile",
        method: "DELETE",
        segs: &[
            Seg::Fixed("security-profiles"),
            Seg::Label("securityProfileName"),
        ],
        verb: Verb::Delete,
        rtype: "security-profiles",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
            "VersionConflictException",
        ],
        rules: &[Rule {
            wire: "securityProfileName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteStream",
        method: "DELETE",
        segs: &[Seg::Fixed("streams"), Seg::Label("streamId")],
        verb: Verb::Delete,
        rtype: "streams",
        nlabels: 1,
        has_input: true,
        errors: &[
            "DeleteConflictException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "streamId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteThing",
        method: "DELETE",
        segs: &[Seg::Fixed("things"), Seg::Label("thingName")],
        verb: Verb::Delete,
        rtype: "things",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
            "VersionConflictException",
        ],
        rules: &[Rule {
            wire: "thingName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteThingGroup",
        method: "DELETE",
        segs: &[Seg::Fixed("thing-groups"), Seg::Label("thingGroupName")],
        verb: Verb::Delete,
        rtype: "thing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
            "VersionConflictException",
        ],
        rules: &[Rule {
            wire: "thingGroupName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteThingType",
        method: "DELETE",
        segs: &[Seg::Fixed("thing-types"), Seg::Label("thingTypeName")],
        verb: Verb::Delete,
        rtype: "thing-types",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "thingTypeName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteTopicRule",
        method: "DELETE",
        segs: &[Seg::Fixed("rules"), Seg::Label("ruleName")],
        verb: Verb::Delete,
        rtype: "rules",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "ruleName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteTopicRuleDestination",
        method: "DELETE",
        segs: &[Seg::Fixed("destinations"), Seg::Greedy("arn")],
        verb: Verb::Delete,
        rtype: "destinations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "arn",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: None,
            max_len: None,
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteV2LoggingLevel",
        method: "DELETE",
        segs: &[Seg::Fixed("v2LoggingLevel")],
        verb: Verb::Action,
        rtype: "v2LoggingLevel",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
        ],
        rules: &[
            Rule {
                wire: "targetType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "DEFAULT",
                    "THING_GROUP",
                    "CLIENT_ID",
                    "SOURCE_IP",
                    "PRINCIPAL_ID",
                ],
            },
            Rule {
                wire: "targetName",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeprecateThingType",
        method: "POST",
        segs: &[
            Seg::Fixed("thing-types"),
            Seg::Label("thingTypeName"),
            Seg::Fixed("deprecate"),
        ],
        verb: Verb::Action,
        rtype: "thing-types",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "thingTypeName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeAccountAuditConfiguration",
        method: "GET",
        segs: &[Seg::Fixed("audit"), Seg::Fixed("configuration")],
        verb: Verb::Action,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &["InternalFailureException", "ThrottlingException"],
        rules: &[],
        omembers: &[
            ("roleArn", K::Str),
            ("auditNotificationTargetConfigurations", K::Map),
            ("auditCheckConfigurations", K::Map),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeAuditFinding",
        method: "GET",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("findings"),
            Seg::Label("findingId"),
        ],
        verb: Verb::Get,
        rtype: "audit",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "findingId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("finding", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeAuditMitigationActionsTask",
        method: "GET",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("tasks"),
            Seg::Label("taskId"),
        ],
        verb: Verb::Get,
        rtype: "audit",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "taskId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("taskStatus", K::Str),
            ("startTime", K::Ts),
            ("endTime", K::Ts),
            ("taskStatistics", K::Map),
            ("target", K::Struct),
            ("auditCheckToActionsMapping", K::Map),
            ("actionsDefinition", K::List),
        ],
        list_field: Some("actionsDefinition"),
        list_elems: &[
            ("name", K::Str),
            ("id", K::Str),
            ("roleArn", K::Str),
            ("actionParams", K::Struct),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeAuditSuppression",
        method: "POST",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("suppressions"),
            Seg::Fixed("describe"),
        ],
        verb: Verb::Action,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "checkName",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceIdentifier",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("checkName", K::Str),
            ("resourceIdentifier", K::Struct),
            ("expirationDate", K::Ts),
            ("suppressIndefinitely", K::Bool),
            ("description", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeAuditTask",
        method: "GET",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("tasks"),
            Seg::Label("taskId"),
        ],
        verb: Verb::Get,
        rtype: "audit",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "taskId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(40),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("taskStatus", K::Str),
            ("taskType", K::Str),
            ("taskStartTime", K::Ts),
            ("taskStatistics", K::Struct),
            ("scheduledAuditName", K::Str),
            ("auditDetails", K::Map),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeAuthorizer",
        method: "GET",
        segs: &[Seg::Fixed("authorizer"), Seg::Label("authorizerName")],
        verb: Verb::Get,
        rtype: "authorizer",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "authorizerName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("authorizerDescription", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeBillingGroup",
        method: "GET",
        segs: &[Seg::Fixed("billing-groups"), Seg::Label("billingGroupName")],
        verb: Verb::Get,
        rtype: "billing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "billingGroupName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("billingGroupName", K::Str),
            ("billingGroupId", K::Str),
            ("billingGroupArn", K::Str),
            ("version", K::Int),
            ("billingGroupProperties", K::Struct),
            ("billingGroupMetadata", K::Struct),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeCACertificate",
        method: "GET",
        segs: &[Seg::Fixed("cacertificate"), Seg::Label("certificateId")],
        verb: Verb::Get,
        rtype: "cacertificate",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "certificateId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(64),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("certificateDescription", K::Struct),
            ("registrationConfig", K::Struct),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeCertificate",
        method: "GET",
        segs: &[Seg::Fixed("certificates"), Seg::Label("certificateId")],
        verb: Verb::Get,
        rtype: "certificates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "certificateId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(64),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("certificateDescription", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeCertificateProvider",
        method: "GET",
        segs: &[
            Seg::Fixed("certificate-providers"),
            Seg::Label("certificateProviderName"),
        ],
        verb: Verb::Get,
        rtype: "certificate-providers",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "certificateProviderName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("certificateProviderName", K::Str),
            ("certificateProviderArn", K::Str),
            ("lambdaFunctionArn", K::Str),
            ("accountDefaultForOperations", K::List),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
        ],
        list_field: Some("accountDefaultForOperations"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeCustomMetric",
        method: "GET",
        segs: &[Seg::Fixed("custom-metric"), Seg::Label("metricName")],
        verb: Verb::Get,
        rtype: "custom-metric",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "metricName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("metricName", K::Str),
            ("metricArn", K::Str),
            ("metricType", K::Str),
            ("displayName", K::Str),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeDefaultAuthorizer",
        method: "GET",
        segs: &[Seg::Fixed("default-authorizer")],
        verb: Verb::Action,
        rtype: "default-authorizer",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[],
        omembers: &[("authorizerDescription", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeDetectMitigationActionsTask",
        method: "GET",
        segs: &[
            Seg::Fixed("detect"),
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("tasks"),
            Seg::Label("taskId"),
        ],
        verb: Verb::Get,
        rtype: "detect",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "taskId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("taskSummary", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeDimension",
        method: "GET",
        segs: &[Seg::Fixed("dimensions"), Seg::Label("name")],
        verb: Verb::Get,
        rtype: "dimensions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "name",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("name", K::Str),
            ("arn", K::Str),
            ("type", K::Str),
            ("stringValues", K::List),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
        ],
        list_field: Some("stringValues"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeDomainConfiguration",
        method: "GET",
        segs: &[
            Seg::Fixed("domainConfigurations"),
            Seg::Label("domainConfigurationName"),
        ],
        verb: Verb::Get,
        rtype: "domainConfigurations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "domainConfigurationName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("domainConfigurationName", K::Str),
            ("domainConfigurationArn", K::Str),
            ("domainName", K::Str),
            ("serverCertificates", K::List),
            ("authorizerConfig", K::Struct),
            ("domainConfigurationStatus", K::Str),
            ("serviceType", K::Str),
            ("domainType", K::Str),
            ("lastStatusChangeDate", K::Ts),
            ("tlsConfig", K::Struct),
            ("serverCertificateConfig", K::Struct),
            ("authenticationType", K::Str),
            ("applicationProtocol", K::Str),
            ("clientCertificateConfig", K::Struct),
        ],
        list_field: Some("serverCertificates"),
        list_elems: &[
            ("serverCertificateArn", K::Str),
            ("serverCertificateStatus", K::Str),
            ("serverCertificateStatusDetail", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeEncryptionConfiguration",
        method: "GET",
        segs: &[Seg::Fixed("encryption-configuration")],
        verb: Verb::Action,
        rtype: "encryption-configuration",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[],
        omembers: &[
            ("encryptionType", K::Str),
            ("kmsKeyArn", K::Str),
            ("kmsAccessRoleArn", K::Str),
            ("configurationDetails", K::Struct),
            ("lastModifiedDate", K::Ts),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeEndpoint",
        method: "GET",
        segs: &[Seg::Fixed("endpoint")],
        verb: Verb::Action,
        rtype: "endpoint",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "endpointType",
            src: Src::Query,
            req: false,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("endpointAddress", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeEventConfigurations",
        method: "GET",
        segs: &[Seg::Fixed("event-configurations")],
        verb: Verb::Action,
        rtype: "event-configurations",
        nlabels: 0,
        has_input: true,
        errors: &["InternalFailureException", "ThrottlingException"],
        rules: &[],
        omembers: &[
            ("eventConfigurations", K::Map),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeFleetMetric",
        method: "GET",
        segs: &[Seg::Fixed("fleet-metric"), Seg::Label("metricName")],
        verb: Verb::Get,
        rtype: "fleet-metric",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "metricName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("metricName", K::Str),
            ("queryString", K::Str),
            ("aggregationType", K::Struct),
            ("period", K::Int),
            ("aggregationField", K::Str),
            ("description", K::Str),
            ("queryVersion", K::Str),
            ("indexName", K::Str),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
            ("unit", K::Str),
            ("version", K::Int),
            ("metricArn", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeIndex",
        method: "GET",
        segs: &[Seg::Fixed("indices"), Seg::Label("indexName")],
        verb: Verb::Get,
        rtype: "indices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "indexName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("indexName", K::Str),
            ("indexStatus", K::Str),
            ("schema", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeJob",
        method: "GET",
        segs: &[Seg::Fixed("jobs"), Seg::Label("jobId")],
        verb: Verb::Get,
        rtype: "jobs",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "jobId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("documentSource", K::Str), ("job", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeJobExecution",
        method: "GET",
        segs: &[
            Seg::Fixed("things"),
            Seg::Label("thingName"),
            Seg::Fixed("jobs"),
            Seg::Label("jobId"),
        ],
        verb: Verb::Get,
        rtype: "things",
        nlabels: 2,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "jobId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("execution", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeJobTemplate",
        method: "GET",
        segs: &[Seg::Fixed("job-templates"), Seg::Label("jobTemplateId")],
        verb: Verb::Get,
        rtype: "job-templates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "jobTemplateId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("jobTemplateArn", K::Str),
            ("jobTemplateId", K::Str),
            ("description", K::Str),
            ("documentSource", K::Str),
            ("document", K::Str),
            ("createdAt", K::Ts),
            ("presignedUrlConfig", K::Struct),
            ("jobExecutionsRolloutConfig", K::Struct),
            ("abortConfig", K::Struct),
            ("timeoutConfig", K::Struct),
            ("jobExecutionsRetryConfig", K::Struct),
            ("maintenanceWindows", K::List),
            ("destinationPackageVersions", K::List),
        ],
        list_field: Some("maintenanceWindows"),
        list_elems: &[("startTime", K::Str), ("durationInMinutes", K::Int)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeManagedJobTemplate",
        method: "GET",
        segs: &[
            Seg::Fixed("managed-job-templates"),
            Seg::Label("templateName"),
        ],
        verb: Verb::Get,
        rtype: "managed-job-templates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "templateName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("templateName", K::Str),
            ("templateArn", K::Str),
            ("description", K::Str),
            ("templateVersion", K::Str),
            ("environments", K::List),
            ("documentParameters", K::List),
            ("document", K::Str),
        ],
        list_field: Some("environments"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeMitigationAction",
        method: "GET",
        segs: &[
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("actions"),
            Seg::Label("actionName"),
        ],
        verb: Verb::Get,
        rtype: "mitigationactions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "actionName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("actionName", K::Str),
            ("actionType", K::Str),
            ("actionArn", K::Str),
            ("actionId", K::Str),
            ("roleArn", K::Str),
            ("actionParams", K::Struct),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeProvisioningTemplate",
        method: "GET",
        segs: &[
            Seg::Fixed("provisioning-templates"),
            Seg::Label("templateName"),
        ],
        verb: Verb::Get,
        rtype: "provisioning-templates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "templateName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(36),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("templateArn", K::Str),
            ("templateName", K::Str),
            ("description", K::Str),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
            ("defaultVersionId", K::Int),
            ("templateBody", K::Str),
            ("enabled", K::Bool),
            ("provisioningRoleArn", K::Str),
            ("preProvisioningHook", K::Struct),
            ("type", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeProvisioningTemplateVersion",
        method: "GET",
        segs: &[
            Seg::Fixed("provisioning-templates"),
            Seg::Label("templateName"),
            Seg::Fixed("versions"),
            Seg::Label("versionId"),
        ],
        verb: Verb::Get,
        rtype: "provisioning-templates",
        nlabels: 2,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "templateName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(36),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "versionId",
                src: Src::Label,
                req: true,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("versionId", K::Int),
            ("creationDate", K::Ts),
            ("templateBody", K::Str),
            ("isDefaultVersion", K::Bool),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeRoleAlias",
        method: "GET",
        segs: &[Seg::Fixed("role-aliases"), Seg::Label("roleAlias")],
        verb: Verb::Get,
        rtype: "role-aliases",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "roleAlias",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("roleAliasDescription", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeScheduledAudit",
        method: "GET",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("scheduledaudits"),
            Seg::Label("scheduledAuditName"),
        ],
        verb: Verb::Get,
        rtype: "audit",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "scheduledAuditName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("frequency", K::Str),
            ("dayOfMonth", K::Str),
            ("dayOfWeek", K::Str),
            ("targetCheckNames", K::List),
            ("scheduledAuditName", K::Str),
            ("scheduledAuditArn", K::Str),
        ],
        list_field: Some("targetCheckNames"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeSecurityProfile",
        method: "GET",
        segs: &[
            Seg::Fixed("security-profiles"),
            Seg::Label("securityProfileName"),
        ],
        verb: Verb::Get,
        rtype: "security-profiles",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "securityProfileName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("securityProfileName", K::Str),
            ("securityProfileArn", K::Str),
            ("securityProfileDescription", K::Str),
            ("behaviors", K::List),
            ("alertTargets", K::Map),
            ("additionalMetricsToRetain", K::List),
            ("additionalMetricsToRetainV2", K::List),
            ("version", K::Int),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
            ("metricsExportConfig", K::Struct),
        ],
        list_field: Some("behaviors"),
        list_elems: &[
            ("name", K::Str),
            ("metric", K::Str),
            ("metricDimension", K::Struct),
            ("criteria", K::Struct),
            ("suppressAlerts", K::Bool),
            ("exportMetric", K::Bool),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeStream",
        method: "GET",
        segs: &[Seg::Fixed("streams"), Seg::Label("streamId")],
        verb: Verb::Get,
        rtype: "streams",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "streamId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("streamInfo", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeThing",
        method: "GET",
        segs: &[Seg::Fixed("things"), Seg::Label("thingName")],
        verb: Verb::Get,
        rtype: "things",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "thingName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("defaultClientId", K::Str),
            ("thingName", K::Str),
            ("thingId", K::Str),
            ("thingArn", K::Str),
            ("thingTypeName", K::Str),
            ("attributes", K::Map),
            ("version", K::Int),
            ("billingGroupName", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeThingGroup",
        method: "GET",
        segs: &[Seg::Fixed("thing-groups"), Seg::Label("thingGroupName")],
        verb: Verb::Get,
        rtype: "thing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "thingGroupName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("thingGroupName", K::Str),
            ("thingGroupId", K::Str),
            ("thingGroupArn", K::Str),
            ("version", K::Int),
            ("thingGroupProperties", K::Struct),
            ("thingGroupMetadata", K::Struct),
            ("indexName", K::Str),
            ("queryString", K::Str),
            ("queryVersion", K::Str),
            ("status", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeThingRegistrationTask",
        method: "GET",
        segs: &[Seg::Fixed("thing-registration-tasks"), Seg::Label("taskId")],
        verb: Verb::Get,
        rtype: "thing-registration-tasks",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "taskId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(40),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("taskId", K::Str),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
            ("templateBody", K::Str),
            ("inputFileBucket", K::Str),
            ("inputFileKey", K::Str),
            ("roleArn", K::Str),
            ("status", K::Str),
            ("message", K::Str),
            ("successCount", K::Int),
            ("failureCount", K::Int),
            ("percentageProgress", K::Int),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DescribeThingType",
        method: "GET",
        segs: &[Seg::Fixed("thing-types"), Seg::Label("thingTypeName")],
        verb: Verb::Get,
        rtype: "thing-types",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "thingTypeName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("thingTypeName", K::Str),
            ("thingTypeId", K::Str),
            ("thingTypeArn", K::Str),
            ("thingTypeProperties", K::Struct),
            ("thingTypeMetadata", K::Struct),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DetachPolicy",
        method: "POST",
        segs: &[Seg::Fixed("target-policies"), Seg::Label("policyName")],
        verb: Verb::Action,
        rtype: "target-policies",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "policyName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "target",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DetachPrincipalPolicy",
        method: "DELETE",
        segs: &[Seg::Fixed("principal-policies"), Seg::Label("policyName")],
        verb: Verb::Action,
        rtype: "principal-policies",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "policyName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "x-amzn-iot-principal",
                src: Src::Header,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DetachSecurityProfile",
        method: "DELETE",
        segs: &[
            Seg::Fixed("security-profiles"),
            Seg::Label("securityProfileName"),
            Seg::Fixed("targets"),
        ],
        verb: Verb::Action,
        rtype: "security-profiles",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "securityProfileName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "securityProfileTargetArn",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DetachThingPrincipal",
        method: "DELETE",
        segs: &[
            Seg::Fixed("things"),
            Seg::Label("thingName"),
            Seg::Fixed("principals"),
        ],
        verb: Verb::Action,
        rtype: "things",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "thingName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "x-amzn-principal",
                src: Src::Header,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DisableTopicRule",
        method: "POST",
        segs: &[
            Seg::Fixed("rules"),
            Seg::Label("ruleName"),
            Seg::Fixed("disable"),
        ],
        verb: Verb::Action,
        rtype: "rules",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "ruleName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DisassociateSbomFromPackageVersion",
        method: "DELETE",
        segs: &[
            Seg::Fixed("packages"),
            Seg::Label("packageName"),
            Seg::Fixed("versions"),
            Seg::Label("versionName"),
            Seg::Fixed("sbom"),
        ],
        verb: Verb::Action,
        rtype: "packages",
        nlabels: 2,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "packageName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "versionName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(36),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "EnableTopicRule",
        method: "POST",
        segs: &[
            Seg::Fixed("rules"),
            Seg::Label("ruleName"),
            Seg::Fixed("enable"),
        ],
        verb: Verb::Action,
        rtype: "rules",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "ruleName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetBehaviorModelTrainingSummaries",
        method: "GET",
        segs: &[
            Seg::Fixed("behavior-model-training"),
            Seg::Fixed("summaries"),
        ],
        verb: Verb::Action,
        rtype: "behavior-model-training",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "securityProfileName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(10),
                enums: &[],
            },
        ],
        omembers: &[("summaries", K::List), ("nextToken", K::Str)],
        list_field: Some("summaries"),
        list_elems: &[
            ("securityProfileName", K::Str),
            ("behaviorName", K::Str),
            ("trainingDataCollectionStartDate", K::Ts),
            ("modelStatus", K::Str),
            ("datapointsCollectionPercentage", K::Num),
            ("lastModelRefreshDate", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetBucketsAggregation",
        method: "POST",
        segs: &[Seg::Fixed("indices"), Seg::Fixed("buckets")],
        verb: Verb::Action,
        rtype: "indices",
        nlabels: 0,
        has_input: true,
        errors: &[
            "IndexNotReadyException",
            "InternalFailureException",
            "InvalidAggregationException",
            "InvalidQueryException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "indexName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "queryString",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "aggregationField",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "bucketsAggregationType",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("totalCount", K::Int), ("buckets", K::List)],
        list_field: Some("buckets"),
        list_elems: &[("keyValue", K::Str), ("count", K::Int)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetCardinality",
        method: "POST",
        segs: &[Seg::Fixed("indices"), Seg::Fixed("cardinality")],
        verb: Verb::Action,
        rtype: "indices",
        nlabels: 0,
        has_input: true,
        errors: &[
            "IndexNotReadyException",
            "InternalFailureException",
            "InvalidAggregationException",
            "InvalidQueryException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "indexName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "queryString",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "aggregationField",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("cardinality", K::Int)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetCommand",
        method: "GET",
        segs: &[Seg::Fixed("commands"), Seg::Label("commandId")],
        verb: Verb::Get,
        rtype: "commands",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "commandId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("commandId", K::Str),
            ("commandArn", K::Str),
            ("namespace", K::Str),
            ("displayName", K::Str),
            ("description", K::Str),
            ("mandatoryParameters", K::List),
            ("payload", K::Struct),
            ("payloadTemplate", K::Str),
            ("preprocessor", K::Struct),
            ("roleArn", K::Str),
            ("createdAt", K::Ts),
            ("lastUpdatedAt", K::Ts),
            ("deprecated", K::Bool),
            ("pendingDeletion", K::Bool),
        ],
        list_field: Some("mandatoryParameters"),
        list_elems: &[
            ("name", K::Str),
            ("type", K::Str),
            ("value", K::Struct),
            ("defaultValue", K::Struct),
            ("valueConditions", K::List),
            ("description", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetCommandExecution",
        method: "GET",
        segs: &[Seg::Fixed("command-executions"), Seg::Label("executionId")],
        verb: Verb::Get,
        rtype: "command-executions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "executionId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "targetArn",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("executionId", K::Str),
            ("commandArn", K::Str),
            ("targetArn", K::Str),
            ("status", K::Str),
            ("statusReason", K::Struct),
            ("result", K::Map),
            ("parameters", K::Map),
            ("executionTimeoutSeconds", K::Int),
            ("createdAt", K::Ts),
            ("lastUpdatedAt", K::Ts),
            ("startedAt", K::Ts),
            ("completedAt", K::Ts),
            ("timeToLive", K::Ts),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetEffectivePolicies",
        method: "POST",
        segs: &[Seg::Fixed("effective-policies")],
        verb: Verb::Action,
        rtype: "effective-policies",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "thingName",
            src: Src::Query,
            req: false,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("effectivePolicies", K::List)],
        list_field: Some("effectivePolicies"),
        list_elems: &[
            ("policyName", K::Str),
            ("policyArn", K::Str),
            ("policyDocument", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetIndexingConfiguration",
        method: "GET",
        segs: &[Seg::Fixed("indexing"), Seg::Fixed("config")],
        verb: Verb::Action,
        rtype: "indexing",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[],
        omembers: &[
            ("thingIndexingConfiguration", K::Struct),
            ("thingGroupIndexingConfiguration", K::Struct),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetJobDocument",
        method: "GET",
        segs: &[
            Seg::Fixed("jobs"),
            Seg::Label("jobId"),
            Seg::Fixed("job-document"),
        ],
        verb: Verb::Action,
        rtype: "jobs",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "jobId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("document", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetLoggingOptions",
        method: "GET",
        segs: &[Seg::Fixed("loggingOptions")],
        verb: Verb::Action,
        rtype: "loggingOptions",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
        ],
        rules: &[],
        omembers: &[("roleArn", K::Str), ("logLevel", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetOTAUpdate",
        method: "GET",
        segs: &[Seg::Fixed("otaUpdates"), Seg::Label("otaUpdateId")],
        verb: Verb::Get,
        rtype: "otaUpdates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "otaUpdateId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("otaUpdateInfo", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetPackage",
        method: "GET",
        segs: &[Seg::Fixed("packages"), Seg::Label("packageName")],
        verb: Verb::Get,
        rtype: "packages",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "packageName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("packageName", K::Str),
            ("packageArn", K::Str),
            ("description", K::Str),
            ("defaultVersionName", K::Str),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetPackageConfiguration",
        method: "GET",
        segs: &[Seg::Fixed("package-configuration")],
        verb: Verb::Action,
        rtype: "package-configuration",
        nlabels: 0,
        has_input: true,
        errors: &["InternalServerException", "ThrottlingException"],
        rules: &[],
        omembers: &[("versionUpdateByJobsConfig", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetPackageVersion",
        method: "GET",
        segs: &[
            Seg::Fixed("packages"),
            Seg::Label("packageName"),
            Seg::Fixed("versions"),
            Seg::Label("versionName"),
        ],
        verb: Verb::Get,
        rtype: "packages",
        nlabels: 2,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "packageName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "versionName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("packageVersionArn", K::Str),
            ("packageName", K::Str),
            ("versionName", K::Str),
            ("description", K::Str),
            ("attributes", K::Map),
            ("artifact", K::Struct),
            ("status", K::Str),
            ("errorReason", K::Str),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
            ("sbom", K::Struct),
            ("sbomValidationStatus", K::Str),
            ("recipe", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetPercentiles",
        method: "POST",
        segs: &[Seg::Fixed("indices"), Seg::Fixed("percentiles")],
        verb: Verb::Action,
        rtype: "indices",
        nlabels: 0,
        has_input: true,
        errors: &[
            "IndexNotReadyException",
            "InternalFailureException",
            "InvalidAggregationException",
            "InvalidQueryException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "indexName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "queryString",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "aggregationField",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("percentiles", K::List)],
        list_field: Some("percentiles"),
        list_elems: &[("percent", K::Num), ("value", K::Num)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetPolicy",
        method: "GET",
        segs: &[Seg::Fixed("policies"), Seg::Label("policyName")],
        verb: Verb::Get,
        rtype: "policies",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "policyName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("policyName", K::Str),
            ("policyArn", K::Str),
            ("policyDocument", K::Str),
            ("defaultVersionId", K::Str),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
            ("generationId", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetPolicyVersion",
        method: "GET",
        segs: &[
            Seg::Fixed("policies"),
            Seg::Label("policyName"),
            Seg::Fixed("version"),
            Seg::Label("policyVersionId"),
        ],
        verb: Verb::Get,
        rtype: "policies",
        nlabels: 2,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "policyName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "policyVersionId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("policyArn", K::Str),
            ("policyName", K::Str),
            ("policyDocument", K::Str),
            ("policyVersionId", K::Str),
            ("isDefaultVersion", K::Bool),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
            ("generationId", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetRegistrationCode",
        method: "GET",
        segs: &[Seg::Fixed("registrationcode")],
        verb: Verb::Action,
        rtype: "registrationcode",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[],
        omembers: &[("registrationCode", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetStatistics",
        method: "POST",
        segs: &[Seg::Fixed("indices"), Seg::Fixed("statistics")],
        verb: Verb::Action,
        rtype: "indices",
        nlabels: 0,
        has_input: true,
        errors: &[
            "IndexNotReadyException",
            "InternalFailureException",
            "InvalidAggregationException",
            "InvalidQueryException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "indexName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "queryString",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "aggregationField",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("statistics", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetThingConnectivityData",
        method: "POST",
        segs: &[
            Seg::Fixed("things"),
            Seg::Label("thingName"),
            Seg::Fixed("connectivity-data"),
        ],
        verb: Verb::Action,
        rtype: "things",
        nlabels: 1,
        has_input: true,
        errors: &[
            "IndexNotReadyException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "thingName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("thingName", K::Str),
            ("connected", K::Bool),
            ("timestamp", K::Ts),
            ("disconnectReason", K::Str),
            ("sourceIp", K::Str),
            ("sourcePort", K::Int),
            ("targetIp", K::Str),
            ("targetPort", K::Int),
            ("vpcEndpointId", K::Str),
            ("keepAliveDuration", K::Int),
            ("cleanSession", K::Bool),
            ("sessionExpiry", K::Int),
            ("clientId", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetTopicRule",
        method: "GET",
        segs: &[Seg::Fixed("rules"), Seg::Label("ruleName")],
        verb: Verb::Get,
        rtype: "rules",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "ruleName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("ruleArn", K::Str), ("rule", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetTopicRuleDestination",
        method: "GET",
        segs: &[Seg::Fixed("destinations"), Seg::Greedy("arn")],
        verb: Verb::Get,
        rtype: "destinations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "arn",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: None,
            max_len: None,
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("topicRuleDestination", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetV2LoggingOptions",
        method: "GET",
        segs: &[Seg::Fixed("v2LoggingOptions")],
        verb: Verb::Action,
        rtype: "v2LoggingOptions",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalException",
            "NotConfiguredException",
            "ServiceUnavailableException",
        ],
        rules: &[],
        omembers: &[
            ("roleArn", K::Str),
            ("defaultLogLevel", K::Str),
            ("disableAllLogs", K::Bool),
            ("eventConfigurations", K::List),
        ],
        list_field: Some("eventConfigurations"),
        list_elems: &[
            ("eventType", K::Str),
            ("logLevel", K::Str),
            ("logDestination", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListActiveViolations",
        method: "GET",
        segs: &[Seg::Fixed("active-violations")],
        verb: Verb::List,
        rtype: "active-violations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "thingName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "securityProfileName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "behaviorCriteriaType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["STATIC", "STATISTICAL", "MACHINE_LEARNING"],
            },
            Rule {
                wire: "verificationState",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "FALSE_POSITIVE",
                    "BENIGN_POSITIVE",
                    "TRUE_POSITIVE",
                    "UNKNOWN",
                ],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("activeViolations", K::List), ("nextToken", K::Str)],
        list_field: Some("activeViolations"),
        list_elems: &[
            ("violationId", K::Str),
            ("thingName", K::Str),
            ("securityProfileName", K::Str),
            ("behavior", K::Struct),
            ("lastViolationValue", K::Struct),
            ("violationEventAdditionalInfo", K::Struct),
            ("verificationState", K::Str),
            ("verificationStateDescription", K::Str),
            ("lastViolationTime", K::Ts),
            ("violationStartTime", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListAttachedPolicies",
        method: "POST",
        segs: &[Seg::Fixed("attached-policies"), Seg::Label("target")],
        verb: Verb::List,
        rtype: "attached-policies",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "target",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("policies", K::List), ("nextMarker", K::Str)],
        list_field: Some("policies"),
        list_elems: &[("policyName", K::Str), ("policyArn", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListAuditFindings",
        method: "POST",
        segs: &[Seg::Fixed("audit"), Seg::Fixed("findings")],
        verb: Verb::List,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "taskId",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(40),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Body,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("findings", K::List), ("nextToken", K::Str)],
        list_field: Some("findings"),
        list_elems: &[
            ("findingId", K::Str),
            ("taskId", K::Str),
            ("checkName", K::Str),
            ("taskStartTime", K::Ts),
            ("findingTime", K::Ts),
            ("severity", K::Str),
            ("nonCompliantResource", K::Struct),
            ("relatedResources", K::List),
            ("reasonForNonCompliance", K::Str),
            ("reasonForNonComplianceCode", K::Str),
            ("isSuppressed", K::Bool),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListAuditMitigationActionsExecutions",
        method: "GET",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("executions"),
        ],
        verb: Verb::List,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "taskId",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "actionStatus",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "IN_PROGRESS",
                    "COMPLETED",
                    "FAILED",
                    "CANCELED",
                    "SKIPPED",
                    "PENDING",
                ],
            },
            Rule {
                wire: "findingId",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("actionsExecutions", K::List), ("nextToken", K::Str)],
        list_field: Some("actionsExecutions"),
        list_elems: &[
            ("taskId", K::Str),
            ("findingId", K::Str),
            ("actionName", K::Str),
            ("actionId", K::Str),
            ("status", K::Str),
            ("startTime", K::Ts),
            ("endTime", K::Ts),
            ("errorCode", K::Str),
            ("message", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListAuditMitigationActionsTasks",
        method: "GET",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("tasks"),
        ],
        verb: Verb::List,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "auditTaskId",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(40),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "findingId",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "taskStatus",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["IN_PROGRESS", "COMPLETED", "FAILED", "CANCELED"],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "startTime",
                src: Src::Query,
                req: true,
                kind: K::Ts,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "endTime",
                src: Src::Query,
                req: true,
                kind: K::Ts,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("tasks", K::List), ("nextToken", K::Str)],
        list_field: Some("tasks"),
        list_elems: &[
            ("taskId", K::Str),
            ("startTime", K::Ts),
            ("taskStatus", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListAuditSuppressions",
        method: "POST",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("suppressions"),
            Seg::Fixed("list"),
        ],
        verb: Verb::List,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Body,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(250),
            enums: &[],
        }],
        omembers: &[("suppressions", K::List), ("nextToken", K::Str)],
        list_field: Some("suppressions"),
        list_elems: &[
            ("checkName", K::Str),
            ("resourceIdentifier", K::Struct),
            ("expirationDate", K::Ts),
            ("suppressIndefinitely", K::Bool),
            ("description", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListAuditTasks",
        method: "GET",
        segs: &[Seg::Fixed("audit"), Seg::Fixed("tasks")],
        verb: Verb::List,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "startTime",
                src: Src::Query,
                req: true,
                kind: K::Ts,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "endTime",
                src: Src::Query,
                req: true,
                kind: K::Ts,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "taskType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["ON_DEMAND_AUDIT_TASK", "SCHEDULED_AUDIT_TASK"],
            },
            Rule {
                wire: "taskStatus",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["IN_PROGRESS", "COMPLETED", "FAILED", "CANCELED"],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("tasks", K::List), ("nextToken", K::Str)],
        list_field: Some("tasks"),
        list_elems: &[
            ("taskId", K::Str),
            ("taskStatus", K::Str),
            ("taskType", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListAuthorizers",
        method: "GET",
        segs: &[Seg::Fixed("authorizers")],
        verb: Verb::List,
        rtype: "authorizers",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "status",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["ACTIVE", "INACTIVE"],
            },
        ],
        omembers: &[("authorizers", K::List), ("nextMarker", K::Str)],
        list_field: Some("authorizers"),
        list_elems: &[("authorizerName", K::Str), ("authorizerArn", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListBillingGroups",
        method: "GET",
        segs: &[Seg::Fixed("billing-groups")],
        verb: Verb::List,
        rtype: "billing-groups",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "namePrefixFilter",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("billingGroups", K::List), ("nextToken", K::Str)],
        list_field: Some("billingGroups"),
        list_elems: &[("groupName", K::Str), ("groupArn", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListCACertificates",
        method: "GET",
        segs: &[Seg::Fixed("cacertificates")],
        verb: Verb::List,
        rtype: "cacertificates",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "templateName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(36),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("certificates", K::List), ("nextMarker", K::Str)],
        list_field: Some("certificates"),
        list_elems: &[
            ("certificateArn", K::Str),
            ("certificateId", K::Str),
            ("status", K::Str),
            ("creationDate", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListCertificateProviders",
        method: "GET",
        segs: &[Seg::Fixed("certificate-providers")],
        verb: Verb::List,
        rtype: "certificate-providers",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "nextToken",
            src: Src::Query,
            req: false,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(1024),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("certificateProviders", K::List), ("nextToken", K::Str)],
        list_field: Some("certificateProviders"),
        list_elems: &[
            ("certificateProviderName", K::Str),
            ("certificateProviderArn", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListCertificates",
        method: "GET",
        segs: &[Seg::Fixed("certificates")],
        verb: Verb::List,
        rtype: "certificates",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("certificates", K::List), ("nextMarker", K::Str)],
        list_field: Some("certificates"),
        list_elems: &[
            ("certificateArn", K::Str),
            ("certificateId", K::Str),
            ("status", K::Str),
            ("certificateMode", K::Str),
            ("creationDate", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListCertificatesByCA",
        method: "GET",
        segs: &[
            Seg::Fixed("certificates-by-ca"),
            Seg::Label("caCertificateId"),
        ],
        verb: Verb::List,
        rtype: "certificates-by-ca",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "caCertificateId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(64),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("certificates", K::List), ("nextMarker", K::Str)],
        list_field: Some("certificates"),
        list_elems: &[
            ("certificateArn", K::Str),
            ("certificateId", K::Str),
            ("status", K::Str),
            ("certificateMode", K::Str),
            ("creationDate", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListCommandExecutions",
        method: "POST",
        segs: &[Seg::Fixed("command-executions")],
        verb: Verb::List,
        rtype: "command-executions",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(100),
                enums: &[],
            },
            Rule {
                wire: "namespace",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["AWS-IoT", "AWS-IoT-FleetWise"],
            },
            Rule {
                wire: "status",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "CREATED",
                    "IN_PROGRESS",
                    "SUCCEEDED",
                    "FAILED",
                    "REJECTED",
                    "TIMED_OUT",
                ],
            },
            Rule {
                wire: "sortOrder",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["ASCENDING", "DESCENDING"],
            },
            Rule {
                wire: "targetArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("commandExecutions", K::List), ("nextToken", K::Str)],
        list_field: Some("commandExecutions"),
        list_elems: &[
            ("commandArn", K::Str),
            ("executionId", K::Str),
            ("targetArn", K::Str),
            ("status", K::Str),
            ("createdAt", K::Ts),
            ("startedAt", K::Ts),
            ("completedAt", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListCommands",
        method: "GET",
        segs: &[Seg::Fixed("commands")],
        verb: Verb::List,
        rtype: "commands",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(100),
                enums: &[],
            },
            Rule {
                wire: "namespace",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["AWS-IoT", "AWS-IoT-FleetWise"],
            },
            Rule {
                wire: "commandParameterName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(192),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "sortOrder",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["ASCENDING", "DESCENDING"],
            },
        ],
        omembers: &[("commands", K::List), ("nextToken", K::Str)],
        list_field: Some("commands"),
        list_elems: &[
            ("commandArn", K::Str),
            ("commandId", K::Str),
            ("displayName", K::Str),
            ("deprecated", K::Bool),
            ("createdAt", K::Ts),
            ("lastUpdatedAt", K::Ts),
            ("pendingDeletion", K::Bool),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListCustomMetrics",
        method: "GET",
        segs: &[Seg::Fixed("custom-metrics")],
        verb: Verb::List,
        rtype: "custom-metrics",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Query,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(250),
            enums: &[],
        }],
        omembers: &[("metricNames", K::List), ("nextToken", K::Str)],
        list_field: Some("metricNames"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListDetectMitigationActionsExecutions",
        method: "GET",
        segs: &[
            Seg::Fixed("detect"),
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("executions"),
        ],
        verb: Verb::List,
        rtype: "detect",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "taskId",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "violationId",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("actionsExecutions", K::List), ("nextToken", K::Str)],
        list_field: Some("actionsExecutions"),
        list_elems: &[
            ("taskId", K::Str),
            ("violationId", K::Str),
            ("actionName", K::Str),
            ("thingName", K::Str),
            ("executionStartDate", K::Ts),
            ("executionEndDate", K::Ts),
            ("status", K::Str),
            ("errorCode", K::Str),
            ("message", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListDetectMitigationActionsTasks",
        method: "GET",
        segs: &[
            Seg::Fixed("detect"),
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("tasks"),
        ],
        verb: Verb::List,
        rtype: "detect",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "startTime",
                src: Src::Query,
                req: true,
                kind: K::Ts,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "endTime",
                src: Src::Query,
                req: true,
                kind: K::Ts,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("tasks", K::List), ("nextToken", K::Str)],
        list_field: Some("tasks"),
        list_elems: &[
            ("taskId", K::Str),
            ("taskStatus", K::Str),
            ("taskStartTime", K::Ts),
            ("taskEndTime", K::Ts),
            ("target", K::Struct),
            ("violationEventOccurrenceRange", K::Struct),
            ("onlyActiveViolationsIncluded", K::Bool),
            ("suppressedAlertsIncluded", K::Bool),
            ("actionsDefinition", K::List),
            ("taskStatistics", K::Struct),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListDimensions",
        method: "GET",
        segs: &[Seg::Fixed("dimensions")],
        verb: Verb::List,
        rtype: "dimensions",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Query,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(250),
            enums: &[],
        }],
        omembers: &[("dimensionNames", K::List), ("nextToken", K::Str)],
        list_field: Some("dimensionNames"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListDomainConfigurations",
        method: "GET",
        segs: &[Seg::Fixed("domainConfigurations")],
        verb: Verb::List,
        rtype: "domainConfigurations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "serviceType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["DATA", "CREDENTIAL_PROVIDER", "JOBS"],
            },
        ],
        omembers: &[("domainConfigurations", K::List), ("nextMarker", K::Str)],
        list_field: Some("domainConfigurations"),
        list_elems: &[
            ("domainConfigurationName", K::Str),
            ("domainConfigurationArn", K::Str),
            ("serviceType", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListFleetMetrics",
        method: "GET",
        segs: &[Seg::Fixed("fleet-metrics")],
        verb: Verb::List,
        rtype: "fleet-metrics",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Query,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(250),
            enums: &[],
        }],
        omembers: &[("fleetMetrics", K::List), ("nextToken", K::Str)],
        list_field: Some("fleetMetrics"),
        list_elems: &[("metricName", K::Str), ("metricArn", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListIndices",
        method: "GET",
        segs: &[Seg::Fixed("indices")],
        verb: Verb::List,
        rtype: "indices",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Query,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(500),
            enums: &[],
        }],
        omembers: &[("indexNames", K::List), ("nextToken", K::Str)],
        list_field: Some("indexNames"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListJobExecutionsForJob",
        method: "GET",
        segs: &[
            Seg::Fixed("jobs"),
            Seg::Label("jobId"),
            Seg::Fixed("things"),
        ],
        verb: Verb::List,
        rtype: "jobs",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "jobId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "status",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "QUEUED",
                    "IN_PROGRESS",
                    "SUCCEEDED",
                    "FAILED",
                    "TIMED_OUT",
                    "REJECTED",
                    "REMOVED",
                    "CANCELED",
                ],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("executionSummaries", K::List), ("nextToken", K::Str)],
        list_field: Some("executionSummaries"),
        list_elems: &[("thingArn", K::Str), ("jobExecutionSummary", K::Struct)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListJobExecutionsForThing",
        method: "GET",
        segs: &[
            Seg::Fixed("things"),
            Seg::Label("thingName"),
            Seg::Fixed("jobs"),
        ],
        verb: Verb::List,
        rtype: "things",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "thingName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "status",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "QUEUED",
                    "IN_PROGRESS",
                    "SUCCEEDED",
                    "FAILED",
                    "TIMED_OUT",
                    "REJECTED",
                    "REMOVED",
                    "CANCELED",
                ],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "jobId",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("executionSummaries", K::List), ("nextToken", K::Str)],
        list_field: Some("executionSummaries"),
        list_elems: &[("jobId", K::Str), ("jobExecutionSummary", K::Struct)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListJobTemplates",
        method: "GET",
        segs: &[Seg::Fixed("job-templates")],
        verb: Verb::List,
        rtype: "job-templates",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Query,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(250),
            enums: &[],
        }],
        omembers: &[("jobTemplates", K::List), ("nextToken", K::Str)],
        list_field: Some("jobTemplates"),
        list_elems: &[
            ("jobTemplateArn", K::Str),
            ("jobTemplateId", K::Str),
            ("description", K::Str),
            ("createdAt", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListJobs",
        method: "GET",
        segs: &[Seg::Fixed("jobs")],
        verb: Verb::List,
        rtype: "jobs",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "status",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "IN_PROGRESS",
                    "CANCELED",
                    "COMPLETED",
                    "DELETION_IN_PROGRESS",
                    "SCHEDULED",
                ],
            },
            Rule {
                wire: "targetSelection",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["CONTINUOUS", "SNAPSHOT"],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "thingGroupName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingGroupId",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("jobs", K::List), ("nextToken", K::Str)],
        list_field: Some("jobs"),
        list_elems: &[
            ("jobArn", K::Str),
            ("jobId", K::Str),
            ("thingGroupId", K::Str),
            ("targetSelection", K::Str),
            ("status", K::Str),
            ("createdAt", K::Ts),
            ("lastUpdatedAt", K::Ts),
            ("completedAt", K::Ts),
            ("isConcurrent", K::Bool),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListManagedJobTemplates",
        method: "GET",
        segs: &[Seg::Fixed("managed-job-templates")],
        verb: Verb::List,
        rtype: "managed-job-templates",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalServerException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "templateName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("managedJobTemplates", K::List), ("nextToken", K::Str)],
        list_field: Some("managedJobTemplates"),
        list_elems: &[
            ("templateArn", K::Str),
            ("templateName", K::Str),
            ("description", K::Str),
            ("environments", K::List),
            ("templateVersion", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListMetricValues",
        method: "GET",
        segs: &[Seg::Fixed("metric-values")],
        verb: Verb::List,
        rtype: "metric-values",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "thingName",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "metricName",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "dimensionName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "dimensionValueOperator",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["IN", "NOT_IN"],
            },
            Rule {
                wire: "startTime",
                src: Src::Query,
                req: true,
                kind: K::Ts,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "endTime",
                src: Src::Query,
                req: true,
                kind: K::Ts,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("metricDatumList", K::List), ("nextToken", K::Str)],
        list_field: Some("metricDatumList"),
        list_elems: &[("timestamp", K::Ts), ("value", K::Struct)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListMitigationActions",
        method: "GET",
        segs: &[Seg::Fixed("mitigationactions"), Seg::Fixed("actions")],
        verb: Verb::List,
        rtype: "mitigationactions",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "actionType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "UPDATE_DEVICE_CERTIFICATE",
                    "UPDATE_CA_CERTIFICATE",
                    "ADD_THINGS_TO_THING_GROUP",
                    "REPLACE_DEFAULT_POLICY_VERSION",
                    "ENABLE_IOT_LOGGING",
                    "PUBLISH_FINDING_TO_SNS",
                ],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("actionIdentifiers", K::List), ("nextToken", K::Str)],
        list_field: Some("actionIdentifiers"),
        list_elems: &[
            ("actionName", K::Str),
            ("actionArn", K::Str),
            ("creationDate", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListOTAUpdates",
        method: "GET",
        segs: &[Seg::Fixed("otaUpdates")],
        verb: Verb::List,
        rtype: "otaUpdates",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "otaUpdateStatus",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "CREATE_PENDING",
                    "CREATE_IN_PROGRESS",
                    "CREATE_COMPLETE",
                    "CREATE_FAILED",
                    "DELETE_IN_PROGRESS",
                    "DELETE_FAILED",
                ],
            },
        ],
        omembers: &[("otaUpdates", K::List), ("nextToken", K::Str)],
        list_field: Some("otaUpdates"),
        list_elems: &[
            ("otaUpdateId", K::Str),
            ("otaUpdateArn", K::Str),
            ("creationDate", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListOutgoingCertificates",
        method: "GET",
        segs: &[Seg::Fixed("certificates-out-going")],
        verb: Verb::List,
        rtype: "certificates-out-going",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("outgoingCertificates", K::List), ("nextMarker", K::Str)],
        list_field: Some("outgoingCertificates"),
        list_elems: &[
            ("certificateArn", K::Str),
            ("certificateId", K::Str),
            ("transferredTo", K::Str),
            ("transferDate", K::Ts),
            ("transferMessage", K::Str),
            ("creationDate", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListPackageVersions",
        method: "GET",
        segs: &[
            Seg::Fixed("packages"),
            Seg::Label("packageName"),
            Seg::Fixed("versions"),
        ],
        verb: Verb::List,
        rtype: "packages",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "packageName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "status",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["DRAFT", "PUBLISHED", "DEPRECATED"],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(100),
                enums: &[],
            },
        ],
        omembers: &[("packageVersionSummaries", K::List), ("nextToken", K::Str)],
        list_field: Some("packageVersionSummaries"),
        list_elems: &[
            ("packageName", K::Str),
            ("versionName", K::Str),
            ("status", K::Str),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListPackages",
        method: "GET",
        segs: &[Seg::Fixed("packages")],
        verb: Verb::List,
        rtype: "packages",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Query,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(100),
            enums: &[],
        }],
        omembers: &[("packageSummaries", K::List), ("nextToken", K::Str)],
        list_field: Some("packageSummaries"),
        list_elems: &[
            ("packageName", K::Str),
            ("defaultVersionName", K::Str),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListPolicies",
        method: "GET",
        segs: &[Seg::Fixed("policies")],
        verb: Verb::List,
        rtype: "policies",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("policies", K::List), ("nextMarker", K::Str)],
        list_field: Some("policies"),
        list_elems: &[("policyName", K::Str), ("policyArn", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListPolicyPrincipals",
        method: "GET",
        segs: &[Seg::Fixed("policy-principals")],
        verb: Verb::List,
        rtype: "policy-principals",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "x-amzn-iot-policy",
                src: Src::Header,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("principals", K::List), ("nextMarker", K::Str)],
        list_field: Some("principals"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListPolicyVersions",
        method: "GET",
        segs: &[
            Seg::Fixed("policies"),
            Seg::Label("policyName"),
            Seg::Fixed("version"),
        ],
        verb: Verb::List,
        rtype: "policies",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "policyName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("policyVersions", K::List)],
        list_field: Some("policyVersions"),
        list_elems: &[
            ("versionId", K::Str),
            ("isDefaultVersion", K::Bool),
            ("createDate", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListPrincipalPolicies",
        method: "GET",
        segs: &[Seg::Fixed("principal-policies")],
        verb: Verb::List,
        rtype: "principal-policies",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "x-amzn-iot-principal",
                src: Src::Header,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("policies", K::List), ("nextMarker", K::Str)],
        list_field: Some("policies"),
        list_elems: &[("policyName", K::Str), ("policyArn", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListPrincipalThings",
        method: "GET",
        segs: &[Seg::Fixed("principals"), Seg::Fixed("things")],
        verb: Verb::List,
        rtype: "principals",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "x-amzn-principal",
                src: Src::Header,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("things", K::List), ("nextToken", K::Str)],
        list_field: Some("things"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListPrincipalThingsV2",
        method: "GET",
        segs: &[Seg::Fixed("principals"), Seg::Fixed("things-v2")],
        verb: Verb::List,
        rtype: "principals",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "x-amzn-principal",
                src: Src::Header,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingPrincipalType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["EXCLUSIVE_THING", "NON_EXCLUSIVE_THING"],
            },
        ],
        omembers: &[("principalThingObjects", K::List), ("nextToken", K::Str)],
        list_field: Some("principalThingObjects"),
        list_elems: &[("thingName", K::Str), ("thingPrincipalType", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListProvisioningTemplateVersions",
        method: "GET",
        segs: &[
            Seg::Fixed("provisioning-templates"),
            Seg::Label("templateName"),
            Seg::Fixed("versions"),
        ],
        verb: Verb::List,
        rtype: "provisioning-templates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "templateName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(36),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("versions", K::List), ("nextToken", K::Str)],
        list_field: Some("versions"),
        list_elems: &[
            ("versionId", K::Int),
            ("creationDate", K::Ts),
            ("isDefaultVersion", K::Bool),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListProvisioningTemplates",
        method: "GET",
        segs: &[Seg::Fixed("provisioning-templates")],
        verb: Verb::List,
        rtype: "provisioning-templates",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Query,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(250),
            enums: &[],
        }],
        omembers: &[("templates", K::List), ("nextToken", K::Str)],
        list_field: Some("templates"),
        list_elems: &[
            ("templateArn", K::Str),
            ("templateName", K::Str),
            ("description", K::Str),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
            ("enabled", K::Bool),
            ("type", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListRelatedResourcesForAuditFinding",
        method: "GET",
        segs: &[Seg::Fixed("audit"), Seg::Fixed("relatedResources")],
        verb: Verb::List,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "findingId",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("relatedResources", K::List), ("nextToken", K::Str)],
        list_field: Some("relatedResources"),
        list_elems: &[
            ("resourceType", K::Str),
            ("resourceIdentifier", K::Struct),
            ("additionalInfo", K::Map),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListRoleAliases",
        method: "GET",
        segs: &[Seg::Fixed("role-aliases")],
        verb: Verb::List,
        rtype: "role-aliases",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("roleAliases", K::List), ("nextMarker", K::Str)],
        list_field: Some("roleAliases"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListSbomValidationResults",
        method: "GET",
        segs: &[
            Seg::Fixed("packages"),
            Seg::Label("packageName"),
            Seg::Fixed("versions"),
            Seg::Label("versionName"),
            Seg::Fixed("sbom-validation-results"),
        ],
        verb: Verb::List,
        rtype: "packages",
        nlabels: 2,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "packageName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "versionName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "validationResult",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["FAILED", "SUCCEEDED"],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(100),
                enums: &[],
            },
        ],
        omembers: &[
            ("validationResultSummaries", K::List),
            ("nextToken", K::Str),
        ],
        list_field: Some("validationResultSummaries"),
        list_elems: &[
            ("fileName", K::Str),
            ("validationResult", K::Str),
            ("errorCode", K::Str),
            ("errorMessage", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListScheduledAudits",
        method: "GET",
        segs: &[Seg::Fixed("audit"), Seg::Fixed("scheduledaudits")],
        verb: Verb::List,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Query,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(250),
            enums: &[],
        }],
        omembers: &[("scheduledAudits", K::List), ("nextToken", K::Str)],
        list_field: Some("scheduledAudits"),
        list_elems: &[
            ("scheduledAuditName", K::Str),
            ("scheduledAuditArn", K::Str),
            ("frequency", K::Str),
            ("dayOfMonth", K::Str),
            ("dayOfWeek", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListSecurityProfiles",
        method: "GET",
        segs: &[Seg::Fixed("security-profiles")],
        verb: Verb::List,
        rtype: "security-profiles",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "dimensionName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "metricName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("securityProfileIdentifiers", K::List),
            ("nextToken", K::Str),
        ],
        list_field: Some("securityProfileIdentifiers"),
        list_elems: &[("name", K::Str), ("arn", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListSecurityProfilesForTarget",
        method: "GET",
        segs: &[Seg::Fixed("security-profiles-for-target")],
        verb: Verb::List,
        rtype: "security-profiles-for-target",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "securityProfileTargetArn",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("securityProfileTargetMappings", K::List),
            ("nextToken", K::Str),
        ],
        list_field: Some("securityProfileTargetMappings"),
        list_elems: &[
            ("securityProfileIdentifier", K::Struct),
            ("target", K::Struct),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListStreams",
        method: "GET",
        segs: &[Seg::Fixed("streams")],
        verb: Verb::List,
        rtype: "streams",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Query,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(250),
            enums: &[],
        }],
        omembers: &[("streams", K::List), ("nextToken", K::Str)],
        list_field: Some("streams"),
        list_elems: &[
            ("streamId", K::Str),
            ("streamArn", K::Str),
            ("streamVersion", K::Int),
            ("description", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListTagsForResource",
        method: "GET",
        segs: &[Seg::Fixed("tags")],
        verb: Verb::List,
        rtype: "tags",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "resourceArn",
            src: Src::Query,
            req: true,
            kind: K::Str,
            min_len: None,
            max_len: None,
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("tags", K::List), ("nextToken", K::Str)],
        list_field: Some("tags"),
        list_elems: &[("Key", K::Str), ("Value", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListTargetsForPolicy",
        method: "POST",
        segs: &[Seg::Fixed("policy-targets"), Seg::Label("policyName")],
        verb: Verb::List,
        rtype: "policy-targets",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "policyName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "marker",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "pageSize",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("targets", K::List), ("nextMarker", K::Str)],
        list_field: Some("targets"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListTargetsForSecurityProfile",
        method: "GET",
        segs: &[
            Seg::Fixed("security-profiles"),
            Seg::Label("securityProfileName"),
            Seg::Fixed("targets"),
        ],
        verb: Verb::List,
        rtype: "security-profiles",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "securityProfileName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("securityProfileTargets", K::List), ("nextToken", K::Str)],
        list_field: Some("securityProfileTargets"),
        list_elems: &[("arn", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListThingGroups",
        method: "GET",
        segs: &[Seg::Fixed("thing-groups")],
        verb: Verb::List,
        rtype: "thing-groups",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "parentGroup",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "namePrefixFilter",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("thingGroups", K::List), ("nextToken", K::Str)],
        list_field: Some("thingGroups"),
        list_elems: &[("groupName", K::Str), ("groupArn", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListThingGroupsForThing",
        method: "GET",
        segs: &[
            Seg::Fixed("things"),
            Seg::Label("thingName"),
            Seg::Fixed("thing-groups"),
        ],
        verb: Verb::List,
        rtype: "things",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "thingName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("thingGroups", K::List), ("nextToken", K::Str)],
        list_field: Some("thingGroups"),
        list_elems: &[("groupName", K::Str), ("groupArn", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListThingPrincipals",
        method: "GET",
        segs: &[
            Seg::Fixed("things"),
            Seg::Label("thingName"),
            Seg::Fixed("principals"),
        ],
        verb: Verb::List,
        rtype: "things",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "thingName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("principals", K::List), ("nextToken", K::Str)],
        list_field: Some("principals"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListThingPrincipalsV2",
        method: "GET",
        segs: &[
            Seg::Fixed("things"),
            Seg::Label("thingName"),
            Seg::Fixed("principals-v2"),
        ],
        verb: Verb::List,
        rtype: "things",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "thingName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingPrincipalType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["EXCLUSIVE_THING", "NON_EXCLUSIVE_THING"],
            },
        ],
        omembers: &[("thingPrincipalObjects", K::List), ("nextToken", K::Str)],
        list_field: Some("thingPrincipalObjects"),
        list_elems: &[("principal", K::Str), ("thingPrincipalType", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListThingRegistrationTaskReports",
        method: "GET",
        segs: &[
            Seg::Fixed("thing-registration-tasks"),
            Seg::Label("taskId"),
            Seg::Fixed("reports"),
        ],
        verb: Verb::List,
        rtype: "thing-registration-tasks",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "taskId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(40),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "reportType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["ERRORS", "RESULTS"],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[
            ("resourceLinks", K::List),
            ("reportType", K::Str),
            ("nextToken", K::Str),
        ],
        list_field: Some("resourceLinks"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListThingRegistrationTasks",
        method: "GET",
        segs: &[Seg::Fixed("thing-registration-tasks")],
        verb: Verb::List,
        rtype: "thing-registration-tasks",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "status",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "InProgress",
                    "Completed",
                    "Failed",
                    "Cancelled",
                    "Cancelling",
                ],
            },
        ],
        omembers: &[("taskIds", K::List), ("nextToken", K::Str)],
        list_field: Some("taskIds"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListThingTypes",
        method: "GET",
        segs: &[Seg::Fixed("thing-types")],
        verb: Verb::List,
        rtype: "thing-types",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "thingTypeName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("thingTypes", K::List), ("nextToken", K::Str)],
        list_field: Some("thingTypes"),
        list_elems: &[
            ("thingTypeName", K::Str),
            ("thingTypeArn", K::Str),
            ("thingTypeProperties", K::Struct),
            ("thingTypeMetadata", K::Struct),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListThings",
        method: "GET",
        segs: &[Seg::Fixed("things")],
        verb: Verb::List,
        rtype: "things",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "attributeName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "attributeValue",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(800),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingTypeName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("things", K::List), ("nextToken", K::Str)],
        list_field: Some("things"),
        list_elems: &[
            ("thingName", K::Str),
            ("thingTypeName", K::Str),
            ("thingArn", K::Str),
            ("attributes", K::Map),
            ("version", K::Int),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListThingsInBillingGroup",
        method: "GET",
        segs: &[
            Seg::Fixed("billing-groups"),
            Seg::Label("billingGroupName"),
            Seg::Fixed("things"),
        ],
        verb: Verb::List,
        rtype: "billing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "billingGroupName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("things", K::List), ("nextToken", K::Str)],
        list_field: Some("things"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListThingsInThingGroup",
        method: "GET",
        segs: &[
            Seg::Fixed("thing-groups"),
            Seg::Label("thingGroupName"),
            Seg::Fixed("things"),
        ],
        verb: Verb::List,
        rtype: "thing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "thingGroupName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("things", K::List), ("nextToken", K::Str)],
        list_field: Some("things"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "ListTopicRuleDestinations",
        method: "GET",
        segs: &[Seg::Fixed("destinations")],
        verb: Verb::List,
        rtype: "destinations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Query,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(1000),
            enums: &[],
        }],
        omembers: &[("destinationSummaries", K::List), ("nextToken", K::Str)],
        list_field: Some("destinationSummaries"),
        list_elems: &[
            ("arn", K::Str),
            ("status", K::Str),
            ("createdAt", K::Ts),
            ("lastUpdatedAt", K::Ts),
            ("statusReason", K::Str),
            ("httpUrlSummary", K::Struct),
            ("vpcDestinationSummary", K::Struct),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListTopicRules",
        method: "GET",
        segs: &[Seg::Fixed("rules")],
        verb: Verb::List,
        rtype: "rules",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "maxResults",
            src: Src::Query,
            req: false,
            kind: K::Int,
            min_len: None,
            max_len: None,
            min_val: Some(1),
            max_val: Some(10000),
            enums: &[],
        }],
        omembers: &[("rules", K::List), ("nextToken", K::Str)],
        list_field: Some("rules"),
        list_elems: &[
            ("ruleArn", K::Str),
            ("ruleName", K::Str),
            ("topicPattern", K::Str),
            ("createdAt", K::Ts),
            ("ruleDisabled", K::Bool),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListV2LoggingLevels",
        method: "GET",
        segs: &[Seg::Fixed("v2LoggingLevel")],
        verb: Verb::List,
        rtype: "v2LoggingLevel",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalException",
            "InvalidRequestException",
            "NotConfiguredException",
            "ServiceUnavailableException",
        ],
        rules: &[
            Rule {
                wire: "targetType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "DEFAULT",
                    "THING_GROUP",
                    "CLIENT_ID",
                    "SOURCE_IP",
                    "PRINCIPAL_ID",
                ],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("logTargetConfigurations", K::List), ("nextToken", K::Str)],
        list_field: Some("logTargetConfigurations"),
        list_elems: &[("logTarget", K::Struct), ("logLevel", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListViolationEvents",
        method: "GET",
        segs: &[Seg::Fixed("violation-events")],
        verb: Verb::List,
        rtype: "violation-events",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "startTime",
                src: Src::Query,
                req: true,
                kind: K::Ts,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "endTime",
                src: Src::Query,
                req: true,
                kind: K::Ts,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "securityProfileName",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "behaviorCriteriaType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["STATIC", "STATISTICAL", "MACHINE_LEARNING"],
            },
            Rule {
                wire: "verificationState",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "FALSE_POSITIVE",
                    "BENIGN_POSITIVE",
                    "TRUE_POSITIVE",
                    "UNKNOWN",
                ],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("violationEvents", K::List), ("nextToken", K::Str)],
        list_field: Some("violationEvents"),
        list_elems: &[
            ("violationId", K::Str),
            ("thingName", K::Str),
            ("securityProfileName", K::Str),
            ("behavior", K::Struct),
            ("metricValue", K::Struct),
            ("violationEventAdditionalInfo", K::Struct),
            ("violationEventType", K::Str),
            ("verificationState", K::Str),
            ("verificationStateDescription", K::Str),
            ("violationEventTime", K::Ts),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "PutVerificationStateOnViolation",
        method: "POST",
        segs: &[
            Seg::Fixed("violations"),
            Seg::Fixed("verification-state"),
            Seg::Label("violationId"),
        ],
        verb: Verb::Action,
        rtype: "violations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "violationId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "verificationState",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "FALSE_POSITIVE",
                    "BENIGN_POSITIVE",
                    "TRUE_POSITIVE",
                    "UNKNOWN",
                ],
            },
            Rule {
                wire: "verificationStateDescription",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1000),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "RegisterCACertificate",
        method: "POST",
        segs: &[Seg::Fixed("cacertificate")],
        verb: Verb::Action,
        rtype: "cacertificate",
        nlabels: 0,
        has_input: true,
        errors: &[
            "CertificateValidationException",
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "RegistrationCodeValidationException",
            "ResourceAlreadyExistsException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "caCertificate",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(65536),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "verificationCertificate",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(65536),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "certificateMode",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["DEFAULT", "SNI_ONLY"],
            },
        ],
        omembers: &[("certificateArn", K::Str), ("certificateId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "RegisterCertificate",
        method: "POST",
        segs: &[Seg::Fixed("certificate"), Seg::Fixed("register")],
        verb: Verb::Action,
        rtype: "certificate",
        nlabels: 0,
        has_input: true,
        errors: &[
            "CertificateConflictException",
            "CertificateStateException",
            "CertificateValidationException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceAlreadyExistsException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "certificatePem",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(65536),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "caCertificatePem",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(65536),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "status",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "ACTIVE",
                    "INACTIVE",
                    "REVOKED",
                    "PENDING_TRANSFER",
                    "REGISTER_INACTIVE",
                    "PENDING_ACTIVATION",
                ],
            },
        ],
        omembers: &[("certificateArn", K::Str), ("certificateId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "RegisterCertificateWithoutCA",
        method: "POST",
        segs: &[Seg::Fixed("certificate"), Seg::Fixed("register-no-ca")],
        verb: Verb::Action,
        rtype: "certificate",
        nlabels: 0,
        has_input: true,
        errors: &[
            "CertificateStateException",
            "CertificateValidationException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceAlreadyExistsException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "certificatePem",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(65536),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "status",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "ACTIVE",
                    "INACTIVE",
                    "REVOKED",
                    "PENDING_TRANSFER",
                    "REGISTER_INACTIVE",
                    "PENDING_ACTIVATION",
                ],
            },
        ],
        omembers: &[("certificateArn", K::Str), ("certificateId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "RegisterThing",
        method: "POST",
        segs: &[Seg::Fixed("things")],
        verb: Verb::Action,
        rtype: "things",
        nlabels: 0,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceRegistrationFailureException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "templateBody",
            src: Src::Body,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(10240),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("certificatePem", K::Str), ("resourceArns", K::Map)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "RejectCertificateTransfer",
        method: "PATCH",
        segs: &[
            Seg::Fixed("reject-certificate-transfer"),
            Seg::Label("certificateId"),
        ],
        verb: Verb::Action,
        rtype: "reject-certificate-transfer",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "TransferAlreadyCompletedException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "certificateId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(64),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "rejectReason",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "RemoveThingFromBillingGroup",
        method: "PUT",
        segs: &[
            Seg::Fixed("billing-groups"),
            Seg::Fixed("removeThingFromBillingGroup"),
        ],
        verb: Verb::Action,
        rtype: "billing-groups",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "billingGroupName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "RemoveThingFromThingGroup",
        method: "PUT",
        segs: &[
            Seg::Fixed("thing-groups"),
            Seg::Fixed("removeThingFromThingGroup"),
        ],
        verb: Verb::Action,
        rtype: "thing-groups",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "thingGroupName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ReplaceTopicRule",
        method: "PATCH",
        segs: &[Seg::Fixed("rules"), Seg::Label("ruleName")],
        verb: Verb::Action,
        rtype: "rules",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "SqlParseException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "ruleName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: true,
    },
    OpMeta {
        op: "SearchIndex",
        method: "POST",
        segs: &[Seg::Fixed("indices"), Seg::Fixed("search")],
        verb: Verb::Action,
        rtype: "indices",
        nlabels: 0,
        has_input: true,
        errors: &[
            "IndexNotReadyException",
            "InternalFailureException",
            "InvalidQueryException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "indexName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "queryString",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "maxResults",
                src: Src::Body,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("nextToken", K::Str),
            ("things", K::List),
            ("thingGroups", K::List),
        ],
        list_field: Some("things"),
        list_elems: &[
            ("thingName", K::Str),
            ("thingId", K::Str),
            ("thingTypeName", K::Str),
            ("thingGroupNames", K::List),
            ("attributes", K::Map),
            ("shadow", K::Str),
            ("deviceDefender", K::Str),
            ("connectivity", K::Struct),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "SetDefaultAuthorizer",
        method: "POST",
        segs: &[Seg::Fixed("default-authorizer")],
        verb: Verb::Action,
        rtype: "default-authorizer",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceAlreadyExistsException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "authorizerName",
            src: Src::Body,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("authorizerName", K::Str), ("authorizerArn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "SetDefaultPolicyVersion",
        method: "PATCH",
        segs: &[
            Seg::Fixed("policies"),
            Seg::Label("policyName"),
            Seg::Fixed("version"),
            Seg::Label("policyVersionId"),
        ],
        verb: Verb::Action,
        rtype: "policies",
        nlabels: 2,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "policyName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "policyVersionId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "SetLoggingOptions",
        method: "POST",
        segs: &[Seg::Fixed("loggingOptions")],
        verb: Verb::Action,
        rtype: "loggingOptions",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
        ],
        rules: &[],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: true,
    },
    OpMeta {
        op: "SetV2LoggingLevel",
        method: "POST",
        segs: &[Seg::Fixed("v2LoggingLevel")],
        verb: Verb::Action,
        rtype: "v2LoggingLevel",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalException",
            "InvalidRequestException",
            "LimitExceededException",
            "NotConfiguredException",
            "ServiceUnavailableException",
        ],
        rules: &[
            Rule {
                wire: "logTarget",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "logLevel",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["DEBUG", "INFO", "ERROR", "WARN", "DISABLED"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "SetV2LoggingOptions",
        method: "POST",
        segs: &[Seg::Fixed("v2LoggingOptions")],
        verb: Verb::Action,
        rtype: "v2LoggingOptions",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
        ],
        rules: &[Rule {
            wire: "defaultLogLevel",
            src: Src::Body,
            req: false,
            kind: K::Str,
            min_len: None,
            max_len: None,
            min_val: None,
            max_val: None,
            enums: &["DEBUG", "INFO", "ERROR", "WARN", "DISABLED"],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "StartAuditMitigationActionsTask",
        method: "POST",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("tasks"),
            Seg::Label("taskId"),
        ],
        verb: Verb::Action,
        rtype: "audit",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "TaskAlreadyExistsException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "taskId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "target",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "auditCheckToActionsMapping",
                src: Src::Body,
                req: true,
                kind: K::Map,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientRequestToken",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("taskId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "StartDetectMitigationActionsTask",
        method: "PUT",
        segs: &[
            Seg::Fixed("detect"),
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("tasks"),
            Seg::Label("taskId"),
        ],
        verb: Verb::Action,
        rtype: "detect",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "TaskAlreadyExistsException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "taskId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "target",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "actions",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: Some(1),
                max_len: Some(5),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientRequestToken",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("taskId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "StartOnDemandAuditTask",
        method: "POST",
        segs: &[Seg::Fixed("audit"), Seg::Fixed("tasks")],
        verb: Verb::Action,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "targetCheckNames",
            src: Src::Body,
            req: true,
            kind: K::List,
            min_len: None,
            max_len: None,
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("taskId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "StartThingRegistrationTask",
        method: "POST",
        segs: &[Seg::Fixed("thing-registration-tasks")],
        verb: Verb::Action,
        rtype: "thing-registration-tasks",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "templateBody",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(10240),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "inputFileBucket",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(3),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "inputFileKey",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "roleArn",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(20),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("taskId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "StopThingRegistrationTask",
        method: "PUT",
        segs: &[
            Seg::Fixed("thing-registration-tasks"),
            Seg::Label("taskId"),
            Seg::Fixed("cancel"),
        ],
        verb: Verb::Action,
        rtype: "thing-registration-tasks",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "taskId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(40),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "TagResource",
        method: "POST",
        segs: &[Seg::Fixed("tags")],
        verb: Verb::Action,
        rtype: "tags",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "resourceArn",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "tags",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "TestAuthorization",
        method: "POST",
        segs: &[Seg::Fixed("test-authorization")],
        verb: Verb::Action,
        rtype: "test-authorization",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "authInfos",
            src: Src::Body,
            req: true,
            kind: K::List,
            min_len: Some(1),
            max_len: Some(10),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("authResults", K::List)],
        list_field: Some("authResults"),
        list_elems: &[
            ("authInfo", K::Struct),
            ("allowed", K::Struct),
            ("denied", K::Struct),
            ("authDecision", K::Str),
            ("missingContextValues", K::List),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "TestInvokeAuthorizer",
        method: "POST",
        segs: &[
            Seg::Fixed("authorizer"),
            Seg::Label("authorizerName"),
            Seg::Fixed("test"),
        ],
        verb: Verb::Action,
        rtype: "authorizer",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "InvalidResponseException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "authorizerName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "token",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(6144),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "tokenSignature",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(2560),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("isAuthenticated", K::Bool),
            ("principalId", K::Str),
            ("policyDocuments", K::List),
            ("refreshAfterInSeconds", K::Int),
            ("disconnectAfterInSeconds", K::Int),
        ],
        list_field: Some("policyDocuments"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "TransferCertificate",
        method: "PATCH",
        segs: &[
            Seg::Fixed("transfer-certificate"),
            Seg::Label("certificateId"),
        ],
        verb: Verb::Action,
        rtype: "transfer-certificate",
        nlabels: 1,
        has_input: true,
        errors: &[
            "CertificateStateException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "TransferConflictException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "certificateId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(64),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "targetAwsAccount",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: Some(12),
                max_len: Some(12),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "transferMessage",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("transferredCertificateArn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UntagResource",
        method: "POST",
        segs: &[Seg::Fixed("untag")],
        verb: Verb::Action,
        rtype: "untag",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "resourceArn",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "tagKeys",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateAccountAuditConfiguration",
        method: "PATCH",
        segs: &[Seg::Fixed("audit"), Seg::Fixed("configuration")],
        verb: Verb::Action,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "roleArn",
            src: Src::Body,
            req: false,
            kind: K::Str,
            min_len: Some(20),
            max_len: Some(2048),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateAuditSuppression",
        method: "PATCH",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("suppressions"),
            Seg::Fixed("update"),
        ],
        verb: Verb::Action,
        rtype: "audit",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "checkName",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceIdentifier",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1000),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateAuthorizer",
        method: "PUT",
        segs: &[Seg::Fixed("authorizer"), Seg::Label("authorizerName")],
        verb: Verb::Update,
        rtype: "authorizer",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "authorizerName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "authorizerFunctionArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "tokenKeyName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "status",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["ACTIVE", "INACTIVE"],
            },
        ],
        omembers: &[("authorizerName", K::Str), ("authorizerArn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateBillingGroup",
        method: "PATCH",
        segs: &[Seg::Fixed("billing-groups"), Seg::Label("billingGroupName")],
        verb: Verb::Update,
        rtype: "billing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "VersionConflictException",
        ],
        rules: &[
            Rule {
                wire: "billingGroupName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "billingGroupProperties",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("version", K::Int)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateCACertificate",
        method: "PUT",
        segs: &[Seg::Fixed("cacertificate"), Seg::Label("certificateId")],
        verb: Verb::Update,
        rtype: "cacertificate",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "certificateId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(64),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "newStatus",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["ACTIVE", "INACTIVE"],
            },
            Rule {
                wire: "newAutoRegistrationStatus",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["ENABLE", "DISABLE"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateCertificate",
        method: "PUT",
        segs: &[Seg::Fixed("certificates"), Seg::Label("certificateId")],
        verb: Verb::Update,
        rtype: "certificates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "CertificateStateException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "certificateId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(64),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "newStatus",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "ACTIVE",
                    "INACTIVE",
                    "REVOKED",
                    "PENDING_TRANSFER",
                    "REGISTER_INACTIVE",
                    "PENDING_ACTIVATION",
                ],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateCertificateProvider",
        method: "PUT",
        segs: &[
            Seg::Fixed("certificate-providers"),
            Seg::Label("certificateProviderName"),
        ],
        verb: Verb::Update,
        rtype: "certificate-providers",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "certificateProviderName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "lambdaFunctionArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "accountDefaultForOperations",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(1),
                max_len: Some(1),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("certificateProviderName", K::Str),
            ("certificateProviderArn", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateCommand",
        method: "PATCH",
        segs: &[Seg::Fixed("commands"), Seg::Label("commandId")],
        verb: Verb::Update,
        rtype: "commands",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "commandId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "displayName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2028),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("commandId", K::Str),
            ("displayName", K::Str),
            ("description", K::Str),
            ("deprecated", K::Bool),
            ("lastUpdatedAt", K::Ts),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateCustomMetric",
        method: "PATCH",
        segs: &[Seg::Fixed("custom-metric"), Seg::Label("metricName")],
        verb: Verb::Update,
        rtype: "custom-metric",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "metricName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "displayName",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("metricName", K::Str),
            ("metricArn", K::Str),
            ("metricType", K::Str),
            ("displayName", K::Str),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateDimension",
        method: "PATCH",
        segs: &[Seg::Fixed("dimensions"), Seg::Label("name")],
        verb: Verb::Update,
        rtype: "dimensions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "name",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "stringValues",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: Some(1),
                max_len: Some(100),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("name", K::Str),
            ("arn", K::Str),
            ("type", K::Str),
            ("stringValues", K::List),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
        ],
        list_field: Some("stringValues"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateDomainConfiguration",
        method: "PUT",
        segs: &[
            Seg::Fixed("domainConfigurations"),
            Seg::Label("domainConfigurationName"),
        ],
        verb: Verb::Update,
        rtype: "domainConfigurations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "CertificateValidationException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "domainConfigurationName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "domainConfigurationStatus",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["ENABLED", "DISABLED"],
            },
            Rule {
                wire: "authenticationType",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "CUSTOM_AUTH_X509",
                    "CUSTOM_AUTH",
                    "AWS_X509",
                    "AWS_SIGV4",
                    "DEFAULT",
                ],
            },
            Rule {
                wire: "applicationProtocol",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["SECURE_MQTT", "MQTT_WSS", "HTTPS", "DEFAULT"],
            },
        ],
        omembers: &[
            ("domainConfigurationName", K::Str),
            ("domainConfigurationArn", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateDynamicThingGroup",
        method: "PATCH",
        segs: &[
            Seg::Fixed("dynamic-thing-groups"),
            Seg::Label("thingGroupName"),
        ],
        verb: Verb::Update,
        rtype: "dynamic-thing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidQueryException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "VersionConflictException",
        ],
        rules: &[
            Rule {
                wire: "thingGroupName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingGroupProperties",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "indexName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "queryString",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("version", K::Int)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateEncryptionConfiguration",
        method: "PATCH",
        segs: &[Seg::Fixed("encryption-configuration")],
        verb: Verb::Action,
        rtype: "encryption-configuration",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "encryptionType",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["CUSTOMER_MANAGED_KMS_KEY", "AWS_OWNED_KMS_KEY"],
            },
            Rule {
                wire: "kmsKeyArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "kmsAccessRoleArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateEventConfigurations",
        method: "PATCH",
        segs: &[Seg::Fixed("event-configurations")],
        verb: Verb::Action,
        rtype: "event-configurations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateFleetMetric",
        method: "PATCH",
        segs: &[Seg::Fixed("fleet-metric"), Seg::Label("metricName")],
        verb: Verb::Update,
        rtype: "fleet-metric",
        nlabels: 1,
        has_input: true,
        errors: &[
            "IndexNotReadyException",
            "InternalFailureException",
            "InvalidAggregationException",
            "InvalidQueryException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
            "VersionConflictException",
        ],
        rules: &[
            Rule {
                wire: "metricName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "queryString",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "period",
                src: Src::Body,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(60),
                max_val: Some(86400),
                enums: &[],
            },
            Rule {
                wire: "aggregationField",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "indexName",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "unit",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "Seconds",
                    "Microseconds",
                    "Milliseconds",
                    "Bytes",
                    "Kilobytes",
                    "Megabytes",
                    "Gigabytes",
                    "Terabytes",
                    "Bits",
                    "Kilobits",
                    "Megabits",
                    "Gigabits",
                    "Terabits",
                    "Percent",
                    "Count",
                    "Bytes/Second",
                    "Kilobytes/Second",
                    "Megabytes/Second",
                    "Gigabytes/Second",
                    "Terabytes/Second",
                    "Bits/Second",
                    "Kilobits/Second",
                    "Megabits/Second",
                    "Gigabits/Second",
                    "Terabits/Second",
                    "Count/Second",
                    "None",
                ],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateIndexingConfiguration",
        method: "POST",
        segs: &[Seg::Fixed("indexing"), Seg::Fixed("config")],
        verb: Verb::Action,
        rtype: "indexing",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateJob",
        method: "PATCH",
        segs: &[Seg::Fixed("jobs"), Seg::Label("jobId")],
        verb: Verb::Update,
        rtype: "jobs",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "jobId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2028),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateMitigationAction",
        method: "PATCH",
        segs: &[
            Seg::Fixed("mitigationactions"),
            Seg::Fixed("actions"),
            Seg::Label("actionName"),
        ],
        verb: Verb::Update,
        rtype: "mitigationactions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "actionName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "roleArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(20),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("actionArn", K::Str), ("actionId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdatePackage",
        method: "PATCH",
        segs: &[Seg::Fixed("packages"), Seg::Label("packageName")],
        verb: Verb::Update,
        rtype: "packages",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "packageName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "defaultVersionName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(36),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdatePackageConfiguration",
        method: "PATCH",
        segs: &[Seg::Fixed("package-configuration")],
        verb: Verb::Action,
        rtype: "package-configuration",
        nlabels: 0,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "clientToken",
            src: Src::Query,
            req: false,
            kind: K::Str,
            min_len: Some(36),
            max_len: Some(64),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdatePackageVersion",
        method: "PATCH",
        segs: &[
            Seg::Fixed("packages"),
            Seg::Label("packageName"),
            Seg::Fixed("versions"),
            Seg::Label("versionName"),
        ],
        verb: Verb::Update,
        rtype: "packages",
        nlabels: 2,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "packageName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "versionName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "action",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["PUBLISH", "DEPRECATE"],
            },
            Rule {
                wire: "recipe",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(3072),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "clientToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(36),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateProvisioningTemplate",
        method: "PATCH",
        segs: &[
            Seg::Fixed("provisioning-templates"),
            Seg::Label("templateName"),
        ],
        verb: Verb::Update,
        rtype: "provisioning-templates",
        nlabels: 1,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "templateName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(36),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(500),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "provisioningRoleArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(20),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateRoleAlias",
        method: "PUT",
        segs: &[Seg::Fixed("role-aliases"), Seg::Label("roleAlias")],
        verb: Verb::Update,
        rtype: "role-aliases",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "roleAlias",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "roleArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(20),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "credentialDurationSeconds",
                src: Src::Body,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(900),
                max_val: Some(43200),
                enums: &[],
            },
        ],
        omembers: &[("roleAlias", K::Str), ("roleAliasArn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateScheduledAudit",
        method: "PATCH",
        segs: &[
            Seg::Fixed("audit"),
            Seg::Fixed("scheduledaudits"),
            Seg::Label("scheduledAuditName"),
        ],
        verb: Verb::Update,
        rtype: "audit",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[
            Rule {
                wire: "frequency",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["DAILY", "WEEKLY", "BIWEEKLY", "MONTHLY"],
            },
            Rule {
                wire: "dayOfWeek",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"],
            },
            Rule {
                wire: "scheduledAuditName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("scheduledAuditArn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateSecurityProfile",
        method: "PATCH",
        segs: &[
            Seg::Fixed("security-profiles"),
            Seg::Label("securityProfileName"),
        ],
        verb: Verb::Update,
        rtype: "security-profiles",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "VersionConflictException",
        ],
        rules: &[
            Rule {
                wire: "securityProfileName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "securityProfileDescription",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(1000),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "behaviors",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(100),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("securityProfileName", K::Str),
            ("securityProfileArn", K::Str),
            ("securityProfileDescription", K::Str),
            ("behaviors", K::List),
            ("alertTargets", K::Map),
            ("additionalMetricsToRetain", K::List),
            ("additionalMetricsToRetainV2", K::List),
            ("version", K::Int),
            ("creationDate", K::Ts),
            ("lastModifiedDate", K::Ts),
            ("metricsExportConfig", K::Struct),
        ],
        list_field: Some("behaviors"),
        list_elems: &[
            ("name", K::Str),
            ("metric", K::Str),
            ("metricDimension", K::Struct),
            ("criteria", K::Struct),
            ("suppressAlerts", K::Bool),
            ("exportMetric", K::Bool),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateStream",
        method: "PUT",
        segs: &[Seg::Fixed("streams"), Seg::Label("streamId")],
        verb: Verb::Update,
        rtype: "streams",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "LimitExceededException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "streamId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "description",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2028),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "files",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(1),
                max_len: Some(50),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "roleArn",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(20),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("streamId", K::Str),
            ("streamArn", K::Str),
            ("description", K::Str),
            ("streamVersion", K::Int),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateThing",
        method: "PATCH",
        segs: &[Seg::Fixed("things"), Seg::Label("thingName")],
        verb: Verb::Update,
        rtype: "things",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
            "VersionConflictException",
        ],
        rules: &[
            Rule {
                wire: "thingName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingTypeName",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateThingGroup",
        method: "PATCH",
        segs: &[Seg::Fixed("thing-groups"), Seg::Label("thingGroupName")],
        verb: Verb::Update,
        rtype: "thing-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "VersionConflictException",
        ],
        rules: &[
            Rule {
                wire: "thingGroupName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "thingGroupProperties",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("version", K::Int)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateThingGroupsForThing",
        method: "PUT",
        segs: &[
            Seg::Fixed("thing-groups"),
            Seg::Fixed("updateThingGroupsForThing"),
        ],
        verb: Verb::Action,
        rtype: "thing-groups",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "thingName",
            src: Src::Body,
            req: false,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateThingType",
        method: "PATCH",
        segs: &[Seg::Fixed("thing-types"), Seg::Label("thingTypeName")],
        verb: Verb::Update,
        rtype: "thing-types",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ResourceNotFoundException",
            "ServiceUnavailableException",
            "ThrottlingException",
            "UnauthorizedException",
        ],
        rules: &[Rule {
            wire: "thingTypeName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateTopicRuleDestination",
        method: "PATCH",
        segs: &[Seg::Fixed("destinations")],
        verb: Verb::Action,
        rtype: "destinations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "ConflictingResourceUpdateException",
            "InternalException",
            "InvalidRequestException",
            "ServiceUnavailableException",
            "UnauthorizedException",
        ],
        rules: &[
            Rule {
                wire: "arn",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "status",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["ENABLED", "IN_PROGRESS", "DISABLED", "ERROR", "DELETING"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ValidateSecurityProfileBehaviors",
        method: "POST",
        segs: &[
            Seg::Fixed("security-profile-behaviors"),
            Seg::Fixed("validate"),
        ],
        verb: Verb::Action,
        rtype: "security-profile-behaviors",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalFailureException",
            "InvalidRequestException",
            "ThrottlingException",
        ],
        rules: &[Rule {
            wire: "behaviors",
            src: Src::Body,
            req: true,
            kind: K::List,
            min_len: Some(0),
            max_len: Some(100),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("valid", K::Bool), ("validationErrors", K::List)],
        list_field: Some("validationErrors"),
        list_elems: &[("errorMessage", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
];

pub static ACTIONS: &[&str] = &[
    "AcceptCertificateTransfer",
    "AddThingToBillingGroup",
    "AddThingToThingGroup",
    "AssociateSbomWithPackageVersion",
    "AssociateTargetsWithJob",
    "AttachPolicy",
    "AttachPrincipalPolicy",
    "AttachSecurityProfile",
    "AttachThingPrincipal",
    "CancelAuditMitigationActionsTask",
    "CancelAuditTask",
    "CancelCertificateTransfer",
    "CancelDetectMitigationActionsTask",
    "CancelJob",
    "CancelJobExecution",
    "ClearDefaultAuthorizer",
    "ConfirmTopicRuleDestination",
    "CreateAuditSuppression",
    "CreateAuthorizer",
    "CreateBillingGroup",
    "CreateCertificateFromCsr",
    "CreateCertificateProvider",
    "CreateCommand",
    "CreateCustomMetric",
    "CreateDimension",
    "CreateDomainConfiguration",
    "CreateDynamicThingGroup",
    "CreateFleetMetric",
    "CreateJob",
    "CreateJobTemplate",
    "CreateKeysAndCertificate",
    "CreateMitigationAction",
    "CreateOTAUpdate",
    "CreatePackage",
    "CreatePackageVersion",
    "CreatePolicy",
    "CreatePolicyVersion",
    "CreateProvisioningClaim",
    "CreateProvisioningTemplate",
    "CreateProvisioningTemplateVersion",
    "CreateRoleAlias",
    "CreateScheduledAudit",
    "CreateSecurityProfile",
    "CreateStream",
    "CreateThing",
    "CreateThingGroup",
    "CreateThingType",
    "CreateTopicRule",
    "CreateTopicRuleDestination",
    "DeleteAccountAuditConfiguration",
    "DeleteAuditSuppression",
    "DeleteAuthorizer",
    "DeleteBillingGroup",
    "DeleteCACertificate",
    "DeleteCertificate",
    "DeleteCertificateProvider",
    "DeleteCommand",
    "DeleteCommandExecution",
    "DeleteCustomMetric",
    "DeleteDimension",
    "DeleteDomainConfiguration",
    "DeleteDynamicThingGroup",
    "DeleteFleetMetric",
    "DeleteJob",
    "DeleteJobExecution",
    "DeleteJobTemplate",
    "DeleteMitigationAction",
    "DeleteOTAUpdate",
    "DeletePackage",
    "DeletePackageVersion",
    "DeletePolicy",
    "DeletePolicyVersion",
    "DeleteProvisioningTemplate",
    "DeleteProvisioningTemplateVersion",
    "DeleteRegistrationCode",
    "DeleteRoleAlias",
    "DeleteScheduledAudit",
    "DeleteSecurityProfile",
    "DeleteStream",
    "DeleteThing",
    "DeleteThingGroup",
    "DeleteThingType",
    "DeleteTopicRule",
    "DeleteTopicRuleDestination",
    "DeleteV2LoggingLevel",
    "DeprecateThingType",
    "DescribeAccountAuditConfiguration",
    "DescribeAuditFinding",
    "DescribeAuditMitigationActionsTask",
    "DescribeAuditSuppression",
    "DescribeAuditTask",
    "DescribeAuthorizer",
    "DescribeBillingGroup",
    "DescribeCACertificate",
    "DescribeCertificate",
    "DescribeCertificateProvider",
    "DescribeCustomMetric",
    "DescribeDefaultAuthorizer",
    "DescribeDetectMitigationActionsTask",
    "DescribeDimension",
    "DescribeDomainConfiguration",
    "DescribeEncryptionConfiguration",
    "DescribeEndpoint",
    "DescribeEventConfigurations",
    "DescribeFleetMetric",
    "DescribeIndex",
    "DescribeJob",
    "DescribeJobExecution",
    "DescribeJobTemplate",
    "DescribeManagedJobTemplate",
    "DescribeMitigationAction",
    "DescribeProvisioningTemplate",
    "DescribeProvisioningTemplateVersion",
    "DescribeRoleAlias",
    "DescribeScheduledAudit",
    "DescribeSecurityProfile",
    "DescribeStream",
    "DescribeThing",
    "DescribeThingGroup",
    "DescribeThingRegistrationTask",
    "DescribeThingType",
    "DetachPolicy",
    "DetachPrincipalPolicy",
    "DetachSecurityProfile",
    "DetachThingPrincipal",
    "DisableTopicRule",
    "DisassociateSbomFromPackageVersion",
    "EnableTopicRule",
    "GetBehaviorModelTrainingSummaries",
    "GetBucketsAggregation",
    "GetCardinality",
    "GetCommand",
    "GetCommandExecution",
    "GetEffectivePolicies",
    "GetIndexingConfiguration",
    "GetJobDocument",
    "GetLoggingOptions",
    "GetOTAUpdate",
    "GetPackage",
    "GetPackageConfiguration",
    "GetPackageVersion",
    "GetPercentiles",
    "GetPolicy",
    "GetPolicyVersion",
    "GetRegistrationCode",
    "GetStatistics",
    "GetThingConnectivityData",
    "GetTopicRule",
    "GetTopicRuleDestination",
    "GetV2LoggingOptions",
    "ListActiveViolations",
    "ListAttachedPolicies",
    "ListAuditFindings",
    "ListAuditMitigationActionsExecutions",
    "ListAuditMitigationActionsTasks",
    "ListAuditSuppressions",
    "ListAuditTasks",
    "ListAuthorizers",
    "ListBillingGroups",
    "ListCACertificates",
    "ListCertificateProviders",
    "ListCertificates",
    "ListCertificatesByCA",
    "ListCommandExecutions",
    "ListCommands",
    "ListCustomMetrics",
    "ListDetectMitigationActionsExecutions",
    "ListDetectMitigationActionsTasks",
    "ListDimensions",
    "ListDomainConfigurations",
    "ListFleetMetrics",
    "ListIndices",
    "ListJobExecutionsForJob",
    "ListJobExecutionsForThing",
    "ListJobTemplates",
    "ListJobs",
    "ListManagedJobTemplates",
    "ListMetricValues",
    "ListMitigationActions",
    "ListOTAUpdates",
    "ListOutgoingCertificates",
    "ListPackageVersions",
    "ListPackages",
    "ListPolicies",
    "ListPolicyPrincipals",
    "ListPolicyVersions",
    "ListPrincipalPolicies",
    "ListPrincipalThings",
    "ListPrincipalThingsV2",
    "ListProvisioningTemplateVersions",
    "ListProvisioningTemplates",
    "ListRelatedResourcesForAuditFinding",
    "ListRoleAliases",
    "ListSbomValidationResults",
    "ListScheduledAudits",
    "ListSecurityProfiles",
    "ListSecurityProfilesForTarget",
    "ListStreams",
    "ListTagsForResource",
    "ListTargetsForPolicy",
    "ListTargetsForSecurityProfile",
    "ListThingGroups",
    "ListThingGroupsForThing",
    "ListThingPrincipals",
    "ListThingPrincipalsV2",
    "ListThingRegistrationTaskReports",
    "ListThingRegistrationTasks",
    "ListThingTypes",
    "ListThings",
    "ListThingsInBillingGroup",
    "ListThingsInThingGroup",
    "ListTopicRuleDestinations",
    "ListTopicRules",
    "ListV2LoggingLevels",
    "ListViolationEvents",
    "PutVerificationStateOnViolation",
    "RegisterCACertificate",
    "RegisterCertificate",
    "RegisterCertificateWithoutCA",
    "RegisterThing",
    "RejectCertificateTransfer",
    "RemoveThingFromBillingGroup",
    "RemoveThingFromThingGroup",
    "ReplaceTopicRule",
    "SearchIndex",
    "SetDefaultAuthorizer",
    "SetDefaultPolicyVersion",
    "SetLoggingOptions",
    "SetV2LoggingLevel",
    "SetV2LoggingOptions",
    "StartAuditMitigationActionsTask",
    "StartDetectMitigationActionsTask",
    "StartOnDemandAuditTask",
    "StartThingRegistrationTask",
    "StopThingRegistrationTask",
    "TagResource",
    "TestAuthorization",
    "TestInvokeAuthorizer",
    "TransferCertificate",
    "UntagResource",
    "UpdateAccountAuditConfiguration",
    "UpdateAuditSuppression",
    "UpdateAuthorizer",
    "UpdateBillingGroup",
    "UpdateCACertificate",
    "UpdateCertificate",
    "UpdateCertificateProvider",
    "UpdateCommand",
    "UpdateCustomMetric",
    "UpdateDimension",
    "UpdateDomainConfiguration",
    "UpdateDynamicThingGroup",
    "UpdateEncryptionConfiguration",
    "UpdateEventConfigurations",
    "UpdateFleetMetric",
    "UpdateIndexingConfiguration",
    "UpdateJob",
    "UpdateMitigationAction",
    "UpdatePackage",
    "UpdatePackageConfiguration",
    "UpdatePackageVersion",
    "UpdateProvisioningTemplate",
    "UpdateRoleAlias",
    "UpdateScheduledAudit",
    "UpdateSecurityProfile",
    "UpdateStream",
    "UpdateThing",
    "UpdateThingGroup",
    "UpdateThingGroupsForThing",
    "UpdateThingType",
    "UpdateTopicRuleDestination",
    "ValidateSecurityProfileBehaviors",
];